From ba37cf3fc21b820e6d4ecf62201bfc3d2c955463 Mon Sep 17 00:00:00 2001 From: Marijn Suijten Date: Tue, 22 Nov 2022 23:13:09 +0100 Subject: [PATCH] Update Vulkan-Headers to 1.3.235 (#667) * Update Vulkan-Headers to 1.3.229 * Update Vulkan-Headers to 1.3.230 * Update Vulkan-Headers to 1.3.231 * Update Vulkan-Headers to 1.3.232 * Update Vulkan-Headers to 1.3.233 * Update Vulkan-Headers to 1.3.235 * README: Document experimental Vulkan Video bindings being semver-exempt --- Changelog.md | 2 +- README.md | 5 + ash/Cargo.toml | 2 +- ash/src/vk/bitflags.rs | 79 + ash/src/vk/const_debugs.rs | 572 +++++- ash/src/vk/definitions.rs | 3802 +++++++++++++++++++++++++++++++++--- ash/src/vk/enums.rs | 218 +++ ash/src/vk/extensions.rs | 2450 +++++++++++++++++++++-- ash/src/vk/native.rs | 2245 +++++++++++++-------- generator/Vulkan-Headers | 2 +- 10 files changed, 8130 insertions(+), 1247 deletions(-) diff --git a/Changelog.md b/Changelog.md index b9c25e6..104b147 100644 --- a/Changelog.md +++ b/Changelog.md @@ -16,7 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Added `VK_EXT_image_drm_format_modifier` device extension (#603) -- Update Vulkan-Headers to 1.3.228 (#605, #608, #619, #655) +- Update Vulkan-Headers to 1.3.235 (#605, #608, #619, #655, #667) - Added `const STRUCTURE_TYPE` to all Vulkan structures for matching with `match_struct!` macro (#614) - Added `VK_EXT_sample_locations` device extension (#616) - Added `VK_NV_coverage_reduction_mode` device extension (#617) diff --git a/README.md b/README.md index 3cf318f..12c0892 100644 --- a/README.md +++ b/README.md @@ -18,6 +18,11 @@ A very lightweight wrapper around Vulkan - [x] Generated from `vk.xml` - [x] Support for Vulkan `1.1`, `1.2`, `1.3` +## ⚠️ Semver compatibility warning +The Vulkan Video bindings are experimental and still seeing breaking changes in their upstream specification, and are only provided by Ash for early adopters. All related functions and types are semver-exempt [^1] (we allow breaking API changes while releasing Ash with non-breaking semver bumps). + +[^1]: `generator` complexity makes it so that we cannot easily hide these bindings behind a non-`default` feature flag, and they are widespread across the generated codebase. + ## Features ### Explicit returns with `Result` ```rust diff --git a/ash/Cargo.toml b/ash/Cargo.toml index c29d720..e398790 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.228" +version = "0.37.0+1.3.235" authors = ["maik klein "] description = "Vulkan bindings for Rust" license = "MIT OR Apache-2.0" diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index 88b35b2..bc3ccde 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -923,6 +923,14 @@ impl PipelineCreationFeedbackFlags { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MemoryDecompressionMethodFlagsNV(pub(crate) Flags64); +vk_bitflags_wrapped!(MemoryDecompressionMethodFlagsNV, Flags64); +impl MemoryDecompressionMethodFlagsNV { + pub const GDEFLATE_1_0: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct PerformanceCounterDescriptionFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(PerformanceCounterDescriptionFlagsKHR, Flags); @@ -1127,6 +1135,14 @@ impl GraphicsPipelineLibraryFlagsEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct DeviceAddressBindingFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(DeviceAddressBindingFlagsEXT, Flags); +impl DeviceAddressBindingFlagsEXT { + pub const INTERNAL_OBJECT: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct VideoCodecOperationFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(VideoCodecOperationFlagsKHR, Flags); @@ -1542,3 +1558,66 @@ impl ImageCompressionFixedRateFlagsEXT { pub const TYPE_23BPC: Self = Self(0b100_0000_0000_0000_0000_0000); pub const TYPE_24BPC: Self = Self(0b1000_0000_0000_0000_0000_0000); } +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowGridSizeFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowGridSizeFlagsNV, Flags); +impl OpticalFlowGridSizeFlagsNV { + pub const UNKNOWN: Self = Self(0); + pub const TYPE_1X1: Self = Self(0b1); + pub const TYPE_2X2: Self = Self(0b10); + pub const TYPE_4X4: Self = Self(0b100); + pub const TYPE_8X8: Self = Self(0b1000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowUsageFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowUsageFlagsNV, Flags); +impl OpticalFlowUsageFlagsNV { + pub const UNKNOWN: Self = Self(0); + pub const INPUT: Self = Self(0b1); + pub const OUTPUT: Self = Self(0b10); + pub const HINT: Self = Self(0b100); + pub const COST: Self = Self(0b1000); + pub const GLOBAL_FLOW: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowSessionCreateFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowSessionCreateFlagsNV, Flags); +impl OpticalFlowSessionCreateFlagsNV { + pub const ENABLE_HINT: Self = Self(0b1); + pub const ENABLE_COST: Self = Self(0b10); + pub const ENABLE_GLOBAL_FLOW: Self = Self(0b100); + pub const ALLOW_REGIONS: Self = Self(0b1000); + pub const BOTH_DIRECTIONS: Self = Self(0b1_0000); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct OpticalFlowExecuteFlagsNV(pub(crate) Flags); +vk_bitflags_wrapped!(OpticalFlowExecuteFlagsNV, Flags); +impl OpticalFlowExecuteFlagsNV { + pub const DISABLE_TEMPORAL_HINTS: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct BuildMicromapFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(BuildMicromapFlagsEXT, Flags); +impl BuildMicromapFlagsEXT { + pub const PREFER_FAST_TRACE: Self = Self(0b1); + pub const PREFER_FAST_BUILD: Self = Self(0b10); + pub const ALLOW_COMPACTION: Self = Self(0b100); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct MicromapCreateFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(MicromapCreateFlagsEXT, Flags); +impl MicromapCreateFlagsEXT { + pub const DEVICE_ADDRESS_CAPTURE_REPLAY: Self = Self(0b1); +} diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index ba87c3d..141718e 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -40,8 +40,8 @@ impl fmt::Debug for AccelerationStructureCreateFlagsKHR { "DEVICE_ADDRESS_CAPTURE_REPLAY", ), ( - AccelerationStructureCreateFlagsKHR::RESERVED_3_AMD.0, - "RESERVED_3_AMD", + AccelerationStructureCreateFlagsKHR::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", ), ( AccelerationStructureCreateFlagsKHR::MOTION_NV.0, @@ -304,7 +304,10 @@ impl fmt::Debug for AccessFlags2 { AccessFlags2::COLOR_ATTACHMENT_READ_NONCOHERENT_EXT.0, "COLOR_ATTACHMENT_READ_NONCOHERENT_EXT", ), - (AccessFlags2::RESERVED_41_AMD.0, "RESERVED_41_AMD"), + ( + AccessFlags2::DESCRIPTOR_BUFFER_READ_EXT.0, + "DESCRIPTOR_BUFFER_READ_EXT", + ), ( AccessFlags2::INVOCATION_MASK_READ_HUAWEI.0, "INVOCATION_MASK_READ_HUAWEI", @@ -313,10 +316,13 @@ impl fmt::Debug for AccessFlags2 { AccessFlags2::SHADER_BINDING_TABLE_READ_KHR.0, "SHADER_BINDING_TABLE_READ_KHR", ), - (AccessFlags2::RESERVED_44_NV.0, "RESERVED_44_NV"), - (AccessFlags2::RESERVED_45_NV.0, "RESERVED_45_NV"), - (AccessFlags2::RESERVED_42_NV.0, "RESERVED_42_NV"), - (AccessFlags2::RESERVED_43_NV.0, "RESERVED_43_NV"), + (AccessFlags2::MICROMAP_READ_EXT.0, "MICROMAP_READ_EXT"), + (AccessFlags2::MICROMAP_WRITE_EXT.0, "MICROMAP_WRITE_EXT"), + (AccessFlags2::OPTICAL_FLOW_READ_NV.0, "OPTICAL_FLOW_READ_NV"), + ( + AccessFlags2::OPTICAL_FLOW_WRITE_NV.0, + "OPTICAL_FLOW_WRITE_NV", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -505,7 +511,10 @@ 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::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), (BufferCreateFlags::PROTECTED.0, "PROTECTED"), ( BufferCreateFlags::DEVICE_ADDRESS_CAPTURE_REPLAY.0, @@ -575,10 +584,26 @@ 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::RESERVED_23_NV.0, "RESERVED_23_NV"), - (BufferUsageFlags::RESERVED_24_NV.0, "RESERVED_24_NV"), + ( + BufferUsageFlags::SAMPLER_DESCRIPTOR_BUFFER_EXT.0, + "SAMPLER_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::RESOURCE_DESCRIPTOR_BUFFER_EXT.0, + "RESOURCE_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT.0, + "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT", + ), + ( + BufferUsageFlags::MICROMAP_BUILD_INPUT_READ_ONLY_EXT.0, + "MICROMAP_BUILD_INPUT_READ_ONLY_EXT", + ), + ( + BufferUsageFlags::MICROMAP_STORAGE_EXT.0, + "MICROMAP_STORAGE_EXT", + ), ( BufferUsageFlags::SHADER_DEVICE_ADDRESS.0, "SHADER_DEVICE_ADDRESS", @@ -618,12 +643,16 @@ impl fmt::Debug for BuildAccelerationStructureFlagsKHR { ), (BuildAccelerationStructureFlagsKHR::MOTION_NV.0, "MOTION_NV"), ( - BuildAccelerationStructureFlagsKHR::RESERVED_6_NV.0, - "RESERVED_6_NV", + BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_UPDATE_EXT.0, + "ALLOW_OPACITY_MICROMAP_UPDATE_EXT", ), ( - BuildAccelerationStructureFlagsKHR::RESERVED_7_NV.0, - "RESERVED_7_NV", + BuildAccelerationStructureFlagsKHR::ALLOW_DISABLE_OPACITY_MICROMAPS_EXT.0, + "ALLOW_DISABLE_OPACITY_MICROMAPS_EXT", + ), + ( + BuildAccelerationStructureFlagsKHR::ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT.0, + "ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT", ), ( BuildAccelerationStructureFlagsKHR::RESERVED_9_NV.0, @@ -651,6 +680,38 @@ impl fmt::Debug for BuildAccelerationStructureModeKHR { } } } +impl fmt::Debug for BuildMicromapFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + BuildMicromapFlagsEXT::PREFER_FAST_TRACE.0, + "PREFER_FAST_TRACE", + ), + ( + BuildMicromapFlagsEXT::PREFER_FAST_BUILD.0, + "PREFER_FAST_BUILD", + ), + ( + BuildMicromapFlagsEXT::ALLOW_COMPACTION.0, + "ALLOW_COMPACTION", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for BuildMicromapModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BUILD => Some("BUILD"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for ChromaLocation { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -906,6 +967,22 @@ impl fmt::Debug for CopyAccelerationStructureModeKHR { } } } +impl fmt::Debug for CopyMicromapModeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CLONE => Some("CLONE"), + Self::SERIALIZE => Some("SERIALIZE"), + Self::DESERIALIZE => Some("DESERIALIZE"), + Self::COMPACT => Some("COMPACT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for CoverageModulationModeNV { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -1030,6 +1107,10 @@ impl fmt::Debug for DebugUtilsMessageTypeFlagsEXT { (DebugUtilsMessageTypeFlagsEXT::GENERAL.0, "GENERAL"), (DebugUtilsMessageTypeFlagsEXT::VALIDATION.0, "VALIDATION"), (DebugUtilsMessageTypeFlagsEXT::PERFORMANCE.0, "PERFORMANCE"), + ( + DebugUtilsMessageTypeFlagsEXT::DEVICE_ADDRESS_BINDING.0, + "DEVICE_ADDRESS_BINDING", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -1108,12 +1189,12 @@ impl fmt::Debug for DescriptorSetLayoutCreateFlags { "PUSH_DESCRIPTOR_KHR", ), ( - DescriptorSetLayoutCreateFlags::RESERVED_4_AMD.0, - "RESERVED_4_AMD", + DescriptorSetLayoutCreateFlags::DESCRIPTOR_BUFFER_EXT.0, + "DESCRIPTOR_BUFFER_EXT", ), ( - DescriptorSetLayoutCreateFlags::RESERVED_5_AMD.0, - "RESERVED_5_AMD", + DescriptorSetLayoutCreateFlags::EMBEDDED_IMMUTABLE_SAMPLERS_EXT.0, + "EMBEDDED_IMMUTABLE_SAMPLERS_EXT", ), ( DescriptorSetLayoutCreateFlags::RESERVED_3_AMD.0, @@ -1180,6 +1261,29 @@ impl fmt::Debug for DescriptorUpdateTemplateType { } } } +impl fmt::Debug for DeviceAddressBindingFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + DeviceAddressBindingFlagsEXT::INTERNAL_OBJECT.0, + "INTERNAL_OBJECT", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for DeviceAddressBindingTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::BIND => Some("BIND"), + Self::UNBIND => Some("UNBIND"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for DeviceCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[]; @@ -1222,6 +1326,38 @@ impl fmt::Debug for DeviceEventTypeEXT { } } } +impl fmt::Debug for DeviceFaultAddressTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::READ_INVALID => Some("READ_INVALID"), + Self::WRITE_INVALID => Some("WRITE_INVALID"), + Self::EXECUTE_INVALID => Some("EXECUTE_INVALID"), + Self::INSTRUCTION_POINTER_UNKNOWN => Some("INSTRUCTION_POINTER_UNKNOWN"), + Self::INSTRUCTION_POINTER_INVALID => Some("INSTRUCTION_POINTER_INVALID"), + Self::INSTRUCTION_POINTER_FAULT => Some("INSTRUCTION_POINTER_FAULT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for DeviceFaultVendorBinaryHeaderVersionEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::ONE => Some("ONE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for DeviceGroupPresentModeFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -1368,6 +1504,7 @@ impl fmt::Debug for DriverId { Self::SAMSUNG_PROPRIETARY => Some("SAMSUNG_PROPRIETARY"), Self::MESA_VENUS => Some("MESA_VENUS"), Self::MESA_DOZEN => Some("MESA_DOZEN"), + Self::MESA_NVK => Some("MESA_NVK"), _ => None, }; if let Some(x) = name { @@ -1404,6 +1541,45 @@ impl fmt::Debug for DynamicState { Self::PATCH_CONTROL_POINTS_EXT => Some("PATCH_CONTROL_POINTS_EXT"), Self::LOGIC_OP_EXT => Some("LOGIC_OP_EXT"), Self::COLOR_WRITE_ENABLE_EXT => Some("COLOR_WRITE_ENABLE_EXT"), + Self::TESSELLATION_DOMAIN_ORIGIN_EXT => Some("TESSELLATION_DOMAIN_ORIGIN_EXT"), + Self::DEPTH_CLAMP_ENABLE_EXT => Some("DEPTH_CLAMP_ENABLE_EXT"), + Self::POLYGON_MODE_EXT => Some("POLYGON_MODE_EXT"), + Self::RASTERIZATION_SAMPLES_EXT => Some("RASTERIZATION_SAMPLES_EXT"), + Self::SAMPLE_MASK_EXT => Some("SAMPLE_MASK_EXT"), + Self::ALPHA_TO_COVERAGE_ENABLE_EXT => Some("ALPHA_TO_COVERAGE_ENABLE_EXT"), + Self::ALPHA_TO_ONE_ENABLE_EXT => Some("ALPHA_TO_ONE_ENABLE_EXT"), + Self::LOGIC_OP_ENABLE_EXT => Some("LOGIC_OP_ENABLE_EXT"), + Self::COLOR_BLEND_ENABLE_EXT => Some("COLOR_BLEND_ENABLE_EXT"), + Self::COLOR_BLEND_EQUATION_EXT => Some("COLOR_BLEND_EQUATION_EXT"), + Self::COLOR_WRITE_MASK_EXT => Some("COLOR_WRITE_MASK_EXT"), + Self::RASTERIZATION_STREAM_EXT => Some("RASTERIZATION_STREAM_EXT"), + Self::CONSERVATIVE_RASTERIZATION_MODE_EXT => { + Some("CONSERVATIVE_RASTERIZATION_MODE_EXT") + } + Self::EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT => { + Some("EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT") + } + Self::DEPTH_CLIP_ENABLE_EXT => Some("DEPTH_CLIP_ENABLE_EXT"), + Self::SAMPLE_LOCATIONS_ENABLE_EXT => Some("SAMPLE_LOCATIONS_ENABLE_EXT"), + Self::COLOR_BLEND_ADVANCED_EXT => Some("COLOR_BLEND_ADVANCED_EXT"), + Self::PROVOKING_VERTEX_MODE_EXT => Some("PROVOKING_VERTEX_MODE_EXT"), + Self::LINE_RASTERIZATION_MODE_EXT => Some("LINE_RASTERIZATION_MODE_EXT"), + Self::LINE_STIPPLE_ENABLE_EXT => Some("LINE_STIPPLE_ENABLE_EXT"), + Self::DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT => Some("DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT"), + Self::VIEWPORT_W_SCALING_ENABLE_NV => Some("VIEWPORT_W_SCALING_ENABLE_NV"), + Self::VIEWPORT_SWIZZLE_NV => Some("VIEWPORT_SWIZZLE_NV"), + Self::COVERAGE_TO_COLOR_ENABLE_NV => Some("COVERAGE_TO_COLOR_ENABLE_NV"), + Self::COVERAGE_TO_COLOR_LOCATION_NV => Some("COVERAGE_TO_COLOR_LOCATION_NV"), + Self::COVERAGE_MODULATION_MODE_NV => Some("COVERAGE_MODULATION_MODE_NV"), + Self::COVERAGE_MODULATION_TABLE_ENABLE_NV => { + Some("COVERAGE_MODULATION_TABLE_ENABLE_NV") + } + Self::COVERAGE_MODULATION_TABLE_NV => Some("COVERAGE_MODULATION_TABLE_NV"), + Self::SHADING_RATE_IMAGE_ENABLE_NV => Some("SHADING_RATE_IMAGE_ENABLE_NV"), + Self::REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV => { + Some("REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV") + } + Self::COVERAGE_REDUCTION_MODE_NV => Some("COVERAGE_REDUCTION_MODE_NV"), Self::CULL_MODE => Some("CULL_MODE"), Self::FRONT_FACE => Some("FRONT_FACE"), Self::PRIMITIVE_TOPOLOGY => Some("PRIMITIVE_TOPOLOGY"), @@ -1890,6 +2066,7 @@ impl fmt::Debug for Format { Self::ASTC_6X6X6_UNORM_BLOCK_EXT => Some("ASTC_6X6X6_UNORM_BLOCK_EXT"), Self::ASTC_6X6X6_SRGB_BLOCK_EXT => Some("ASTC_6X6X6_SRGB_BLOCK_EXT"), Self::ASTC_6X6X6_SFLOAT_BLOCK_EXT => Some("ASTC_6X6X6_SFLOAT_BLOCK_EXT"), + Self::R16G16_S10_5_NV => Some("R16G16_S10_5_NV"), Self::G8B8G8R8_422_UNORM => Some("G8B8G8R8_422_UNORM"), Self::B8G8R8G8_422_UNORM => Some("B8G8R8G8_422_UNORM"), Self::G8_B8_R8_3PLANE_420_UNORM => Some("G8_B8_R8_3PLANE_420_UNORM"), @@ -1993,7 +2170,7 @@ impl fmt::Debug for FormatFeatureFlags { } impl fmt::Debug for FormatFeatureFlags2 { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: RESERVED_44_EXT . 0 , "RESERVED_44_EXT") , (FormatFeatureFlags2 :: RESERVED_45_EXT . 0 , "RESERVED_45_EXT") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: RESERVED_39_EXT . 0 , "RESERVED_39_EXT") , (FormatFeatureFlags2 :: RESERVED_40_NV . 0 , "RESERVED_40_NV") , (FormatFeatureFlags2 :: RESERVED_41_NV . 0 , "RESERVED_41_NV") , (FormatFeatureFlags2 :: RESERVED_42_NV . 0 , "RESERVED_42_NV") , (FormatFeatureFlags2 :: RESERVED_43_NV . 0 , "RESERVED_43_NV")] ; + const KNOWN : & [(Flags64 , & str)] = & [(FormatFeatureFlags2 :: SAMPLED_IMAGE . 0 , "SAMPLED_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE . 0 , "STORAGE_IMAGE") , (FormatFeatureFlags2 :: STORAGE_IMAGE_ATOMIC . 0 , "STORAGE_IMAGE_ATOMIC") , (FormatFeatureFlags2 :: UNIFORM_TEXEL_BUFFER . 0 , "UNIFORM_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER . 0 , "STORAGE_TEXEL_BUFFER") , (FormatFeatureFlags2 :: STORAGE_TEXEL_BUFFER_ATOMIC . 0 , "STORAGE_TEXEL_BUFFER_ATOMIC") , (FormatFeatureFlags2 :: VERTEX_BUFFER . 0 , "VERTEX_BUFFER") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT . 0 , "COLOR_ATTACHMENT") , (FormatFeatureFlags2 :: COLOR_ATTACHMENT_BLEND . 0 , "COLOR_ATTACHMENT_BLEND") , (FormatFeatureFlags2 :: DEPTH_STENCIL_ATTACHMENT . 0 , "DEPTH_STENCIL_ATTACHMENT") , (FormatFeatureFlags2 :: BLIT_SRC . 0 , "BLIT_SRC") , (FormatFeatureFlags2 :: BLIT_DST . 0 , "BLIT_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_LINEAR . 0 , "SAMPLED_IMAGE_FILTER_LINEAR") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_CUBIC . 0 , "SAMPLED_IMAGE_FILTER_CUBIC") , (FormatFeatureFlags2 :: TRANSFER_SRC . 0 , "TRANSFER_SRC") , (FormatFeatureFlags2 :: TRANSFER_DST . 0 , "TRANSFER_DST") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_FILTER_MINMAX . 0 , "SAMPLED_IMAGE_FILTER_MINMAX") , (FormatFeatureFlags2 :: MIDPOINT_CHROMA_SAMPLES . 0 , "MIDPOINT_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE . 0 , "SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE") , (FormatFeatureFlags2 :: DISJOINT . 0 , "DISJOINT") , (FormatFeatureFlags2 :: COSITED_CHROMA_SAMPLES . 0 , "COSITED_CHROMA_SAMPLES") , (FormatFeatureFlags2 :: STORAGE_READ_WITHOUT_FORMAT . 0 , "STORAGE_READ_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: STORAGE_WRITE_WITHOUT_FORMAT . 0 , "STORAGE_WRITE_WITHOUT_FORMAT") , (FormatFeatureFlags2 :: SAMPLED_IMAGE_DEPTH_COMPARISON . 0 , "SAMPLED_IMAGE_DEPTH_COMPARISON") , (FormatFeatureFlags2 :: VIDEO_DECODE_OUTPUT_KHR . 0 , "VIDEO_DECODE_OUTPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_DECODE_DPB_KHR . 0 , "VIDEO_DECODE_DPB_KHR") , (FormatFeatureFlags2 :: ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR . 0 , "ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR") , (FormatFeatureFlags2 :: FRAGMENT_DENSITY_MAP_EXT . 0 , "FRAGMENT_DENSITY_MAP_EXT") , (FormatFeatureFlags2 :: FRAGMENT_SHADING_RATE_ATTACHMENT_KHR . 0 , "FRAGMENT_SHADING_RATE_ATTACHMENT_KHR") , (FormatFeatureFlags2 :: RESERVED_44_EXT . 0 , "RESERVED_44_EXT") , (FormatFeatureFlags2 :: RESERVED_45_EXT . 0 , "RESERVED_45_EXT") , (FormatFeatureFlags2 :: VIDEO_ENCODE_INPUT_KHR . 0 , "VIDEO_ENCODE_INPUT_KHR") , (FormatFeatureFlags2 :: VIDEO_ENCODE_DPB_KHR . 0 , "VIDEO_ENCODE_DPB_KHR") , (FormatFeatureFlags2 :: LINEAR_COLOR_ATTACHMENT_NV . 0 , "LINEAR_COLOR_ATTACHMENT_NV") , (FormatFeatureFlags2 :: WEIGHT_IMAGE_QCOM . 0 , "WEIGHT_IMAGE_QCOM") , (FormatFeatureFlags2 :: WEIGHT_SAMPLED_IMAGE_QCOM . 0 , "WEIGHT_SAMPLED_IMAGE_QCOM") , (FormatFeatureFlags2 :: BLOCK_MATCHING_QCOM . 0 , "BLOCK_MATCHING_QCOM") , (FormatFeatureFlags2 :: BOX_FILTER_SAMPLED_QCOM . 0 , "BOX_FILTER_SAMPLED_QCOM") , (FormatFeatureFlags2 :: RESERVED_39_EXT . 0 , "RESERVED_39_EXT") , (FormatFeatureFlags2 :: OPTICAL_FLOW_IMAGE_NV . 0 , "OPTICAL_FLOW_IMAGE_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_VECTOR_NV . 0 , "OPTICAL_FLOW_VECTOR_NV") , (FormatFeatureFlags2 :: OPTICAL_FLOW_COST_NV . 0 , "OPTICAL_FLOW_COST_NV")] ; debug_flags(f, KNOWN, self.0) } } @@ -2116,8 +2293,14 @@ impl fmt::Debug for GeometryInstanceFlagsKHR { GeometryInstanceFlagsKHR::FORCE_NO_OPAQUE.0, "FORCE_NO_OPAQUE", ), - (GeometryInstanceFlagsKHR::RESERVED_4_NV.0, "RESERVED_4_NV"), - (GeometryInstanceFlagsKHR::RESERVED_5_NV.0, "RESERVED_5_NV"), + ( + GeometryInstanceFlagsKHR::FORCE_OPACITY_MICROMAP_2_STATE_EXT.0, + "FORCE_OPACITY_MICROMAP_2_STATE_EXT", + ), + ( + GeometryInstanceFlagsKHR::DISABLE_OPACITY_MICROMAPS_EXT.0, + "DISABLE_OPACITY_MICROMAPS_EXT", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -2327,7 +2510,10 @@ impl fmt::Debug for ImageCreateFlags { ), (ImageCreateFlags::SUBSAMPLED_EXT.0, "SUBSAMPLED_EXT"), (ImageCreateFlags::RESERVED_19_EXT.0, "RESERVED_19_EXT"), - (ImageCreateFlags::RESERVED_16_AMD.0, "RESERVED_16_AMD"), + ( + ImageCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), ( ImageCreateFlags::MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT.0, "MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT", @@ -2526,7 +2712,10 @@ impl fmt::Debug for ImageViewCreateFlags { ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DYNAMIC_EXT.0, "FRAGMENT_DENSITY_MAP_DYNAMIC_EXT", ), - (ImageViewCreateFlags::RESERVED_2_AMD.0, "RESERVED_2_AMD"), + ( + ImageViewCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), ( ImageViewCreateFlags::FRAGMENT_DENSITY_MAP_DEFERRED_EXT.0, "FRAGMENT_DENSITY_MAP_DEFERRED_EXT", @@ -2703,6 +2892,15 @@ impl fmt::Debug for MemoryAllocateFlags { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for MemoryDecompressionMethodFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags64, &str)] = &[( + MemoryDecompressionMethodFlagsNV::GDEFLATE_1_0.0, + "GDEFLATE_1_0", + )]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for MemoryHeapFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -2762,6 +2960,156 @@ impl fmt::Debug for MetalSurfaceCreateFlagsEXT { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for MicromapCreateFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + MicromapCreateFlagsEXT::DEVICE_ADDRESS_CAPTURE_REPLAY.0, + "DEVICE_ADDRESS_CAPTURE_REPLAY", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for MicromapTypeEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::OPACITY_MICROMAP => Some("OPACITY_MICROMAP"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpacityMicromapFormatEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::TYPE_2_STATE => Some("TYPE_2_STATE"), + Self::TYPE_4_STATE => Some("TYPE_4_STATE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpacityMicromapSpecialIndexEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::FULLY_TRANSPARENT => Some("FULLY_TRANSPARENT"), + Self::FULLY_OPAQUE => Some("FULLY_OPAQUE"), + Self::FULLY_UNKNOWN_TRANSPARENT => Some("FULLY_UNKNOWN_TRANSPARENT"), + Self::FULLY_UNKNOWN_OPAQUE => Some("FULLY_UNKNOWN_OPAQUE"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpticalFlowExecuteFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + OpticalFlowExecuteFlagsNV::DISABLE_TEMPORAL_HINTS.0, + "DISABLE_TEMPORAL_HINTS", + )]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for OpticalFlowGridSizeFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (OpticalFlowGridSizeFlagsNV::UNKNOWN.0, "UNKNOWN"), + (OpticalFlowGridSizeFlagsNV::TYPE_1X1.0, "TYPE_1X1"), + (OpticalFlowGridSizeFlagsNV::TYPE_2X2.0, "TYPE_2X2"), + (OpticalFlowGridSizeFlagsNV::TYPE_4X4.0, "TYPE_4X4"), + (OpticalFlowGridSizeFlagsNV::TYPE_8X8.0, "TYPE_8X8"), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for OpticalFlowPerformanceLevelNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::SLOW => Some("SLOW"), + Self::MEDIUM => Some("MEDIUM"), + Self::FAST => Some("FAST"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpticalFlowSessionBindingPointNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::UNKNOWN => Some("UNKNOWN"), + Self::INPUT => Some("INPUT"), + Self::REFERENCE => Some("REFERENCE"), + Self::HINT => Some("HINT"), + Self::FLOW_VECTOR => Some("FLOW_VECTOR"), + Self::BACKWARD_FLOW_VECTOR => Some("BACKWARD_FLOW_VECTOR"), + Self::COST => Some("COST"), + Self::BACKWARD_COST => Some("BACKWARD_COST"), + Self::GLOBAL_FLOW => Some("GLOBAL_FLOW"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for OpticalFlowSessionCreateFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + ( + OpticalFlowSessionCreateFlagsNV::ENABLE_HINT.0, + "ENABLE_HINT", + ), + ( + OpticalFlowSessionCreateFlagsNV::ENABLE_COST.0, + "ENABLE_COST", + ), + ( + OpticalFlowSessionCreateFlagsNV::ENABLE_GLOBAL_FLOW.0, + "ENABLE_GLOBAL_FLOW", + ), + ( + OpticalFlowSessionCreateFlagsNV::ALLOW_REGIONS.0, + "ALLOW_REGIONS", + ), + ( + OpticalFlowSessionCreateFlagsNV::BOTH_DIRECTIONS.0, + "BOTH_DIRECTIONS", + ), + ]; + debug_flags(f, KNOWN, self.0) + } +} +impl fmt::Debug for OpticalFlowUsageFlagsNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[ + (OpticalFlowUsageFlagsNV::UNKNOWN.0, "UNKNOWN"), + (OpticalFlowUsageFlagsNV::INPUT.0, "INPUT"), + (OpticalFlowUsageFlagsNV::OUTPUT.0, "OUTPUT"), + (OpticalFlowUsageFlagsNV::HINT.0, "HINT"), + (OpticalFlowUsageFlagsNV::COST.0, "COST"), + (OpticalFlowUsageFlagsNV::GLOBAL_FLOW.0, "GLOBAL_FLOW"), + ]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for PeerMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -3058,7 +3406,10 @@ impl fmt::Debug for PipelineCreateFlags { "INDIRECT_BINDABLE_NV", ), (PipelineCreateFlags::LIBRARY_KHR.0, "LIBRARY_KHR"), - (PipelineCreateFlags::RESERVED_29_AMD.0, "RESERVED_29_AMD"), + ( + PipelineCreateFlags::DESCRIPTOR_BUFFER_EXT.0, + "DESCRIPTOR_BUFFER_EXT", + ), ( PipelineCreateFlags::RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT.0, "RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT", @@ -3079,10 +3430,19 @@ impl fmt::Debug for PipelineCreateFlags { PipelineCreateFlags::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT.0, "DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT", ), - (PipelineCreateFlags::RESERVED_24_NV.0, "RESERVED_24_NV"), + ( + PipelineCreateFlags::RAY_TRACING_OPACITY_MICROMAP_EXT.0, + "RAY_TRACING_OPACITY_MICROMAP_EXT", + ), (PipelineCreateFlags::RESERVED_28_NV.0, "RESERVED_28_NV"), - (PipelineCreateFlags::RESERVED_27_EXT.0, "RESERVED_27_EXT"), - (PipelineCreateFlags::RESERVED_30_EXT.0, "RESERVED_30_EXT"), + ( + PipelineCreateFlags::NO_PROTECTED_ACCESS_EXT.0, + "NO_PROTECTED_ACCESS_EXT", + ), + ( + PipelineCreateFlags::PROTECTED_ACCESS_ONLY_EXT.0, + "PROTECTED_ACCESS_ONLY_EXT", + ), ( PipelineCreateFlags::VIEW_INDEX_FROM_DEVICE_INDEX.0, "VIEW_INDEX_FROM_DEVICE_INDEX", @@ -3415,8 +3775,15 @@ impl fmt::Debug for PipelineStageFlags2 { PipelineStageFlags2::ACCELERATION_STRUCTURE_COPY_KHR.0, "ACCELERATION_STRUCTURE_COPY_KHR", ), - (PipelineStageFlags2::RESERVED_30_NV.0, "RESERVED_30_NV"), - (PipelineStageFlags2::RESERVED_29_NV.0, "RESERVED_29_NV"), + ( + PipelineStageFlags2::MICROMAP_BUILD_EXT.0, + "MICROMAP_BUILD_EXT", + ), + ( + PipelineStageFlags2::RESEVED_41_HUAWEI.0, + "RESEVED_41_HUAWEI", + ), + (PipelineStageFlags2::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"), ]; debug_flags(f, KNOWN, self.0) } @@ -3675,6 +4042,8 @@ impl fmt::Debug for QueryType { Some("ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR") } Self::ACCELERATION_STRUCTURE_SIZE_KHR => Some("ACCELERATION_STRUCTURE_SIZE_KHR"), + Self::MICROMAP_SERIALIZATION_SIZE_EXT => Some("MICROMAP_SERIALIZATION_SIZE_EXT"), + Self::MICROMAP_COMPACTED_SIZE_EXT => Some("MICROMAP_COMPACTED_SIZE_EXT"), _ => None, }; if let Some(x) = name { @@ -3695,7 +4064,7 @@ impl fmt::Debug for QueueFlags { (QueueFlags::RESERVED_9_EXT.0, "RESERVED_9_EXT"), (QueueFlags::VIDEO_ENCODE_KHR.0, "VIDEO_ENCODE_KHR"), (QueueFlags::RESERVED_7_QCOM.0, "RESERVED_7_QCOM"), - (QueueFlags::RESERVED_8_NV.0, "RESERVED_8_NV"), + (QueueFlags::OPTICAL_FLOW_NV.0, "OPTICAL_FLOW_NV"), (QueueFlags::PROTECTED.0, "PROTECTED"), ]; debug_flags(f, KNOWN, self.0) @@ -3731,6 +4100,20 @@ impl fmt::Debug for RasterizationOrderAMD { } } } +impl fmt::Debug for RayTracingInvocationReorderModeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::REORDER => Some("REORDER"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for RayTracingShaderGroupTypeKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -3823,7 +4206,10 @@ impl fmt::Debug for SamplerCreateFlags { SamplerCreateFlags::SUBSAMPLED_COARSE_RECONSTRUCTION_EXT.0, "SUBSAMPLED_COARSE_RECONSTRUCTION_EXT", ), - (SamplerCreateFlags::RESERVED_3_AMD.0, "RESERVED_3_AMD"), + ( + SamplerCreateFlags::DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT.0, + "DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT", + ), ( SamplerCreateFlags::NON_SEAMLESS_CUBE_MAP_EXT.0, "NON_SEAMLESS_CUBE_MAP_EXT", @@ -4037,6 +4423,7 @@ impl fmt::Debug for ShaderStageFlags { ShaderStageFlags::SUBPASS_SHADING_HUAWEI.0, "SUBPASS_SHADING_HUAWEI", ), + (ShaderStageFlags::RESERVED_19_HUAWEI.0, "RESERVED_19_HUAWEI"), (ShaderStageFlags::EXT_483_RESERVE_15.0, "EXT_483_RESERVE_15"), (ShaderStageFlags::EXT_483_RESERVE_16.0, "EXT_483_RESERVE_16"), (ShaderStageFlags::EXT_483_RESERVE_17.0, "EXT_483_RESERVE_17"), @@ -4359,7 +4746,6 @@ impl fmt::Debug for StructureType { } Self::VIDEO_DECODE_H264_CAPABILITIES_EXT => Some("VIDEO_DECODE_H264_CAPABILITIES_EXT"), Self::VIDEO_DECODE_H264_PICTURE_INFO_EXT => Some("VIDEO_DECODE_H264_PICTURE_INFO_EXT"), - Self::VIDEO_DECODE_H264_MVC_INFO_EXT => Some("VIDEO_DECODE_H264_MVC_INFO_EXT"), Self::VIDEO_DECODE_H264_PROFILE_INFO_EXT => Some("VIDEO_DECODE_H264_PROFILE_INFO_EXT"), Self::VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT => { Some("VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT") @@ -5008,6 +5394,15 @@ impl fmt::Debug for StructureType { Some("PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT") } Self::PIPELINE_LIBRARY_CREATE_INFO_KHR => Some("PIPELINE_LIBRARY_CREATE_INFO_KHR"), + Self::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV => { + Some("PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV") + } + Self::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV => { + Some("SURFACE_CAPABILITIES_PRESENT_BARRIER_NV") + } + Self::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV => { + Some("SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV") + } Self::PRESENT_ID_KHR => Some("PRESENT_ID_KHR"), Self::PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR => { Some("PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR") @@ -5046,6 +5441,39 @@ impl fmt::Debug for StructureType { Some("QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV") } Self::CHECKPOINT_DATA_2_NV => Some("CHECKPOINT_DATA_2_NV"), + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT") + } + Self::DESCRIPTOR_ADDRESS_INFO_EXT => Some("DESCRIPTOR_ADDRESS_INFO_EXT"), + Self::DESCRIPTOR_GET_INFO_EXT => Some("DESCRIPTOR_GET_INFO_EXT"), + Self::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } + Self::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT => { + Some("OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT") + } + Self::DESCRIPTOR_BUFFER_BINDING_INFO_EXT => Some("DESCRIPTOR_BUFFER_BINDING_INFO_EXT"), + Self::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT => { + Some("DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT") + } + Self::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT => { + Some("ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT") + } Self::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT => { Some("PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT") } @@ -5117,6 +5545,9 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_FAULT_FEATURES_EXT => Some("PHYSICAL_DEVICE_FAULT_FEATURES_EXT"), + Self::DEVICE_FAULT_COUNTS_EXT => Some("DEVICE_FAULT_COUNTS_EXT"), + Self::DEVICE_FAULT_INFO_EXT => Some("DEVICE_FAULT_INFO_EXT"), Self::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT") } @@ -5131,6 +5562,12 @@ impl fmt::Debug for StructureType { Some("VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT") } Self::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT => Some("PHYSICAL_DEVICE_DRM_PROPERTIES_EXT"), + Self::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT") + } + Self::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT => { + Some("DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT") + } Self::PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT => { Some("PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT") } @@ -5237,6 +5674,22 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT => { Some("PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT") } + Self::MICROMAP_BUILD_INFO_EXT => Some("MICROMAP_BUILD_INFO_EXT"), + Self::MICROMAP_VERSION_INFO_EXT => Some("MICROMAP_VERSION_INFO_EXT"), + Self::COPY_MICROMAP_INFO_EXT => Some("COPY_MICROMAP_INFO_EXT"), + Self::COPY_MICROMAP_TO_MEMORY_INFO_EXT => Some("COPY_MICROMAP_TO_MEMORY_INFO_EXT"), + Self::COPY_MEMORY_TO_MICROMAP_INFO_EXT => Some("COPY_MEMORY_TO_MICROMAP_INFO_EXT"), + Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT") + } + Self::MICROMAP_CREATE_INFO_EXT => Some("MICROMAP_CREATE_INFO_EXT"), + Self::MICROMAP_BUILD_SIZES_INFO_EXT => Some("MICROMAP_BUILD_SIZES_INFO_EXT"), + Self::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT => { + Some("ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT") + } Self::PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT => { Some("PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT") } @@ -5270,6 +5723,18 @@ impl fmt::Debug for StructureType { Self::SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM => { Some("SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM") } + Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV => { + Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV") + } + Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV => { + Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV") + } Self::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV => { Some("PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV") } @@ -5285,6 +5750,12 @@ impl fmt::Debug for StructureType { Self::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM => { Some("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM") } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT") + } Self::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT => { Some("PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT") } @@ -5308,9 +5779,29 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV => { + Some("PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV") + } + Self::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV => Some("OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV"), + Self::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV => { + Some("OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV") + } + Self::OPTICAL_FLOW_SESSION_CREATE_INFO_NV => { + Some("OPTICAL_FLOW_SESSION_CREATE_INFO_NV") + } + Self::OPTICAL_FLOW_EXECUTE_INFO_NV => Some("OPTICAL_FLOW_EXECUTE_INFO_NV"), + Self::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV => { + Some("OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV") + } Self::PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT => { Some("PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT") + } Self::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM => { Some("PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM") } @@ -5319,12 +5810,24 @@ impl fmt::Debug for StructureType { Some("PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC") } Self::AMIGO_PROFILING_SUBMIT_INFO_SEC => Some("AMIGO_PROFILING_SUBMIT_INFO_SEC"), + Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV") + } Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT => { Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT") } Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT => { Some("MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT") } + Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM => { + Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM") + } + Self::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM => { + Some("PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM") + } Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") } @@ -5819,6 +6322,7 @@ impl fmt::Debug for SwapchainCreateFlagsKHR { ), (SwapchainCreateFlagsKHR::PROTECTED.0, "PROTECTED"), (SwapchainCreateFlagsKHR::MUTABLE_FORMAT.0, "MUTABLE_FORMAT"), + (SwapchainCreateFlagsKHR::RESERVED_4_EXT.0, "RESERVED_4_EXT"), (SwapchainCreateFlagsKHR::RESERVED_3_SEC.0, "RESERVED_3_SEC"), ]; debug_flags(f, KNOWN, self.0) diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index b1625ab..c8481a8 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -57,7 +57,7 @@ pub const API_VERSION_1_1: u32 = make_api_version(0, 1, 1, 0); pub const API_VERSION_1_2: u32 = make_api_version(0, 1, 2, 0); #[doc = ""] pub const API_VERSION_1_3: u32 = make_api_version(0, 1, 3, 0); -pub const HEADER_VERSION: u32 = 228u32; +pub const HEADER_VERSION: u32 = 235u32; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -420,6 +420,8 @@ handle_nondispatchable ! (DeferredOperationKHR , DEFERRED_OPERATION_KHR , doc = handle_nondispatchable ! (PrivateDataSlot , PRIVATE_DATA_SLOT , doc = "") ; handle_nondispatchable ! (CuModuleNVX , CU_MODULE_NVX , doc = "") ; handle_nondispatchable ! (CuFunctionNVX , CU_FUNCTION_NVX , doc = "") ; +handle_nondispatchable ! (OpticalFlowSessionNV , OPTICAL_FLOW_SESSION_NV , doc = "") ; +handle_nondispatchable ! (MicromapEXT , MICROMAP_EXT , doc = "") ; handle_nondispatchable!( DisplayKHR, DISPLAY_KHR, @@ -3041,6 +3043,76 @@ impl BufferImageCopy { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct CopyMemoryIndirectCommandNV { + pub src_address: DeviceAddress, + pub dst_address: DeviceAddress, + pub size: DeviceSize, +} +impl CopyMemoryIndirectCommandNV { + #[inline] + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.src_address = src_address; + self + } + #[inline] + pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self { + self.dst_address = dst_address; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.size = size; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct CopyMemoryToImageIndirectCommandNV { + pub src_address: DeviceAddress, + pub buffer_row_length: u32, + pub buffer_image_height: u32, + pub image_subresource: ImageSubresourceLayers, + pub image_offset: Offset3D, + pub image_extent: Extent3D, +} +impl CopyMemoryToImageIndirectCommandNV { + #[inline] + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.src_address = src_address; + self + } + #[inline] + pub fn buffer_row_length(mut self, buffer_row_length: u32) -> Self { + self.buffer_row_length = buffer_row_length; + self + } + #[inline] + pub fn buffer_image_height(mut self, buffer_image_height: u32) -> Self { + self.buffer_image_height = buffer_image_height; + self + } + #[inline] + pub fn image_subresource(mut self, image_subresource: ImageSubresourceLayers) -> Self { + self.image_subresource = image_subresource; + self + } + #[inline] + pub fn image_offset(mut self, image_offset: Offset3D) -> Self { + self.image_offset = image_offset; + self + } + #[inline] + pub fn image_extent(mut self, image_extent: Extent3D) -> Self { + self.image_extent = image_extent; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] #[doc = ""] pub struct ImageResolve { pub src_subresource: ImageSubresourceLayers, @@ -17938,6 +18010,7 @@ impl ::std::default::Default for DebugUtilsMessengerCallbackDataEXT<'_> { unsafe impl<'a> TaggedStructure for DebugUtilsMessengerCallbackDataEXT<'a> { const STRUCTURE_TYPE: StructureType = StructureType::DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT; } +pub unsafe trait ExtendsDebugUtilsMessengerCallbackDataEXT {} impl<'a> DebugUtilsMessengerCallbackDataEXT<'a> { #[inline] pub fn flags(mut self, flags: DebugUtilsMessengerCallbackDataFlagsEXT) -> Self { @@ -17977,6 +18050,23 @@ impl<'a> DebugUtilsMessengerCallbackDataEXT<'a> { self.p_objects = objects.as_ptr(); self } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.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 = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; + } + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -21742,6 +21832,153 @@ impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCopyMemoryIndirectFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub indirect_copy: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + indirect_copy: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCopyMemoryIndirectFeaturesNV<'_> {} +impl<'a> PhysicalDeviceCopyMemoryIndirectFeaturesNV<'a> { + #[inline] + pub fn indirect_copy(mut self, indirect_copy: bool) -> Self { + self.indirect_copy = indirect_copy.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCopyMemoryIndirectPropertiesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_queues: QueueFlags, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceCopyMemoryIndirectPropertiesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_queues: QueueFlags::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceCopyMemoryIndirectPropertiesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCopyMemoryIndirectPropertiesNV<'_> {} +impl<'a> PhysicalDeviceCopyMemoryIndirectPropertiesNV<'a> { + #[inline] + pub fn supported_queues(mut self, supported_queues: QueueFlags) -> Self { + self.supported_queues = supported_queues; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryDecompressionFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_decompression: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceMemoryDecompressionFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_decompression: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceMemoryDecompressionFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceMemoryDecompressionFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceMemoryDecompressionFeaturesNV<'_> {} +impl<'a> PhysicalDeviceMemoryDecompressionFeaturesNV<'a> { + #[inline] + pub fn memory_decompression(mut self, memory_decompression: bool) -> Self { + self.memory_decompression = memory_decompression.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceMemoryDecompressionPropertiesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub decompression_methods: MemoryDecompressionMethodFlagsNV, + pub max_decompression_indirect_count: u64, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceMemoryDecompressionPropertiesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + decompression_methods: MemoryDecompressionMethodFlagsNV::default(), + max_decompression_indirect_count: u64::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceMemoryDecompressionPropertiesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceMemoryDecompressionPropertiesNV<'_> {} +impl<'a> PhysicalDeviceMemoryDecompressionPropertiesNV<'a> { + #[inline] + pub fn decompression_methods( + mut self, + decompression_methods: MemoryDecompressionMethodFlagsNV, + ) -> Self { + self.decompression_methods = decompression_methods; + self + } + #[inline] + pub fn max_decompression_indirect_count( + mut self, + max_decompression_indirect_count: u64, + ) -> Self { + self.max_decompression_indirect_count = max_decompression_indirect_count; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct ShadingRatePaletteNV<'a> { pub shading_rate_palette_entry_count: u32, @@ -23227,6 +23464,7 @@ impl ::std::default::Default for AccelerationStructureCreateInfoNV<'_> { unsafe impl<'a> TaggedStructure for AccelerationStructureCreateInfoNV<'a> { const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_CREATE_INFO_NV; } +pub unsafe trait ExtendsAccelerationStructureCreateInfoNV {} impl<'a> AccelerationStructureCreateInfoNV<'a> { #[inline] pub fn compacted_size(mut self, compacted_size: DeviceSize) -> Self { @@ -23238,6 +23476,23 @@ impl<'a> AccelerationStructureCreateInfoNV<'a> { self.info = info; self } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.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 = <*const T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; + } + self + } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] @@ -26049,6 +26304,104 @@ impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePresentBarrierFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_barrier: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDevicePresentBarrierFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_barrier: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDevicePresentBarrierFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePresentBarrierFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePresentBarrierFeaturesNV<'_> {} +impl<'a> PhysicalDevicePresentBarrierFeaturesNV<'a> { + #[inline] + pub fn present_barrier(mut self, present_barrier: bool) -> Self { + self.present_barrier = present_barrier.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SurfaceCapabilitiesPresentBarrierNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_barrier_supported: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SurfaceCapabilitiesPresentBarrierNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_barrier_supported: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SurfaceCapabilitiesPresentBarrierNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SURFACE_CAPABILITIES_PRESENT_BARRIER_NV; +} +unsafe impl ExtendsSurfaceCapabilities2KHR for SurfaceCapabilitiesPresentBarrierNV<'_> {} +impl<'a> SurfaceCapabilitiesPresentBarrierNV<'a> { + #[inline] + pub fn present_barrier_supported(mut self, present_barrier_supported: bool) -> Self { + self.present_barrier_supported = present_barrier_supported.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainPresentBarrierCreateInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub present_barrier_enable: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SwapchainPresentBarrierCreateInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + present_barrier_enable: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SwapchainPresentBarrierCreateInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainPresentBarrierCreateInfoNV<'_> {} +impl<'a> SwapchainPresentBarrierCreateInfoNV<'a> { + #[inline] + pub fn present_barrier_enable(mut self, present_barrier_enable: bool) -> Self { + self.present_barrier_enable = present_barrier_enable.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDevicePerformanceQueryFeaturesKHR<'a> { pub s_type: StructureType, @@ -31545,6 +31898,494 @@ impl<'a> PhysicalDeviceExtendedDynamicState2FeaturesEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicState3FeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_dynamic_state3_tessellation_domain_origin: Bool32, + pub extended_dynamic_state3_depth_clamp_enable: Bool32, + pub extended_dynamic_state3_polygon_mode: Bool32, + pub extended_dynamic_state3_rasterization_samples: Bool32, + pub extended_dynamic_state3_sample_mask: Bool32, + pub extended_dynamic_state3_alpha_to_coverage_enable: Bool32, + pub extended_dynamic_state3_alpha_to_one_enable: Bool32, + pub extended_dynamic_state3_logic_op_enable: Bool32, + pub extended_dynamic_state3_color_blend_enable: Bool32, + pub extended_dynamic_state3_color_blend_equation: Bool32, + pub extended_dynamic_state3_color_write_mask: Bool32, + pub extended_dynamic_state3_rasterization_stream: Bool32, + pub extended_dynamic_state3_conservative_rasterization_mode: Bool32, + pub extended_dynamic_state3_extra_primitive_overestimation_size: Bool32, + pub extended_dynamic_state3_depth_clip_enable: Bool32, + pub extended_dynamic_state3_sample_locations_enable: Bool32, + pub extended_dynamic_state3_color_blend_advanced: Bool32, + pub extended_dynamic_state3_provoking_vertex_mode: Bool32, + pub extended_dynamic_state3_line_rasterization_mode: Bool32, + pub extended_dynamic_state3_line_stipple_enable: Bool32, + pub extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32, + pub extended_dynamic_state3_viewport_w_scaling_enable: Bool32, + pub extended_dynamic_state3_viewport_swizzle: Bool32, + pub extended_dynamic_state3_coverage_to_color_enable: Bool32, + pub extended_dynamic_state3_coverage_to_color_location: Bool32, + pub extended_dynamic_state3_coverage_modulation_mode: Bool32, + pub extended_dynamic_state3_coverage_modulation_table_enable: Bool32, + pub extended_dynamic_state3_coverage_modulation_table: Bool32, + pub extended_dynamic_state3_coverage_reduction_mode: Bool32, + pub extended_dynamic_state3_representative_fragment_test_enable: Bool32, + pub extended_dynamic_state3_shading_rate_image_enable: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + extended_dynamic_state3_tessellation_domain_origin: Bool32::default(), + extended_dynamic_state3_depth_clamp_enable: Bool32::default(), + extended_dynamic_state3_polygon_mode: Bool32::default(), + extended_dynamic_state3_rasterization_samples: Bool32::default(), + extended_dynamic_state3_sample_mask: Bool32::default(), + extended_dynamic_state3_alpha_to_coverage_enable: Bool32::default(), + extended_dynamic_state3_alpha_to_one_enable: Bool32::default(), + extended_dynamic_state3_logic_op_enable: Bool32::default(), + extended_dynamic_state3_color_blend_enable: Bool32::default(), + extended_dynamic_state3_color_blend_equation: Bool32::default(), + extended_dynamic_state3_color_write_mask: Bool32::default(), + extended_dynamic_state3_rasterization_stream: Bool32::default(), + extended_dynamic_state3_conservative_rasterization_mode: Bool32::default(), + extended_dynamic_state3_extra_primitive_overestimation_size: Bool32::default(), + extended_dynamic_state3_depth_clip_enable: Bool32::default(), + extended_dynamic_state3_sample_locations_enable: Bool32::default(), + extended_dynamic_state3_color_blend_advanced: Bool32::default(), + extended_dynamic_state3_provoking_vertex_mode: Bool32::default(), + extended_dynamic_state3_line_rasterization_mode: Bool32::default(), + extended_dynamic_state3_line_stipple_enable: Bool32::default(), + extended_dynamic_state3_depth_clip_negative_one_to_one: Bool32::default(), + extended_dynamic_state3_viewport_w_scaling_enable: Bool32::default(), + extended_dynamic_state3_viewport_swizzle: Bool32::default(), + extended_dynamic_state3_coverage_to_color_enable: Bool32::default(), + extended_dynamic_state3_coverage_to_color_location: Bool32::default(), + extended_dynamic_state3_coverage_modulation_mode: Bool32::default(), + extended_dynamic_state3_coverage_modulation_table_enable: Bool32::default(), + extended_dynamic_state3_coverage_modulation_table: Bool32::default(), + extended_dynamic_state3_coverage_reduction_mode: Bool32::default(), + extended_dynamic_state3_representative_fragment_test_enable: Bool32::default(), + extended_dynamic_state3_shading_rate_image_enable: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedDynamicState3FeaturesEXT<'_> {} +impl<'a> PhysicalDeviceExtendedDynamicState3FeaturesEXT<'a> { + #[inline] + pub fn extended_dynamic_state3_tessellation_domain_origin( + mut self, + extended_dynamic_state3_tessellation_domain_origin: bool, + ) -> Self { + self.extended_dynamic_state3_tessellation_domain_origin = + extended_dynamic_state3_tessellation_domain_origin.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_depth_clamp_enable( + mut self, + extended_dynamic_state3_depth_clamp_enable: bool, + ) -> Self { + self.extended_dynamic_state3_depth_clamp_enable = + extended_dynamic_state3_depth_clamp_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_polygon_mode( + mut self, + extended_dynamic_state3_polygon_mode: bool, + ) -> Self { + self.extended_dynamic_state3_polygon_mode = extended_dynamic_state3_polygon_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_rasterization_samples( + mut self, + extended_dynamic_state3_rasterization_samples: bool, + ) -> Self { + self.extended_dynamic_state3_rasterization_samples = + extended_dynamic_state3_rasterization_samples.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_sample_mask( + mut self, + extended_dynamic_state3_sample_mask: bool, + ) -> Self { + self.extended_dynamic_state3_sample_mask = extended_dynamic_state3_sample_mask.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_alpha_to_coverage_enable( + mut self, + extended_dynamic_state3_alpha_to_coverage_enable: bool, + ) -> Self { + self.extended_dynamic_state3_alpha_to_coverage_enable = + extended_dynamic_state3_alpha_to_coverage_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_alpha_to_one_enable( + mut self, + extended_dynamic_state3_alpha_to_one_enable: bool, + ) -> Self { + self.extended_dynamic_state3_alpha_to_one_enable = + extended_dynamic_state3_alpha_to_one_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_logic_op_enable( + mut self, + extended_dynamic_state3_logic_op_enable: bool, + ) -> Self { + self.extended_dynamic_state3_logic_op_enable = + extended_dynamic_state3_logic_op_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_blend_enable( + mut self, + extended_dynamic_state3_color_blend_enable: bool, + ) -> Self { + self.extended_dynamic_state3_color_blend_enable = + extended_dynamic_state3_color_blend_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_blend_equation( + mut self, + extended_dynamic_state3_color_blend_equation: bool, + ) -> Self { + self.extended_dynamic_state3_color_blend_equation = + extended_dynamic_state3_color_blend_equation.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_write_mask( + mut self, + extended_dynamic_state3_color_write_mask: bool, + ) -> Self { + self.extended_dynamic_state3_color_write_mask = + extended_dynamic_state3_color_write_mask.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_rasterization_stream( + mut self, + extended_dynamic_state3_rasterization_stream: bool, + ) -> Self { + self.extended_dynamic_state3_rasterization_stream = + extended_dynamic_state3_rasterization_stream.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_conservative_rasterization_mode( + mut self, + extended_dynamic_state3_conservative_rasterization_mode: bool, + ) -> Self { + self.extended_dynamic_state3_conservative_rasterization_mode = + extended_dynamic_state3_conservative_rasterization_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_extra_primitive_overestimation_size( + mut self, + extended_dynamic_state3_extra_primitive_overestimation_size: bool, + ) -> Self { + self.extended_dynamic_state3_extra_primitive_overestimation_size = + extended_dynamic_state3_extra_primitive_overestimation_size.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_depth_clip_enable( + mut self, + extended_dynamic_state3_depth_clip_enable: bool, + ) -> Self { + self.extended_dynamic_state3_depth_clip_enable = + extended_dynamic_state3_depth_clip_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_sample_locations_enable( + mut self, + extended_dynamic_state3_sample_locations_enable: bool, + ) -> Self { + self.extended_dynamic_state3_sample_locations_enable = + extended_dynamic_state3_sample_locations_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_color_blend_advanced( + mut self, + extended_dynamic_state3_color_blend_advanced: bool, + ) -> Self { + self.extended_dynamic_state3_color_blend_advanced = + extended_dynamic_state3_color_blend_advanced.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_provoking_vertex_mode( + mut self, + extended_dynamic_state3_provoking_vertex_mode: bool, + ) -> Self { + self.extended_dynamic_state3_provoking_vertex_mode = + extended_dynamic_state3_provoking_vertex_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_line_rasterization_mode( + mut self, + extended_dynamic_state3_line_rasterization_mode: bool, + ) -> Self { + self.extended_dynamic_state3_line_rasterization_mode = + extended_dynamic_state3_line_rasterization_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_line_stipple_enable( + mut self, + extended_dynamic_state3_line_stipple_enable: bool, + ) -> Self { + self.extended_dynamic_state3_line_stipple_enable = + extended_dynamic_state3_line_stipple_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_depth_clip_negative_one_to_one( + mut self, + extended_dynamic_state3_depth_clip_negative_one_to_one: bool, + ) -> Self { + self.extended_dynamic_state3_depth_clip_negative_one_to_one = + extended_dynamic_state3_depth_clip_negative_one_to_one.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_viewport_w_scaling_enable( + mut self, + extended_dynamic_state3_viewport_w_scaling_enable: bool, + ) -> Self { + self.extended_dynamic_state3_viewport_w_scaling_enable = + extended_dynamic_state3_viewport_w_scaling_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_viewport_swizzle( + mut self, + extended_dynamic_state3_viewport_swizzle: bool, + ) -> Self { + self.extended_dynamic_state3_viewport_swizzle = + extended_dynamic_state3_viewport_swizzle.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_to_color_enable( + mut self, + extended_dynamic_state3_coverage_to_color_enable: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_to_color_enable = + extended_dynamic_state3_coverage_to_color_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_to_color_location( + mut self, + extended_dynamic_state3_coverage_to_color_location: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_to_color_location = + extended_dynamic_state3_coverage_to_color_location.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_modulation_mode( + mut self, + extended_dynamic_state3_coverage_modulation_mode: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_modulation_mode = + extended_dynamic_state3_coverage_modulation_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_modulation_table_enable( + mut self, + extended_dynamic_state3_coverage_modulation_table_enable: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_modulation_table_enable = + extended_dynamic_state3_coverage_modulation_table_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_modulation_table( + mut self, + extended_dynamic_state3_coverage_modulation_table: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_modulation_table = + extended_dynamic_state3_coverage_modulation_table.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_coverage_reduction_mode( + mut self, + extended_dynamic_state3_coverage_reduction_mode: bool, + ) -> Self { + self.extended_dynamic_state3_coverage_reduction_mode = + extended_dynamic_state3_coverage_reduction_mode.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_representative_fragment_test_enable( + mut self, + extended_dynamic_state3_representative_fragment_test_enable: bool, + ) -> Self { + self.extended_dynamic_state3_representative_fragment_test_enable = + extended_dynamic_state3_representative_fragment_test_enable.into(); + self + } + #[inline] + pub fn extended_dynamic_state3_shading_rate_image_enable( + mut self, + extended_dynamic_state3_shading_rate_image_enable: bool, + ) -> Self { + self.extended_dynamic_state3_shading_rate_image_enable = + extended_dynamic_state3_shading_rate_image_enable.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedDynamicState3PropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub dynamic_primitive_topology_unrestricted: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceExtendedDynamicState3PropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + dynamic_primitive_topology_unrestricted: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceExtendedDynamicState3PropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceExtendedDynamicState3PropertiesEXT<'_> +{ +} +impl<'a> PhysicalDeviceExtendedDynamicState3PropertiesEXT<'a> { + #[inline] + pub fn dynamic_primitive_topology_unrestricted( + mut self, + dynamic_primitive_topology_unrestricted: bool, + ) -> Self { + self.dynamic_primitive_topology_unrestricted = + dynamic_primitive_topology_unrestricted.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ColorBlendEquationEXT { + pub src_color_blend_factor: BlendFactor, + pub dst_color_blend_factor: BlendFactor, + pub color_blend_op: BlendOp, + pub src_alpha_blend_factor: BlendFactor, + pub dst_alpha_blend_factor: BlendFactor, + pub alpha_blend_op: BlendOp, +} +impl ColorBlendEquationEXT { + #[inline] + pub fn src_color_blend_factor(mut self, src_color_blend_factor: BlendFactor) -> Self { + self.src_color_blend_factor = src_color_blend_factor; + self + } + #[inline] + pub fn dst_color_blend_factor(mut self, dst_color_blend_factor: BlendFactor) -> Self { + self.dst_color_blend_factor = dst_color_blend_factor; + self + } + #[inline] + pub fn color_blend_op(mut self, color_blend_op: BlendOp) -> Self { + self.color_blend_op = color_blend_op; + self + } + #[inline] + pub fn src_alpha_blend_factor(mut self, src_alpha_blend_factor: BlendFactor) -> Self { + self.src_alpha_blend_factor = src_alpha_blend_factor; + self + } + #[inline] + pub fn dst_alpha_blend_factor(mut self, dst_alpha_blend_factor: BlendFactor) -> Self { + self.dst_alpha_blend_factor = dst_alpha_blend_factor; + self + } + #[inline] + pub fn alpha_blend_op(mut self, alpha_blend_op: BlendOp) -> Self { + self.alpha_blend_op = alpha_blend_op; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct ColorBlendAdvancedEXT { + pub advanced_blend_op: BlendOp, + pub src_premultiplied: Bool32, + pub dst_premultiplied: Bool32, + pub blend_overlap: BlendOverlapEXT, + pub clamp_results: Bool32, +} +impl ColorBlendAdvancedEXT { + #[inline] + pub fn advanced_blend_op(mut self, advanced_blend_op: BlendOp) -> Self { + self.advanced_blend_op = advanced_blend_op; + self + } + #[inline] + pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self { + self.src_premultiplied = src_premultiplied.into(); + self + } + #[inline] + pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self { + self.dst_premultiplied = dst_premultiplied.into(); + self + } + #[inline] + pub fn blend_overlap(mut self, blend_overlap: BlendOverlapEXT) -> Self { + self.blend_overlap = blend_overlap; + self + } + #[inline] + pub fn clamp_results(mut self, clamp_results: bool) -> Self { + self.clamp_results = clamp_results.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct RenderPassTransformBeginInfoQCOM<'a> { pub s_type: StructureType, @@ -34837,6 +35678,43 @@ impl<'a> MultisampledRenderToSingleSampledInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDevicePipelineProtectedAccessFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub pipeline_protected_access: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDevicePipelineProtectedAccessFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + pipeline_protected_access: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDevicePipelineProtectedAccessFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDevicePipelineProtectedAccessFeaturesEXT<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineProtectedAccessFeaturesEXT<'_> {} +impl<'a> PhysicalDevicePipelineProtectedAccessFeaturesEXT<'a> { + #[inline] + pub fn pipeline_protected_access(mut self, pipeline_protected_access: bool) -> Self { + self.pipeline_protected_access = pipeline_protected_access.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct QueueFamilyVideoPropertiesKHR<'a> { pub s_type: StructureType, @@ -35136,14 +36014,14 @@ impl<'a> VideoProfileInfoKHR<'a> { pub struct VideoCapabilitiesKHR<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub capability_flags: VideoCapabilityFlagsKHR, + pub flags: VideoCapabilityFlagsKHR, pub min_bitstream_buffer_offset_alignment: DeviceSize, pub min_bitstream_buffer_size_alignment: DeviceSize, - pub video_picture_extent_granularity: Extent2D, - pub min_extent: Extent2D, - pub max_extent: Extent2D, - pub max_reference_pictures_slots_count: u32, - pub max_reference_pictures_active_count: u32, + pub picture_access_granularity: Extent2D, + pub min_coded_extent: Extent2D, + pub max_coded_extent: Extent2D, + pub max_dpb_slots: u32, + pub max_active_reference_pictures: u32, pub std_header_version: ExtensionProperties, pub _marker: PhantomData<&'a ()>, } @@ -35153,14 +36031,14 @@ impl ::std::default::Default for VideoCapabilitiesKHR<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - capability_flags: VideoCapabilityFlagsKHR::default(), + flags: VideoCapabilityFlagsKHR::default(), min_bitstream_buffer_offset_alignment: DeviceSize::default(), min_bitstream_buffer_size_alignment: DeviceSize::default(), - video_picture_extent_granularity: Extent2D::default(), - min_extent: Extent2D::default(), - max_extent: Extent2D::default(), - max_reference_pictures_slots_count: u32::default(), - max_reference_pictures_active_count: u32::default(), + picture_access_granularity: Extent2D::default(), + min_coded_extent: Extent2D::default(), + max_coded_extent: Extent2D::default(), + max_dpb_slots: u32::default(), + max_active_reference_pictures: u32::default(), std_header_version: ExtensionProperties::default(), _marker: PhantomData, } @@ -35172,8 +36050,8 @@ unsafe impl<'a> TaggedStructure for VideoCapabilitiesKHR<'a> { pub unsafe trait ExtendsVideoCapabilitiesKHR {} impl<'a> VideoCapabilitiesKHR<'a> { #[inline] - pub fn capability_flags(mut self, capability_flags: VideoCapabilityFlagsKHR) -> Self { - self.capability_flags = capability_flags; + pub fn flags(mut self, flags: VideoCapabilityFlagsKHR) -> Self { + self.flags = flags; self } #[inline] @@ -35193,37 +36071,28 @@ impl<'a> VideoCapabilitiesKHR<'a> { self } #[inline] - pub fn video_picture_extent_granularity( - mut self, - video_picture_extent_granularity: Extent2D, - ) -> Self { - self.video_picture_extent_granularity = video_picture_extent_granularity; + pub fn picture_access_granularity(mut self, picture_access_granularity: Extent2D) -> Self { + self.picture_access_granularity = picture_access_granularity; self } #[inline] - pub fn min_extent(mut self, min_extent: Extent2D) -> Self { - self.min_extent = min_extent; + pub fn min_coded_extent(mut self, min_coded_extent: Extent2D) -> Self { + self.min_coded_extent = min_coded_extent; self } #[inline] - pub fn max_extent(mut self, max_extent: Extent2D) -> Self { - self.max_extent = max_extent; + pub fn max_coded_extent(mut self, max_coded_extent: Extent2D) -> Self { + self.max_coded_extent = max_coded_extent; self } #[inline] - pub fn max_reference_pictures_slots_count( - mut self, - max_reference_pictures_slots_count: u32, - ) -> Self { - self.max_reference_pictures_slots_count = max_reference_pictures_slots_count; + pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self { + self.max_dpb_slots = max_dpb_slots; self } #[inline] - pub fn max_reference_pictures_active_count( - mut self, - max_reference_pictures_active_count: u32, - ) -> Self { - self.max_reference_pictures_active_count = max_reference_pictures_active_count; + pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self { + self.max_active_reference_pictures = max_active_reference_pictures; self } #[inline] @@ -35395,7 +36264,7 @@ impl<'a> VideoPictureResourceInfoKHR<'a> { pub struct VideoReferenceSlotInfoKHR<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub slot_index: i8, + pub slot_index: i32, pub p_picture_resource: *const VideoPictureResourceInfoKHR<'a>, pub _marker: PhantomData<&'a ()>, } @@ -35405,7 +36274,7 @@ impl ::std::default::Default for VideoReferenceSlotInfoKHR<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - slot_index: i8::default(), + slot_index: i32::default(), p_picture_resource: ::std::ptr::null(), _marker: PhantomData, } @@ -35417,7 +36286,7 @@ unsafe impl<'a> TaggedStructure for VideoReferenceSlotInfoKHR<'a> { pub unsafe trait ExtendsVideoReferenceSlotInfoKHR {} impl<'a> VideoReferenceSlotInfoKHR<'a> { #[inline] - pub fn slot_index(mut self, slot_index: i8) -> Self { + pub fn slot_index(mut self, slot_index: i32) -> Self { self.slot_index = slot_index; self } @@ -35501,6 +36370,7 @@ unsafe impl<'a> TaggedStructure for VideoDecodeUsageInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_USAGE_INFO_KHR; } unsafe impl ExtendsVideoProfileInfoKHR for VideoDecodeUsageInfoKHR<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoDecodeUsageInfoKHR<'_> {} impl<'a> VideoDecodeUsageInfoKHR<'a> { #[inline] pub fn video_usage_hints(mut self, video_usage_hints: VideoDecodeUsageFlagsKHR) -> Self { @@ -35652,7 +36522,7 @@ impl<'a> VideoDecodeH264ProfileInfoEXT<'a> { pub struct VideoDecodeH264CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_level: StdVideoH264Level, + pub max_level_idc: StdVideoH264LevelIdc, pub field_offset_granularity: Offset2D, pub _marker: PhantomData<&'a ()>, } @@ -35662,7 +36532,7 @@ impl ::std::default::Default for VideoDecodeH264CapabilitiesEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - max_level: StdVideoH264Level::default(), + max_level_idc: StdVideoH264LevelIdc::default(), field_offset_granularity: Offset2D::default(), _marker: PhantomData, } @@ -35674,8 +36544,8 @@ unsafe impl<'a> TaggedStructure for VideoDecodeH264CapabilitiesEXT<'a> { unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH264CapabilitiesEXT<'_> {} impl<'a> VideoDecodeH264CapabilitiesEXT<'a> { #[inline] - pub fn max_level(mut self, max_level: StdVideoH264Level) -> Self { - self.max_level = max_level; + pub fn max_level_idc(mut self, max_level_idc: StdVideoH264LevelIdc) -> Self { + self.max_level_idc = max_level_idc; self } #[inline] @@ -35691,10 +36561,10 @@ impl<'a> VideoDecodeH264CapabilitiesEXT<'a> { pub struct VideoDecodeH264SessionParametersAddInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub sps_std_count: u32, - pub p_sps_std: *const StdVideoH264SequenceParameterSet, - pub pps_std_count: u32, - pub p_pps_std: *const StdVideoH264PictureParameterSet, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH264PictureParameterSet, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT<'_> { @@ -35703,10 +36573,10 @@ impl ::std::default::Default for VideoDecodeH264SessionParametersAddInfoEXT<'_> Self { s_type: Self::STRUCTURE_TYPE, p_next: ::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(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), _marker: PhantomData, } } @@ -35721,15 +36591,15 @@ unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR } impl<'a> VideoDecodeH264SessionParametersAddInfoEXT<'a> { #[inline] - pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self { - self.sps_std_count = sps_std.len() as _; - self.p_sps_std = sps_std.as_ptr(); + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self { + self.std_sps_count = std_sp_ss.len() as _; + self.p_std_sp_ss = std_sp_ss.as_ptr(); self } #[inline] - pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self { - self.pps_std_count = pps_std.len() as _; - self.p_pps_std = pps_std.as_ptr(); + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self { + self.std_pps_count = std_pp_ss.len() as _; + self.p_std_pp_ss = std_pp_ss.as_ptr(); self } } @@ -35740,8 +36610,8 @@ impl<'a> VideoDecodeH264SessionParametersAddInfoEXT<'a> { pub struct VideoDecodeH264SessionParametersCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub max_sps_std_count: u32, - pub max_pps_std_count: u32, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, pub p_parameters_add_info: *const VideoDecodeH264SessionParametersAddInfoEXT<'a>, pub _marker: PhantomData<&'a ()>, } @@ -35751,8 +36621,8 @@ impl ::std::default::Default for VideoDecodeH264SessionParametersCreateInfoEXT<' Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - max_sps_std_count: u32::default(), - max_pps_std_count: u32::default(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), p_parameters_add_info: ::std::ptr::null(), _marker: PhantomData, } @@ -35768,13 +36638,13 @@ unsafe impl ExtendsVideoSessionParametersCreateInfoKHR } impl<'a> VideoDecodeH264SessionParametersCreateInfoEXT<'a> { #[inline] - pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { - self.max_sps_std_count = max_sps_std_count; + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.max_std_sps_count = max_std_sps_count; self } #[inline] - pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self { - self.max_pps_std_count = max_pps_std_count; + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.max_std_pps_count = max_std_pps_count; self } #[inline] @@ -35794,8 +36664,8 @@ pub struct VideoDecodeH264PictureInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_picture_info: *const StdVideoDecodeH264PictureInfo, - pub slices_count: u32, - pub p_slices_data_offsets: *const u32, + pub slice_count: u32, + pub p_slice_offsets: *const u32, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoDecodeH264PictureInfoEXT<'_> { @@ -35805,8 +36675,8 @@ impl ::std::default::Default for VideoDecodeH264PictureInfoEXT<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), p_std_picture_info: ::std::ptr::null(), - slices_count: u32::default(), - p_slices_data_offsets: ::std::ptr::null(), + slice_count: u32::default(), + p_slice_offsets: ::std::ptr::null(), _marker: PhantomData, } } @@ -35815,7 +36685,6 @@ unsafe impl<'a> TaggedStructure for VideoDecodeH264PictureInfoEXT<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_PICTURE_INFO_EXT; } unsafe impl ExtendsVideoDecodeInfoKHR for VideoDecodeH264PictureInfoEXT<'_> {} -pub unsafe trait ExtendsVideoDecodeH264PictureInfoEXT {} impl<'a> VideoDecodeH264PictureInfoEXT<'a> { #[inline] pub fn std_picture_info(mut self, std_picture_info: &'a StdVideoDecodeH264PictureInfo) -> Self { @@ -35823,23 +36692,9 @@ impl<'a> VideoDecodeH264PictureInfoEXT<'a> { self } #[inline] - pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self { - self.slices_count = slices_data_offsets.len() as _; - self.p_slices_data_offsets = slices_data_offsets.as_ptr(); - self - } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.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 = <*const T>::cast(next); - let last_next = ptr_chain_iter(next).last().unwrap(); - (*last_next).p_next = self.p_next as _; - self.p_next = next_ptr; - } + pub fn slice_offsets(mut self, slice_offsets: &'a [u32]) -> Self { + self.slice_count = slice_offsets.len() as _; + self.p_slice_offsets = slice_offsets.as_ptr(); self } } @@ -35881,38 +36736,6 @@ impl<'a> VideoDecodeH264DpbSlotInfoEXT<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct VideoDecodeH264MvcInfoEXT<'a> { - pub s_type: StructureType, - pub p_next: *const c_void, - pub p_std_mvc: *const StdVideoDecodeH264Mvc, - pub _marker: PhantomData<&'a ()>, -} -impl ::std::default::Default for VideoDecodeH264MvcInfoEXT<'_> { - #[inline] - fn default() -> Self { - Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - p_std_mvc: ::std::ptr::null(), - _marker: PhantomData, - } - } -} -unsafe impl<'a> TaggedStructure for VideoDecodeH264MvcInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_DECODE_H264_MVC_INFO_EXT; -} -unsafe impl ExtendsVideoDecodeH264PictureInfoEXT for VideoDecodeH264MvcInfoEXT<'_> {} -impl<'a> VideoDecodeH264MvcInfoEXT<'a> { - #[inline] - pub fn std_mvc(mut self, std_mvc: &'a StdVideoDecodeH264Mvc) -> Self { - self.p_std_mvc = std_mvc; - self - } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] #[doc = ""] pub struct VideoDecodeH265ProfileInfoEXT<'a> { pub s_type: StructureType, @@ -35950,7 +36773,7 @@ impl<'a> VideoDecodeH265ProfileInfoEXT<'a> { pub struct VideoDecodeH265CapabilitiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_level: StdVideoH265Level, + pub max_level_idc: StdVideoH265LevelIdc, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT<'_> { @@ -35959,7 +36782,7 @@ impl ::std::default::Default for VideoDecodeH265CapabilitiesEXT<'_> { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - max_level: StdVideoH265Level::default(), + max_level_idc: StdVideoH265LevelIdc::default(), _marker: PhantomData, } } @@ -35970,8 +36793,8 @@ unsafe impl<'a> TaggedStructure for VideoDecodeH265CapabilitiesEXT<'a> { unsafe impl ExtendsVideoCapabilitiesKHR for VideoDecodeH265CapabilitiesEXT<'_> {} impl<'a> VideoDecodeH265CapabilitiesEXT<'a> { #[inline] - pub fn max_level(mut self, max_level: StdVideoH265Level) -> Self { - self.max_level = max_level; + pub fn max_level_idc(mut self, max_level_idc: StdVideoH265LevelIdc) -> Self { + self.max_level_idc = max_level_idc; self } } @@ -35982,12 +36805,12 @@ impl<'a> VideoDecodeH265CapabilitiesEXT<'a> { pub struct VideoDecodeH265SessionParametersAddInfoEXT<'a> { 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, + pub std_vps_count: u32, + pub p_std_vp_ss: *const StdVideoH265VideoParameterSet, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH265PictureParameterSet, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT<'_> { @@ -35996,12 +36819,12 @@ impl ::std::default::Default for VideoDecodeH265SessionParametersAddInfoEXT<'_> Self { s_type: Self::STRUCTURE_TYPE, 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(), + std_vps_count: u32::default(), + p_std_vp_ss: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), _marker: PhantomData, } } @@ -36016,21 +36839,21 @@ unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR } impl<'a> VideoDecodeH265SessionParametersAddInfoEXT<'a> { #[inline] - pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self { - self.vps_std_count = vps_std.len() as _; - self.p_vps_std = vps_std.as_ptr(); + pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self { + self.std_vps_count = std_vp_ss.len() as _; + self.p_std_vp_ss = std_vp_ss.as_ptr(); self } #[inline] - pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self { - self.sps_std_count = sps_std.len() as _; - self.p_sps_std = sps_std.as_ptr(); + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self { + self.std_sps_count = std_sp_ss.len() as _; + self.p_std_sp_ss = std_sp_ss.as_ptr(); self } #[inline] - pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self { - self.pps_std_count = pps_std.len() as _; - self.p_pps_std = pps_std.as_ptr(); + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self { + self.std_pps_count = std_pp_ss.len() as _; + self.p_std_pp_ss = std_pp_ss.as_ptr(); self } } @@ -36041,9 +36864,9 @@ impl<'a> VideoDecodeH265SessionParametersAddInfoEXT<'a> { pub struct VideoDecodeH265SessionParametersCreateInfoEXT<'a> { 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 max_std_vps_count: u32, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, pub p_parameters_add_info: *const VideoDecodeH265SessionParametersAddInfoEXT<'a>, pub _marker: PhantomData<&'a ()>, } @@ -36053,9 +36876,9 @@ impl ::std::default::Default for VideoDecodeH265SessionParametersCreateInfoEXT<' Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - max_vps_std_count: u32::default(), - max_sps_std_count: u32::default(), - max_pps_std_count: u32::default(), + max_std_vps_count: u32::default(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), p_parameters_add_info: ::std::ptr::null(), _marker: PhantomData, } @@ -36071,18 +36894,18 @@ unsafe impl ExtendsVideoSessionParametersCreateInfoKHR } impl<'a> VideoDecodeH265SessionParametersCreateInfoEXT<'a> { #[inline] - pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self { - self.max_vps_std_count = max_vps_std_count; + pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self { + self.max_std_vps_count = max_std_vps_count; self } #[inline] - pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { - self.max_sps_std_count = max_sps_std_count; + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.max_std_sps_count = max_std_sps_count; self } #[inline] - pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self { - self.max_pps_std_count = max_pps_std_count; + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.max_std_pps_count = max_std_pps_count; self } #[inline] @@ -36102,8 +36925,8 @@ pub struct VideoDecodeH265PictureInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, pub p_std_picture_info: *mut StdVideoDecodeH265PictureInfo, - pub slices_count: u32, - pub p_slices_data_offsets: *const u32, + pub slice_count: u32, + pub p_slice_offsets: *const u32, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoDecodeH265PictureInfoEXT<'_> { @@ -36113,8 +36936,8 @@ impl ::std::default::Default for VideoDecodeH265PictureInfoEXT<'_> { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), p_std_picture_info: ::std::ptr::null_mut(), - slices_count: u32::default(), - p_slices_data_offsets: ::std::ptr::null(), + slice_count: u32::default(), + p_slice_offsets: ::std::ptr::null(), _marker: PhantomData, } } @@ -36133,9 +36956,9 @@ impl<'a> VideoDecodeH265PictureInfoEXT<'a> { self } #[inline] - pub fn slices_data_offsets(mut self, slices_data_offsets: &'a [u32]) -> Self { - self.slices_count = slices_data_offsets.len() as _; - self.p_slices_data_offsets = slices_data_offsets.as_ptr(); + pub fn slice_offsets(mut self, slice_offsets: &'a [u32]) -> Self { + self.slice_count = slice_offsets.len() as _; + self.p_slice_offsets = slice_offsets.as_ptr(); self } } @@ -36186,9 +37009,9 @@ pub struct VideoSessionCreateInfoKHR<'a> { pub p_video_profile: *const VideoProfileInfoKHR<'a>, pub picture_format: Format, pub max_coded_extent: Extent2D, - pub reference_pictures_format: Format, - pub max_reference_pictures_slots_count: u32, - pub max_reference_pictures_active_count: u32, + pub reference_picture_format: Format, + pub max_dpb_slots: u32, + pub max_active_reference_pictures: u32, pub p_std_header_version: *const ExtensionProperties, pub _marker: PhantomData<&'a ()>, } @@ -36203,9 +37026,9 @@ impl ::std::default::Default for VideoSessionCreateInfoKHR<'_> { p_video_profile: ::std::ptr::null(), picture_format: Format::default(), max_coded_extent: Extent2D::default(), - reference_pictures_format: Format::default(), - max_reference_pictures_slots_count: u32::default(), - max_reference_pictures_active_count: u32::default(), + reference_picture_format: Format::default(), + max_dpb_slots: u32::default(), + max_active_reference_pictures: u32::default(), p_std_header_version: ::std::ptr::null(), _marker: PhantomData, } @@ -36241,24 +37064,18 @@ impl<'a> VideoSessionCreateInfoKHR<'a> { self } #[inline] - pub fn reference_pictures_format(mut self, reference_pictures_format: Format) -> Self { - self.reference_pictures_format = reference_pictures_format; + pub fn reference_picture_format(mut self, reference_picture_format: Format) -> Self { + self.reference_picture_format = reference_picture_format; self } #[inline] - pub fn max_reference_pictures_slots_count( - mut self, - max_reference_pictures_slots_count: u32, - ) -> Self { - self.max_reference_pictures_slots_count = max_reference_pictures_slots_count; + pub fn max_dpb_slots(mut self, max_dpb_slots: u32) -> Self { + self.max_dpb_slots = max_dpb_slots; self } #[inline] - pub fn max_reference_pictures_active_count( - mut self, - max_reference_pictures_active_count: u32, - ) -> Self { - self.max_reference_pictures_active_count = max_reference_pictures_active_count; + pub fn max_active_reference_pictures(mut self, max_active_reference_pictures: u32) -> Self { + self.max_active_reference_pictures = max_active_reference_pictures; self } #[inline] @@ -36546,6 +37363,7 @@ unsafe impl<'a> TaggedStructure for VideoEncodeUsageInfoKHR<'a> { const STRUCTURE_TYPE: StructureType = StructureType::VIDEO_ENCODE_USAGE_INFO_KHR; } unsafe impl ExtendsVideoProfileInfoKHR for VideoEncodeUsageInfoKHR<'_> {} +unsafe impl ExtendsQueryPoolCreateInfo for VideoEncodeUsageInfoKHR<'_> {} impl<'a> VideoEncodeUsageInfoKHR<'a> { #[inline] pub fn video_usage_hints(mut self, video_usage_hints: VideoEncodeUsageFlagsKHR) -> Self { @@ -37011,10 +37829,10 @@ impl<'a> VideoEncodeH264CapabilitiesEXT<'a> { pub struct VideoEncodeH264SessionParametersAddInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub sps_std_count: u32, - pub p_sps_std: *const StdVideoH264SequenceParameterSet, - pub pps_std_count: u32, - pub p_pps_std: *const StdVideoH264PictureParameterSet, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH264SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH264PictureParameterSet, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT<'_> { @@ -37023,10 +37841,10 @@ impl ::std::default::Default for VideoEncodeH264SessionParametersAddInfoEXT<'_> Self { s_type: Self::STRUCTURE_TYPE, p_next: ::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(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), _marker: PhantomData, } } @@ -37041,15 +37859,15 @@ unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR } impl<'a> VideoEncodeH264SessionParametersAddInfoEXT<'a> { #[inline] - pub fn sps_std(mut self, sps_std: &'a [StdVideoH264SequenceParameterSet]) -> Self { - self.sps_std_count = sps_std.len() as _; - self.p_sps_std = sps_std.as_ptr(); + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH264SequenceParameterSet]) -> Self { + self.std_sps_count = std_sp_ss.len() as _; + self.p_std_sp_ss = std_sp_ss.as_ptr(); self } #[inline] - pub fn pps_std(mut self, pps_std: &'a [StdVideoH264PictureParameterSet]) -> Self { - self.pps_std_count = pps_std.len() as _; - self.p_pps_std = pps_std.as_ptr(); + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH264PictureParameterSet]) -> Self { + self.std_pps_count = std_pp_ss.len() as _; + self.p_std_pp_ss = std_pp_ss.as_ptr(); self } } @@ -37060,8 +37878,8 @@ impl<'a> VideoEncodeH264SessionParametersAddInfoEXT<'a> { pub struct VideoEncodeH264SessionParametersCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub max_sps_std_count: u32, - pub max_pps_std_count: u32, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, pub p_parameters_add_info: *const VideoEncodeH264SessionParametersAddInfoEXT<'a>, pub _marker: PhantomData<&'a ()>, } @@ -37071,8 +37889,8 @@ impl ::std::default::Default for VideoEncodeH264SessionParametersCreateInfoEXT<' Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - max_sps_std_count: u32::default(), - max_pps_std_count: u32::default(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), p_parameters_add_info: ::std::ptr::null(), _marker: PhantomData, } @@ -37088,13 +37906,13 @@ unsafe impl ExtendsVideoSessionParametersCreateInfoKHR } impl<'a> VideoEncodeH264SessionParametersCreateInfoEXT<'a> { #[inline] - pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { - self.max_sps_std_count = max_sps_std_count; + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.max_std_sps_count = max_std_sps_count; self } #[inline] - pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self { - self.max_pps_std_count = max_pps_std_count; + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.max_std_pps_count = max_std_pps_count; self } #[inline] @@ -37816,12 +38634,12 @@ impl<'a> VideoEncodeH265CapabilitiesEXT<'a> { pub struct VideoEncodeH265SessionParametersAddInfoEXT<'a> { 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, + pub std_vps_count: u32, + pub p_std_vp_ss: *const StdVideoH265VideoParameterSet, + pub std_sps_count: u32, + pub p_std_sp_ss: *const StdVideoH265SequenceParameterSet, + pub std_pps_count: u32, + pub p_std_pp_ss: *const StdVideoH265PictureParameterSet, pub _marker: PhantomData<&'a ()>, } impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT<'_> { @@ -37830,12 +38648,12 @@ impl ::std::default::Default for VideoEncodeH265SessionParametersAddInfoEXT<'_> Self { s_type: Self::STRUCTURE_TYPE, 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(), + std_vps_count: u32::default(), + p_std_vp_ss: ::std::ptr::null(), + std_sps_count: u32::default(), + p_std_sp_ss: ::std::ptr::null(), + std_pps_count: u32::default(), + p_std_pp_ss: ::std::ptr::null(), _marker: PhantomData, } } @@ -37850,21 +38668,21 @@ unsafe impl ExtendsVideoSessionParametersUpdateInfoKHR } impl<'a> VideoEncodeH265SessionParametersAddInfoEXT<'a> { #[inline] - pub fn vps_std(mut self, vps_std: &'a [StdVideoH265VideoParameterSet]) -> Self { - self.vps_std_count = vps_std.len() as _; - self.p_vps_std = vps_std.as_ptr(); + pub fn std_vp_ss(mut self, std_vp_ss: &'a [StdVideoH265VideoParameterSet]) -> Self { + self.std_vps_count = std_vp_ss.len() as _; + self.p_std_vp_ss = std_vp_ss.as_ptr(); self } #[inline] - pub fn sps_std(mut self, sps_std: &'a [StdVideoH265SequenceParameterSet]) -> Self { - self.sps_std_count = sps_std.len() as _; - self.p_sps_std = sps_std.as_ptr(); + pub fn std_sp_ss(mut self, std_sp_ss: &'a [StdVideoH265SequenceParameterSet]) -> Self { + self.std_sps_count = std_sp_ss.len() as _; + self.p_std_sp_ss = std_sp_ss.as_ptr(); self } #[inline] - pub fn pps_std(mut self, pps_std: &'a [StdVideoH265PictureParameterSet]) -> Self { - self.pps_std_count = pps_std.len() as _; - self.p_pps_std = pps_std.as_ptr(); + pub fn std_pp_ss(mut self, std_pp_ss: &'a [StdVideoH265PictureParameterSet]) -> Self { + self.std_pps_count = std_pp_ss.len() as _; + self.p_std_pp_ss = std_pp_ss.as_ptr(); self } } @@ -37875,9 +38693,9 @@ impl<'a> VideoEncodeH265SessionParametersAddInfoEXT<'a> { pub struct VideoEncodeH265SessionParametersCreateInfoEXT<'a> { 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 max_std_vps_count: u32, + pub max_std_sps_count: u32, + pub max_std_pps_count: u32, pub p_parameters_add_info: *const VideoEncodeH265SessionParametersAddInfoEXT<'a>, pub _marker: PhantomData<&'a ()>, } @@ -37887,9 +38705,9 @@ impl ::std::default::Default for VideoEncodeH265SessionParametersCreateInfoEXT<' Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - max_vps_std_count: u32::default(), - max_sps_std_count: u32::default(), - max_pps_std_count: u32::default(), + max_std_vps_count: u32::default(), + max_std_sps_count: u32::default(), + max_std_pps_count: u32::default(), p_parameters_add_info: ::std::ptr::null(), _marker: PhantomData, } @@ -37905,18 +38723,18 @@ unsafe impl ExtendsVideoSessionParametersCreateInfoKHR } impl<'a> VideoEncodeH265SessionParametersCreateInfoEXT<'a> { #[inline] - pub fn max_vps_std_count(mut self, max_vps_std_count: u32) -> Self { - self.max_vps_std_count = max_vps_std_count; + pub fn max_std_vps_count(mut self, max_std_vps_count: u32) -> Self { + self.max_std_vps_count = max_std_vps_count; self } #[inline] - pub fn max_sps_std_count(mut self, max_sps_std_count: u32) -> Self { - self.max_sps_std_count = max_sps_std_count; + pub fn max_std_sps_count(mut self, max_std_sps_count: u32) -> Self { + self.max_std_sps_count = max_std_sps_count; self } #[inline] - pub fn max_pps_std_count(mut self, max_pps_std_count: u32) -> Self { - self.max_pps_std_count = max_pps_std_count; + pub fn max_std_pps_count(mut self, max_std_pps_count: u32) -> Self { + self.max_std_pps_count = max_std_pps_count; self } #[inline] @@ -38868,6 +39686,872 @@ impl<'a> CuLaunchInfoNVX<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_buffer: Bool32, + pub descriptor_buffer_capture_replay: Bool32, + pub descriptor_buffer_image_layout_ignored: Bool32, + pub descriptor_buffer_push_descriptors: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_buffer: Bool32::default(), + descriptor_buffer_capture_replay: Bool32::default(), + descriptor_buffer_image_layout_ignored: Bool32::default(), + descriptor_buffer_push_descriptors: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { + #[inline] + pub fn descriptor_buffer(mut self, descriptor_buffer: bool) -> Self { + self.descriptor_buffer = descriptor_buffer.into(); + self + } + #[inline] + pub fn descriptor_buffer_capture_replay( + mut self, + descriptor_buffer_capture_replay: bool, + ) -> Self { + self.descriptor_buffer_capture_replay = descriptor_buffer_capture_replay.into(); + self + } + #[inline] + pub fn descriptor_buffer_image_layout_ignored( + mut self, + descriptor_buffer_image_layout_ignored: bool, + ) -> Self { + self.descriptor_buffer_image_layout_ignored = descriptor_buffer_image_layout_ignored.into(); + self + } + #[inline] + pub fn descriptor_buffer_push_descriptors( + mut self, + descriptor_buffer_push_descriptors: bool, + ) -> Self { + self.descriptor_buffer_push_descriptors = descriptor_buffer_push_descriptors.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_descriptor_single_array: Bool32, + pub bufferless_push_descriptors: Bool32, + pub allow_sampler_image_view_post_submit_creation: Bool32, + pub descriptor_buffer_offset_alignment: DeviceSize, + pub max_descriptor_buffer_bindings: u32, + pub max_resource_descriptor_buffer_bindings: u32, + pub max_sampler_descriptor_buffer_bindings: u32, + pub max_embedded_immutable_sampler_bindings: u32, + pub max_embedded_immutable_samplers: u32, + pub buffer_capture_replay_descriptor_data_size: usize, + pub image_capture_replay_descriptor_data_size: usize, + pub image_view_capture_replay_descriptor_data_size: usize, + pub sampler_capture_replay_descriptor_data_size: usize, + pub acceleration_structure_capture_replay_descriptor_data_size: usize, + pub sampler_descriptor_size: usize, + pub combined_image_sampler_descriptor_size: usize, + pub sampled_image_descriptor_size: usize, + pub storage_image_descriptor_size: usize, + pub uniform_texel_buffer_descriptor_size: usize, + pub robust_uniform_texel_buffer_descriptor_size: usize, + pub storage_texel_buffer_descriptor_size: usize, + pub robust_storage_texel_buffer_descriptor_size: usize, + pub uniform_buffer_descriptor_size: usize, + pub robust_uniform_buffer_descriptor_size: usize, + pub storage_buffer_descriptor_size: usize, + pub robust_storage_buffer_descriptor_size: usize, + pub input_attachment_descriptor_size: usize, + pub acceleration_structure_descriptor_size: usize, + pub max_sampler_descriptor_buffer_range: DeviceSize, + pub max_resource_descriptor_buffer_range: DeviceSize, + pub sampler_descriptor_buffer_address_space_size: DeviceSize, + pub resource_descriptor_buffer_address_space_size: DeviceSize, + pub descriptor_buffer_address_space_size: DeviceSize, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_descriptor_single_array: Bool32::default(), + bufferless_push_descriptors: Bool32::default(), + allow_sampler_image_view_post_submit_creation: Bool32::default(), + descriptor_buffer_offset_alignment: DeviceSize::default(), + max_descriptor_buffer_bindings: u32::default(), + max_resource_descriptor_buffer_bindings: u32::default(), + max_sampler_descriptor_buffer_bindings: u32::default(), + max_embedded_immutable_sampler_bindings: u32::default(), + max_embedded_immutable_samplers: u32::default(), + buffer_capture_replay_descriptor_data_size: usize::default(), + image_capture_replay_descriptor_data_size: usize::default(), + image_view_capture_replay_descriptor_data_size: usize::default(), + sampler_capture_replay_descriptor_data_size: usize::default(), + acceleration_structure_capture_replay_descriptor_data_size: usize::default(), + sampler_descriptor_size: usize::default(), + combined_image_sampler_descriptor_size: usize::default(), + sampled_image_descriptor_size: usize::default(), + storage_image_descriptor_size: usize::default(), + uniform_texel_buffer_descriptor_size: usize::default(), + robust_uniform_texel_buffer_descriptor_size: usize::default(), + storage_texel_buffer_descriptor_size: usize::default(), + robust_storage_texel_buffer_descriptor_size: usize::default(), + uniform_buffer_descriptor_size: usize::default(), + robust_uniform_buffer_descriptor_size: usize::default(), + storage_buffer_descriptor_size: usize::default(), + robust_storage_buffer_descriptor_size: usize::default(), + input_attachment_descriptor_size: usize::default(), + acceleration_structure_descriptor_size: usize::default(), + max_sampler_descriptor_buffer_range: DeviceSize::default(), + max_resource_descriptor_buffer_range: DeviceSize::default(), + sampler_descriptor_buffer_address_space_size: DeviceSize::default(), + resource_descriptor_buffer_address_space_size: DeviceSize::default(), + descriptor_buffer_address_space_size: DeviceSize::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorBufferPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { + #[inline] + pub fn combined_image_sampler_descriptor_single_array( + mut self, + combined_image_sampler_descriptor_single_array: bool, + ) -> Self { + self.combined_image_sampler_descriptor_single_array = + combined_image_sampler_descriptor_single_array.into(); + self + } + #[inline] + pub fn bufferless_push_descriptors(mut self, bufferless_push_descriptors: bool) -> Self { + self.bufferless_push_descriptors = bufferless_push_descriptors.into(); + self + } + #[inline] + pub fn allow_sampler_image_view_post_submit_creation( + mut self, + allow_sampler_image_view_post_submit_creation: bool, + ) -> Self { + self.allow_sampler_image_view_post_submit_creation = + allow_sampler_image_view_post_submit_creation.into(); + self + } + #[inline] + pub fn descriptor_buffer_offset_alignment( + mut self, + descriptor_buffer_offset_alignment: DeviceSize, + ) -> Self { + self.descriptor_buffer_offset_alignment = descriptor_buffer_offset_alignment; + self + } + #[inline] + pub fn max_descriptor_buffer_bindings(mut self, max_descriptor_buffer_bindings: u32) -> Self { + self.max_descriptor_buffer_bindings = max_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_resource_descriptor_buffer_bindings( + mut self, + max_resource_descriptor_buffer_bindings: u32, + ) -> Self { + self.max_resource_descriptor_buffer_bindings = max_resource_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_sampler_descriptor_buffer_bindings( + mut self, + max_sampler_descriptor_buffer_bindings: u32, + ) -> Self { + self.max_sampler_descriptor_buffer_bindings = max_sampler_descriptor_buffer_bindings; + self + } + #[inline] + pub fn max_embedded_immutable_sampler_bindings( + mut self, + max_embedded_immutable_sampler_bindings: u32, + ) -> Self { + self.max_embedded_immutable_sampler_bindings = max_embedded_immutable_sampler_bindings; + self + } + #[inline] + pub fn max_embedded_immutable_samplers(mut self, max_embedded_immutable_samplers: u32) -> Self { + self.max_embedded_immutable_samplers = max_embedded_immutable_samplers; + self + } + #[inline] + pub fn buffer_capture_replay_descriptor_data_size( + mut self, + buffer_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.buffer_capture_replay_descriptor_data_size = + buffer_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn image_capture_replay_descriptor_data_size( + mut self, + image_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.image_capture_replay_descriptor_data_size = image_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn image_view_capture_replay_descriptor_data_size( + mut self, + image_view_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.image_view_capture_replay_descriptor_data_size = + image_view_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn sampler_capture_replay_descriptor_data_size( + mut self, + sampler_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.sampler_capture_replay_descriptor_data_size = + sampler_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn acceleration_structure_capture_replay_descriptor_data_size( + mut self, + acceleration_structure_capture_replay_descriptor_data_size: usize, + ) -> Self { + self.acceleration_structure_capture_replay_descriptor_data_size = + acceleration_structure_capture_replay_descriptor_data_size; + self + } + #[inline] + pub fn sampler_descriptor_size(mut self, sampler_descriptor_size: usize) -> Self { + self.sampler_descriptor_size = sampler_descriptor_size; + self + } + #[inline] + pub fn combined_image_sampler_descriptor_size( + mut self, + combined_image_sampler_descriptor_size: usize, + ) -> Self { + self.combined_image_sampler_descriptor_size = combined_image_sampler_descriptor_size; + self + } + #[inline] + pub fn sampled_image_descriptor_size(mut self, sampled_image_descriptor_size: usize) -> Self { + self.sampled_image_descriptor_size = sampled_image_descriptor_size; + self + } + #[inline] + pub fn storage_image_descriptor_size(mut self, storage_image_descriptor_size: usize) -> Self { + self.storage_image_descriptor_size = storage_image_descriptor_size; + self + } + #[inline] + pub fn uniform_texel_buffer_descriptor_size( + mut self, + uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.uniform_texel_buffer_descriptor_size = uniform_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_uniform_texel_buffer_descriptor_size( + mut self, + robust_uniform_texel_buffer_descriptor_size: usize, + ) -> Self { + self.robust_uniform_texel_buffer_descriptor_size = + robust_uniform_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn storage_texel_buffer_descriptor_size( + mut self, + storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.storage_texel_buffer_descriptor_size = storage_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_storage_texel_buffer_descriptor_size( + mut self, + robust_storage_texel_buffer_descriptor_size: usize, + ) -> Self { + self.robust_storage_texel_buffer_descriptor_size = + robust_storage_texel_buffer_descriptor_size; + self + } + #[inline] + pub fn uniform_buffer_descriptor_size(mut self, uniform_buffer_descriptor_size: usize) -> Self { + self.uniform_buffer_descriptor_size = uniform_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_uniform_buffer_descriptor_size( + mut self, + robust_uniform_buffer_descriptor_size: usize, + ) -> Self { + self.robust_uniform_buffer_descriptor_size = robust_uniform_buffer_descriptor_size; + self + } + #[inline] + pub fn storage_buffer_descriptor_size(mut self, storage_buffer_descriptor_size: usize) -> Self { + self.storage_buffer_descriptor_size = storage_buffer_descriptor_size; + self + } + #[inline] + pub fn robust_storage_buffer_descriptor_size( + mut self, + robust_storage_buffer_descriptor_size: usize, + ) -> Self { + self.robust_storage_buffer_descriptor_size = robust_storage_buffer_descriptor_size; + self + } + #[inline] + pub fn input_attachment_descriptor_size( + mut self, + input_attachment_descriptor_size: usize, + ) -> Self { + self.input_attachment_descriptor_size = input_attachment_descriptor_size; + self + } + #[inline] + pub fn acceleration_structure_descriptor_size( + mut self, + acceleration_structure_descriptor_size: usize, + ) -> Self { + self.acceleration_structure_descriptor_size = acceleration_structure_descriptor_size; + self + } + #[inline] + pub fn max_sampler_descriptor_buffer_range( + mut self, + max_sampler_descriptor_buffer_range: DeviceSize, + ) -> Self { + self.max_sampler_descriptor_buffer_range = max_sampler_descriptor_buffer_range; + self + } + #[inline] + pub fn max_resource_descriptor_buffer_range( + mut self, + max_resource_descriptor_buffer_range: DeviceSize, + ) -> Self { + self.max_resource_descriptor_buffer_range = max_resource_descriptor_buffer_range; + self + } + #[inline] + pub fn sampler_descriptor_buffer_address_space_size( + mut self, + sampler_descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.sampler_descriptor_buffer_address_space_size = + sampler_descriptor_buffer_address_space_size; + self + } + #[inline] + pub fn resource_descriptor_buffer_address_space_size( + mut self, + resource_descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.resource_descriptor_buffer_address_space_size = + resource_descriptor_buffer_address_space_size; + self + } + #[inline] + pub fn descriptor_buffer_address_space_size( + mut self, + descriptor_buffer_address_space_size: DeviceSize, + ) -> Self { + self.descriptor_buffer_address_space_size = descriptor_buffer_address_space_size; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub combined_image_sampler_density_map_descriptor_size: usize, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + combined_image_sampler_density_map_descriptor_size: usize::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'_> +{ +} +impl<'a> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + #[inline] + pub fn combined_image_sampler_density_map_descriptor_size( + mut self, + combined_image_sampler_density_map_descriptor_size: usize, + ) -> Self { + self.combined_image_sampler_density_map_descriptor_size = + combined_image_sampler_density_map_descriptor_size; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorAddressInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address: DeviceAddress, + pub range: DeviceSize, + pub format: Format, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DescriptorAddressInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address: DeviceAddress::default(), + range: DeviceSize::default(), + format: Format::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DescriptorAddressInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_ADDRESS_INFO_EXT; +} +impl<'a> DescriptorAddressInfoEXT<'a> { + #[inline] + pub fn address(mut self, address: DeviceAddress) -> Self { + self.address = address; + self + } + #[inline] + pub fn range(mut self, range: DeviceSize) -> Self { + self.range = range; + self + } + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.format = format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorBufferBindingInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address: DeviceAddress, + pub usage: BufferUsageFlags, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DescriptorBufferBindingInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address: DeviceAddress::default(), + usage: BufferUsageFlags::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DescriptorBufferBindingInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_BUFFER_BINDING_INFO_EXT; +} +pub unsafe trait ExtendsDescriptorBufferBindingInfoEXT {} +impl<'a> DescriptorBufferBindingInfoEXT<'a> { + #[inline] + pub fn address(mut self, address: DeviceAddress) -> Self { + self.address = address; + self + } + #[inline] + pub fn usage(mut self, usage: BufferUsageFlags) -> Self { + self.usage = usage; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.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 = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; + } + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub buffer: Buffer, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + buffer: Buffer::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; +} +unsafe impl ExtendsDescriptorBufferBindingInfoEXT + for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'_> +{ +} +impl<'a> DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.buffer = buffer; + self + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union DescriptorDataEXT<'a> { + pub p_sampler: *const Sampler, + pub p_combined_image_sampler: *const DescriptorImageInfo, + pub p_input_attachment_image: *const DescriptorImageInfo, + pub p_sampled_image: *const DescriptorImageInfo, + pub p_storage_image: *const DescriptorImageInfo, + pub p_uniform_texel_buffer: *const DescriptorAddressInfoEXT<'a>, + pub p_storage_texel_buffer: *const DescriptorAddressInfoEXT<'a>, + pub p_uniform_buffer: *const DescriptorAddressInfoEXT<'a>, + pub p_storage_buffer: *const DescriptorAddressInfoEXT<'a>, + pub acceleration_structure: DeviceAddress, +} +impl<'a> ::std::default::Default for DescriptorDataEXT<'a> { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DescriptorGetInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: DescriptorType, + pub data: DescriptorDataEXT<'a>, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DescriptorGetInfoEXT<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DescriptorGetInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("ty", &self.ty) + .field("data", &"union") + .finish() + } +} +impl ::std::default::Default for DescriptorGetInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: DescriptorType::default(), + data: DescriptorDataEXT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DescriptorGetInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_GET_INFO_EXT; +} +impl<'a> DescriptorGetInfoEXT<'a> { + #[inline] + pub fn ty(mut self, ty: DescriptorType) -> Self { + self.ty = ty; + self + } + #[inline] + pub fn data(mut self, data: DescriptorDataEXT<'a>) -> Self { + self.data = data; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub buffer: Buffer, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BufferCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + buffer: Buffer::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BufferCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> BufferCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.buffer = buffer; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image: Image, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImageCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image: Image::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImageCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> ImageCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn image(mut self, image: Image) -> Self { + self.image = image; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageViewCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImageViewCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImageViewCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> ImageViewCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.image_view = image_view; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub sampler: Sampler, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SamplerCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + sampler: Sampler::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SamplerCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> SamplerCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn sampler(mut self, sampler: Sampler) -> Self { + self.sampler = sampler; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub acceleration_structure: AccelerationStructureKHR, + pub acceleration_structure_nv: AccelerationStructureNV, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for AccelerationStructureCaptureDescriptorDataInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + acceleration_structure: AccelerationStructureKHR::default(), + acceleration_structure_nv: AccelerationStructureNV::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; +} +impl<'a> AccelerationStructureCaptureDescriptorDataInfoEXT<'a> { + #[inline] + pub fn acceleration_structure( + mut self, + acceleration_structure: AccelerationStructureKHR, + ) -> Self { + self.acceleration_structure = acceleration_structure; + self + } + #[inline] + pub fn acceleration_structure_nv( + mut self, + acceleration_structure_nv: AccelerationStructureNV, + ) -> Self { + self.acceleration_structure_nv = acceleration_structure_nv; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub opaque_capture_descriptor_data: *const c_void, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + opaque_capture_descriptor_data: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; +} +unsafe impl ExtendsBufferCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {} +unsafe impl ExtendsImageCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {} +unsafe impl ExtendsImageViewCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {} +unsafe impl ExtendsSamplerCreateInfo for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> {} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR + for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> +{ +} +unsafe impl ExtendsAccelerationStructureCreateInfoNV + for OpaqueCaptureDescriptorDataCreateInfoEXT<'_> +{ +} +impl<'a> OpaqueCaptureDescriptorDataCreateInfoEXT<'a> { + #[inline] + pub fn opaque_capture_descriptor_data( + mut self, + opaque_capture_descriptor_data: *const c_void, + ) -> Self { + self.opaque_capture_descriptor_data = opaque_capture_descriptor_data; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceShaderIntegerDotProductFeatures<'a> { pub s_type: StructureType, @@ -42017,6 +43701,666 @@ impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { } } #[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapBuildInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub ty: MicromapTypeEXT, + pub flags: BuildMicromapFlagsEXT, + pub mode: BuildMicromapModeEXT, + pub dst_micromap: MicromapEXT, + pub usage_counts_count: u32, + pub p_usage_counts: *const MicromapUsageEXT, + pub pp_usage_counts: *const *const MicromapUsageEXT, + pub data: DeviceOrHostAddressConstKHR, + pub scratch_data: DeviceOrHostAddressKHR, + pub triangle_array: DeviceOrHostAddressConstKHR, + pub triangle_array_stride: DeviceSize, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for MicromapBuildInfoEXT<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("MicromapBuildInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("ty", &self.ty) + .field("flags", &self.flags) + .field("mode", &self.mode) + .field("dst_micromap", &self.dst_micromap) + .field("usage_counts_count", &self.usage_counts_count) + .field("p_usage_counts", &self.p_usage_counts) + .field("pp_usage_counts", &self.pp_usage_counts) + .field("data", &"union") + .field("scratch_data", &"union") + .field("triangle_array", &"union") + .field("triangle_array_stride", &self.triangle_array_stride) + .finish() + } +} +impl ::std::default::Default for MicromapBuildInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + ty: MicromapTypeEXT::default(), + flags: BuildMicromapFlagsEXT::default(), + mode: BuildMicromapModeEXT::default(), + dst_micromap: MicromapEXT::default(), + usage_counts_count: u32::default(), + p_usage_counts: ::std::ptr::null(), + pp_usage_counts: ::std::ptr::null(), + data: DeviceOrHostAddressConstKHR::default(), + scratch_data: DeviceOrHostAddressKHR::default(), + triangle_array: DeviceOrHostAddressConstKHR::default(), + triangle_array_stride: DeviceSize::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for MicromapBuildInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_INFO_EXT; +} +impl<'a> MicromapBuildInfoEXT<'a> { + #[inline] + pub fn ty(mut self, ty: MicromapTypeEXT) -> Self { + self.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: BuildMicromapFlagsEXT) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn mode(mut self, mode: BuildMicromapModeEXT) -> Self { + self.mode = mode; + self + } + #[inline] + pub fn dst_micromap(mut self, dst_micromap: MicromapEXT) -> Self { + self.dst_micromap = dst_micromap; + self + } + #[inline] + pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self { + self.usage_counts_count = usage_counts.len() as _; + self.p_usage_counts = usage_counts.as_ptr(); + self + } + #[inline] + pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self { + self.usage_counts_count = usage_counts_ptrs.len() as _; + self.pp_usage_counts = usage_counts_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { + self.data = data; + self + } + #[inline] + pub fn scratch_data(mut self, scratch_data: DeviceOrHostAddressKHR) -> Self { + self.scratch_data = scratch_data; + self + } + #[inline] + pub fn triangle_array(mut self, triangle_array: DeviceOrHostAddressConstKHR) -> Self { + self.triangle_array = triangle_array; + self + } + #[inline] + pub fn triangle_array_stride(mut self, triangle_array_stride: DeviceSize) -> Self { + self.triangle_array_stride = triangle_array_stride; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapCreateInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub create_flags: MicromapCreateFlagsEXT, + pub buffer: Buffer, + pub offset: DeviceSize, + pub size: DeviceSize, + pub ty: MicromapTypeEXT, + pub device_address: DeviceAddress, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for MicromapCreateInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + create_flags: MicromapCreateFlagsEXT::default(), + buffer: Buffer::default(), + offset: DeviceSize::default(), + size: DeviceSize::default(), + ty: MicromapTypeEXT::default(), + device_address: DeviceAddress::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for MicromapCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_CREATE_INFO_EXT; +} +impl<'a> MicromapCreateInfoEXT<'a> { + #[inline] + pub fn create_flags(mut self, create_flags: MicromapCreateFlagsEXT) -> Self { + self.create_flags = create_flags; + self + } + #[inline] + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.buffer = buffer; + self + } + #[inline] + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.offset = offset; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.size = size; + self + } + #[inline] + pub fn ty(mut self, ty: MicromapTypeEXT) -> Self { + self.ty = ty; + self + } + #[inline] + pub fn device_address(mut self, device_address: DeviceAddress) -> Self { + self.device_address = device_address; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapVersionInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_version_data: *const [u8; 2 * UUID_SIZE], + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for MicromapVersionInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_version_data: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for MicromapVersionInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_VERSION_INFO_EXT; +} +impl<'a> MicromapVersionInfoEXT<'a> { + #[inline] + pub fn version_data(mut self, version_data: &'a [u8; 2 * UUID_SIZE]) -> Self { + self.p_version_data = version_data; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMicromapInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: MicromapEXT, + pub dst: MicromapEXT, + pub mode: CopyMicromapModeEXT, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for CopyMicromapInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: MicromapEXT::default(), + dst: MicromapEXT::default(), + mode: CopyMicromapModeEXT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CopyMicromapInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_INFO_EXT; +} +impl<'a> CopyMicromapInfoEXT<'a> { + #[inline] + pub fn src(mut self, src: MicromapEXT) -> Self { + self.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: MicromapEXT) -> Self { + self.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self { + self.mode = mode; + self + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMicromapToMemoryInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: MicromapEXT, + pub dst: DeviceOrHostAddressKHR, + pub mode: CopyMicromapModeEXT, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyMicromapToMemoryInfoEXT<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyMicromapToMemoryInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &self.src) + .field("dst", &"union") + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyMicromapToMemoryInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: MicromapEXT::default(), + dst: DeviceOrHostAddressKHR::default(), + mode: CopyMicromapModeEXT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CopyMicromapToMemoryInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_TO_MEMORY_INFO_EXT; +} +impl<'a> CopyMicromapToMemoryInfoEXT<'a> { + #[inline] + pub fn src(mut self, src: MicromapEXT) -> Self { + self.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self { + self.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self { + self.mode = mode; + self + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CopyMemoryToMicromapInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub src: DeviceOrHostAddressConstKHR, + pub dst: MicromapEXT, + pub mode: CopyMicromapModeEXT, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for CopyMemoryToMicromapInfoEXT<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("CopyMemoryToMicromapInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("src", &"union") + .field("dst", &self.dst) + .field("mode", &self.mode) + .finish() + } +} +impl ::std::default::Default for CopyMemoryToMicromapInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + src: DeviceOrHostAddressConstKHR::default(), + dst: MicromapEXT::default(), + mode: CopyMicromapModeEXT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CopyMemoryToMicromapInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MEMORY_TO_MICROMAP_INFO_EXT; +} +impl<'a> CopyMemoryToMicromapInfoEXT<'a> { + #[inline] + pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self { + self.src = src; + self + } + #[inline] + pub fn dst(mut self, dst: MicromapEXT) -> Self { + self.dst = dst; + self + } + #[inline] + pub fn mode(mut self, mode: CopyMicromapModeEXT) -> Self { + self.mode = mode; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MicromapBuildSizesInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub micromap_size: DeviceSize, + pub build_scratch_size: DeviceSize, + pub discardable: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for MicromapBuildSizesInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + micromap_size: DeviceSize::default(), + build_scratch_size: DeviceSize::default(), + discardable: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for MicromapBuildSizesInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_SIZES_INFO_EXT; +} +impl<'a> MicromapBuildSizesInfoEXT<'a> { + #[inline] + pub fn micromap_size(mut self, micromap_size: DeviceSize) -> Self { + self.micromap_size = micromap_size; + self + } + #[inline] + pub fn build_scratch_size(mut self, build_scratch_size: DeviceSize) -> Self { + self.build_scratch_size = build_scratch_size; + self + } + #[inline] + pub fn discardable(mut self, discardable: bool) -> Self { + self.discardable = discardable.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MicromapUsageEXT { + pub count: u32, + pub subdivision_level: u32, + pub format: u32, +} +impl MicromapUsageEXT { + #[inline] + pub fn count(mut self, count: u32) -> Self { + self.count = count; + self + } + #[inline] + pub fn subdivision_level(mut self, subdivision_level: u32) -> Self { + self.subdivision_level = subdivision_level; + self + } + #[inline] + pub fn format(mut self, format: u32) -> Self { + self.format = format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct MicromapTriangleEXT { + pub data_offset: u32, + pub subdivision_level: u16, + pub format: u16, +} +impl MicromapTriangleEXT { + #[inline] + pub fn data_offset(mut self, data_offset: u32) -> Self { + self.data_offset = data_offset; + self + } + #[inline] + pub fn subdivision_level(mut self, subdivision_level: u16) -> Self { + self.subdivision_level = subdivision_level; + self + } + #[inline] + pub fn format(mut self, format: u16) -> Self { + self.format = format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub micromap: Bool32, + pub micromap_capture_replay: Bool32, + pub micromap_host_commands: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceOpacityMicromapFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + micromap: Bool32::default(), + micromap_capture_replay: Bool32::default(), + micromap_host_commands: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { + #[inline] + pub fn micromap(mut self, micromap: bool) -> Self { + self.micromap = micromap.into(); + self + } + #[inline] + pub fn micromap_capture_replay(mut self, micromap_capture_replay: bool) -> Self { + self.micromap_capture_replay = micromap_capture_replay.into(); + self + } + #[inline] + pub fn micromap_host_commands(mut self, micromap_host_commands: bool) -> Self { + self.micromap_host_commands = micromap_host_commands.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_opacity2_state_subdivision_level: u32, + pub max_opacity4_state_subdivision_level: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceOpacityMicromapPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_opacity2_state_subdivision_level: u32::default(), + max_opacity4_state_subdivision_level: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpacityMicromapPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { + #[inline] + pub fn max_opacity2_state_subdivision_level( + mut self, + max_opacity2_state_subdivision_level: u32, + ) -> Self { + self.max_opacity2_state_subdivision_level = max_opacity2_state_subdivision_level; + self + } + #[inline] + pub fn max_opacity4_state_subdivision_level( + mut self, + max_opacity4_state_subdivision_level: u32, + ) -> Self { + self.max_opacity4_state_subdivision_level = max_opacity4_state_subdivision_level; + self + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureTrianglesOpacityMicromapEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub index_type: IndexType, + pub index_buffer: DeviceOrHostAddressConstKHR, + pub index_stride: DeviceSize, + pub base_triangle: u32, + pub usage_counts_count: u32, + pub p_usage_counts: *const MicromapUsageEXT, + pub pp_usage_counts: *const *const MicromapUsageEXT, + pub micromap: MicromapEXT, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureTrianglesOpacityMicromapEXT<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureTrianglesOpacityMicromapEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("index_type", &self.index_type) + .field("index_buffer", &"union") + .field("index_stride", &self.index_stride) + .field("base_triangle", &self.base_triangle) + .field("usage_counts_count", &self.usage_counts_count) + .field("p_usage_counts", &self.p_usage_counts) + .field("pp_usage_counts", &self.pp_usage_counts) + .field("micromap", &self.micromap) + .finish() + } +} +impl ::std::default::Default for AccelerationStructureTrianglesOpacityMicromapEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + index_type: IndexType::default(), + index_buffer: DeviceOrHostAddressConstKHR::default(), + index_stride: DeviceSize::default(), + base_triangle: u32::default(), + usage_counts_count: u32::default(), + p_usage_counts: ::std::ptr::null(), + pp_usage_counts: ::std::ptr::null(), + micromap: MicromapEXT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for AccelerationStructureTrianglesOpacityMicromapEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureTrianglesOpacityMicromapEXT<'_> +{ +} +impl<'a> AccelerationStructureTrianglesOpacityMicromapEXT<'a> { + #[inline] + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.index_type = index_type; + self + } + #[inline] + pub fn index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self { + self.index_buffer = index_buffer; + self + } + #[inline] + pub fn index_stride(mut self, index_stride: DeviceSize) -> Self { + self.index_stride = index_stride; + self + } + #[inline] + pub fn base_triangle(mut self, base_triangle: u32) -> Self { + self.base_triangle = base_triangle; + self + } + #[inline] + pub fn usage_counts(mut self, usage_counts: &'a [MicromapUsageEXT]) -> Self { + self.usage_counts_count = usage_counts.len() as _; + self.p_usage_counts = usage_counts.as_ptr(); + self + } + #[inline] + pub fn usage_counts_ptrs(mut self, usage_counts_ptrs: &'a [&'a MicromapUsageEXT]) -> Self { + self.usage_counts_count = usage_counts_ptrs.len() as _; + self.pp_usage_counts = usage_counts_ptrs.as_ptr().cast(); + self + } + #[inline] + pub fn micromap(mut self, micromap: MicromapEXT) -> Self { + self.micromap = micromap; + self + } +} +#[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] #[doc = ""] @@ -43156,3 +45500,993 @@ impl<'a> PhysicalDeviceDepthClampZeroOneFeaturesEXT<'a> { self } } +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub report_address_binding: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceAddressBindingReportFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + report_address_binding: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAddressBindingReportFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { + #[inline] + pub fn report_address_binding(mut self, report_address_binding: bool) -> Self { + self.report_address_binding = report_address_binding.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceAddressBindingCallbackDataEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: DeviceAddressBindingFlagsEXT, + pub base_address: DeviceAddress, + pub size: DeviceSize, + pub binding_type: DeviceAddressBindingTypeEXT, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DeviceAddressBindingCallbackDataEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: DeviceAddressBindingFlagsEXT::default(), + base_address: DeviceAddress::default(), + size: DeviceSize::default(), + binding_type: DeviceAddressBindingTypeEXT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DeviceAddressBindingCallbackDataEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; +} +unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT for DeviceAddressBindingCallbackDataEXT<'_> {} +impl<'a> DeviceAddressBindingCallbackDataEXT<'a> { + #[inline] + pub fn flags(mut self, flags: DeviceAddressBindingFlagsEXT) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn base_address(mut self, base_address: DeviceAddress) -> Self { + self.base_address = base_address; + self + } + #[inline] + pub fn size(mut self, size: DeviceSize) -> Self { + self.size = size; + self + } + #[inline] + pub fn binding_type(mut self, binding_type: DeviceAddressBindingTypeEXT) -> Self { + self.binding_type = binding_type; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpticalFlowFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub optical_flow: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceOpticalFlowFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + optical_flow: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceOpticalFlowFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNV<'_> {} +impl<'a> PhysicalDeviceOpticalFlowFeaturesNV<'a> { + #[inline] + pub fn optical_flow(mut self, optical_flow: bool) -> Self { + self.optical_flow = optical_flow.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceOpticalFlowPropertiesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV, + pub supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV, + pub hint_supported: Bool32, + pub cost_supported: Bool32, + pub bidirectional_flow_supported: Bool32, + pub global_flow_supported: Bool32, + pub min_width: u32, + pub min_height: u32, + pub max_width: u32, + pub max_height: u32, + pub max_num_regions_of_interest: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceOpticalFlowPropertiesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV::default(), + supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV::default(), + hint_supported: Bool32::default(), + cost_supported: Bool32::default(), + bidirectional_flow_supported: Bool32::default(), + global_flow_supported: Bool32::default(), + min_width: u32::default(), + min_height: u32::default(), + max_width: u32::default(), + max_height: u32::default(), + max_num_regions_of_interest: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceOpticalFlowPropertiesNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNV<'_> {} +impl<'a> PhysicalDeviceOpticalFlowPropertiesNV<'a> { + #[inline] + pub fn supported_output_grid_sizes( + mut self, + supported_output_grid_sizes: OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.supported_output_grid_sizes = supported_output_grid_sizes; + self + } + #[inline] + pub fn supported_hint_grid_sizes( + mut self, + supported_hint_grid_sizes: OpticalFlowGridSizeFlagsNV, + ) -> Self { + self.supported_hint_grid_sizes = supported_hint_grid_sizes; + self + } + #[inline] + pub fn hint_supported(mut self, hint_supported: bool) -> Self { + self.hint_supported = hint_supported.into(); + self + } + #[inline] + pub fn cost_supported(mut self, cost_supported: bool) -> Self { + self.cost_supported = cost_supported.into(); + self + } + #[inline] + pub fn bidirectional_flow_supported(mut self, bidirectional_flow_supported: bool) -> Self { + self.bidirectional_flow_supported = bidirectional_flow_supported.into(); + self + } + #[inline] + pub fn global_flow_supported(mut self, global_flow_supported: bool) -> Self { + self.global_flow_supported = global_flow_supported.into(); + self + } + #[inline] + pub fn min_width(mut self, min_width: u32) -> Self { + self.min_width = min_width; + self + } + #[inline] + pub fn min_height(mut self, min_height: u32) -> Self { + self.min_height = min_height; + self + } + #[inline] + pub fn max_width(mut self, max_width: u32) -> Self { + self.max_width = max_width; + self + } + #[inline] + pub fn max_height(mut self, max_height: u32) -> Self { + self.max_height = max_height; + self + } + #[inline] + pub fn max_num_regions_of_interest(mut self, max_num_regions_of_interest: u32) -> Self { + self.max_num_regions_of_interest = max_num_regions_of_interest; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowImageFormatInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub usage: OpticalFlowUsageFlagsNV, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for OpticalFlowImageFormatInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + usage: OpticalFlowUsageFlagsNV::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for OpticalFlowImageFormatInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; +} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNV<'_> {} +unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNV<'_> {} +impl<'a> OpticalFlowImageFormatInfoNV<'a> { + #[inline] + pub fn usage(mut self, usage: OpticalFlowUsageFlagsNV) -> Self { + self.usage = usage; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowImageFormatPropertiesNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format: Format, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for OpticalFlowImageFormatPropertiesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format: Format::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for OpticalFlowImageFormatPropertiesNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; +} +impl<'a> OpticalFlowImageFormatPropertiesNV<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.format = format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowSessionCreateInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub width: u32, + pub height: u32, + pub image_format: Format, + pub flow_vector_format: Format, + pub cost_format: Format, + pub output_grid_size: OpticalFlowGridSizeFlagsNV, + pub hint_grid_size: OpticalFlowGridSizeFlagsNV, + pub performance_level: OpticalFlowPerformanceLevelNV, + pub flags: OpticalFlowSessionCreateFlagsNV, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for OpticalFlowSessionCreateInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + width: u32::default(), + height: u32::default(), + image_format: Format::default(), + flow_vector_format: Format::default(), + cost_format: Format::default(), + output_grid_size: OpticalFlowGridSizeFlagsNV::default(), + hint_grid_size: OpticalFlowGridSizeFlagsNV::default(), + performance_level: OpticalFlowPerformanceLevelNV::default(), + flags: OpticalFlowSessionCreateFlagsNV::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for OpticalFlowSessionCreateInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_SESSION_CREATE_INFO_NV; +} +pub unsafe trait ExtendsOpticalFlowSessionCreateInfoNV {} +impl<'a> OpticalFlowSessionCreateInfoNV<'a> { + #[inline] + pub fn width(mut self, width: u32) -> Self { + self.width = width; + self + } + #[inline] + pub fn height(mut self, height: u32) -> Self { + self.height = height; + self + } + #[inline] + pub fn image_format(mut self, image_format: Format) -> Self { + self.image_format = image_format; + self + } + #[inline] + pub fn flow_vector_format(mut self, flow_vector_format: Format) -> Self { + self.flow_vector_format = flow_vector_format; + self + } + #[inline] + pub fn cost_format(mut self, cost_format: Format) -> Self { + self.cost_format = cost_format; + self + } + #[inline] + pub fn output_grid_size(mut self, output_grid_size: OpticalFlowGridSizeFlagsNV) -> Self { + self.output_grid_size = output_grid_size; + self + } + #[inline] + pub fn hint_grid_size(mut self, hint_grid_size: OpticalFlowGridSizeFlagsNV) -> Self { + self.hint_grid_size = hint_grid_size; + self + } + #[inline] + pub fn performance_level(mut self, performance_level: OpticalFlowPerformanceLevelNV) -> Self { + self.performance_level = performance_level; + self + } + #[inline] + pub fn flags(mut self, flags: OpticalFlowSessionCreateFlagsNV) -> Self { + self.flags = flags; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `x.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 = <*mut T>::cast(next); + let last_next = ptr_chain_iter(next).last().unwrap(); + (*last_next).p_next = self.p_next as _; + self.p_next = next_ptr; + } + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowSessionCreatePrivateDataInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub id: u32, + pub size: u32, + pub p_private_data: *const c_void, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for OpticalFlowSessionCreatePrivateDataInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + id: u32::default(), + size: u32::default(), + p_private_data: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for OpticalFlowSessionCreatePrivateDataInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; +} +unsafe impl ExtendsOpticalFlowSessionCreateInfoNV + for OpticalFlowSessionCreatePrivateDataInfoNV<'_> +{ +} +impl<'a> OpticalFlowSessionCreatePrivateDataInfoNV<'a> { + #[inline] + pub fn id(mut self, id: u32) -> Self { + self.id = id; + self + } + #[inline] + pub fn size(mut self, size: u32) -> Self { + self.size = size; + self + } + #[inline] + pub fn private_data(mut self, private_data: *const c_void) -> Self { + self.p_private_data = private_data; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OpticalFlowExecuteInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub flags: OpticalFlowExecuteFlagsNV, + pub region_count: u32, + pub p_regions: *const Rect2D, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for OpticalFlowExecuteInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + flags: OpticalFlowExecuteFlagsNV::default(), + region_count: u32::default(), + p_regions: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for OpticalFlowExecuteInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_EXECUTE_INFO_NV; +} +impl<'a> OpticalFlowExecuteInfoNV<'a> { + #[inline] + pub fn flags(mut self, flags: OpticalFlowExecuteFlagsNV) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn regions(mut self, regions: &'a [Rect2D]) -> Self { + self.region_count = regions.len() as _; + self.p_regions = regions.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFaultFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub device_fault: Bool32, + pub device_fault_vendor_binary: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceFaultFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + device_fault: Bool32::default(), + device_fault_vendor_binary: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceFaultFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceFaultFeaturesEXT<'a> { + #[inline] + pub fn device_fault(mut self, device_fault: bool) -> Self { + self.device_fault = device_fault.into(); + self + } + #[inline] + pub fn device_fault_vendor_binary(mut self, device_fault_vendor_binary: bool) -> Self { + self.device_fault_vendor_binary = device_fault_vendor_binary.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DeviceFaultAddressInfoEXT { + pub address_type: DeviceFaultAddressTypeEXT, + pub reported_address: DeviceAddress, + pub address_precision: DeviceSize, +} +impl DeviceFaultAddressInfoEXT { + #[inline] + pub fn address_type(mut self, address_type: DeviceFaultAddressTypeEXT) -> Self { + self.address_type = address_type; + self + } + #[inline] + pub fn reported_address(mut self, reported_address: DeviceAddress) -> Self { + self.reported_address = reported_address; + self + } + #[inline] + pub fn address_precision(mut self, address_precision: DeviceSize) -> Self { + self.address_precision = address_precision; + self + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultVendorInfoEXT { + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub vendor_fault_code: u64, + pub vendor_fault_data: u64, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DeviceFaultVendorInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DeviceFaultVendorInfoEXT") + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("vendor_fault_code", &self.vendor_fault_code) + .field("vendor_fault_data", &self.vendor_fault_data) + .finish() + } +} +impl ::std::default::Default for DeviceFaultVendorInfoEXT { + #[inline] + fn default() -> Self { + Self { + description: unsafe { ::std::mem::zeroed() }, + vendor_fault_code: u64::default(), + vendor_fault_data: u64::default(), + } + } +} +impl DeviceFaultVendorInfoEXT { + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.description = description; + self + } + #[inline] + pub fn vendor_fault_code(mut self, vendor_fault_code: u64) -> Self { + self.vendor_fault_code = vendor_fault_code; + self + } + #[inline] + pub fn vendor_fault_data(mut self, vendor_fault_data: u64) -> Self { + self.vendor_fault_data = vendor_fault_data; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultCountsEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub address_info_count: u32, + pub vendor_info_count: u32, + pub vendor_binary_size: DeviceSize, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DeviceFaultCountsEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + address_info_count: u32::default(), + vendor_info_count: u32::default(), + vendor_binary_size: DeviceSize::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DeviceFaultCountsEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_COUNTS_EXT; +} +impl<'a> DeviceFaultCountsEXT<'a> { + #[inline] + pub fn address_info_count(mut self, address_info_count: u32) -> Self { + self.address_info_count = address_info_count; + self + } + #[inline] + pub fn vendor_info_count(mut self, vendor_info_count: u32) -> Self { + self.vendor_info_count = vendor_info_count; + self + } + #[inline] + pub fn vendor_binary_size(mut self, vendor_binary_size: DeviceSize) -> Self { + self.vendor_binary_size = vendor_binary_size; + self + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub p_address_infos: *mut DeviceFaultAddressInfoEXT, + pub p_vendor_infos: *mut DeviceFaultVendorInfoEXT, + pub p_vendor_binary_data: *mut c_void, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for DeviceFaultInfoEXT<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("DeviceFaultInfoEXT") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("p_address_infos", &self.p_address_infos) + .field("p_vendor_infos", &self.p_vendor_infos) + .field("p_vendor_binary_data", &self.p_vendor_binary_data) + .finish() + } +} +impl ::std::default::Default for DeviceFaultInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + description: unsafe { ::std::mem::zeroed() }, + p_address_infos: ::std::ptr::null_mut(), + p_vendor_infos: ::std::ptr::null_mut(), + p_vendor_binary_data: ::std::ptr::null_mut(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DeviceFaultInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_INFO_EXT; +} +impl<'a> DeviceFaultInfoEXT<'a> { + #[inline] + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.description = description; + self + } + #[inline] + pub fn address_infos(mut self, address_infos: &'a mut DeviceFaultAddressInfoEXT) -> Self { + self.p_address_infos = address_infos; + self + } + #[inline] + pub fn vendor_infos(mut self, vendor_infos: &'a mut DeviceFaultVendorInfoEXT) -> Self { + self.p_vendor_infos = vendor_infos; + self + } + #[inline] + pub fn vendor_binary_data(mut self, vendor_binary_data: *mut c_void) -> Self { + self.p_vendor_binary_data = vendor_binary_data; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceFaultVendorBinaryHeaderVersionOneEXT { + pub header_size: u32, + pub header_version: DeviceFaultVendorBinaryHeaderVersionEXT, + pub vendor_id: u32, + pub device_id: u32, + pub driver_version: u32, + pub pipeline_cache_uuid: [u8; UUID_SIZE], + pub application_name_offset: u32, + pub application_version: u32, + pub engine_name_offset: u32, +} +impl ::std::default::Default for DeviceFaultVendorBinaryHeaderVersionOneEXT { + #[inline] + fn default() -> Self { + Self { + header_size: u32::default(), + header_version: DeviceFaultVendorBinaryHeaderVersionEXT::default(), + vendor_id: u32::default(), + device_id: u32::default(), + driver_version: u32::default(), + pipeline_cache_uuid: unsafe { ::std::mem::zeroed() }, + application_name_offset: u32::default(), + application_version: u32::default(), + engine_name_offset: u32::default(), + } + } +} +impl DeviceFaultVendorBinaryHeaderVersionOneEXT { + #[inline] + pub fn header_size(mut self, header_size: u32) -> Self { + self.header_size = header_size; + self + } + #[inline] + pub fn header_version( + mut self, + header_version: DeviceFaultVendorBinaryHeaderVersionEXT, + ) -> Self { + self.header_version = header_version; + self + } + #[inline] + pub fn vendor_id(mut self, vendor_id: u32) -> Self { + self.vendor_id = vendor_id; + self + } + #[inline] + pub fn device_id(mut self, device_id: u32) -> Self { + self.device_id = device_id; + self + } + #[inline] + pub fn driver_version(mut self, driver_version: u32) -> Self { + self.driver_version = driver_version; + self + } + #[inline] + pub fn pipeline_cache_uuid(mut self, pipeline_cache_uuid: [u8; UUID_SIZE]) -> Self { + self.pipeline_cache_uuid = pipeline_cache_uuid; + self + } + #[inline] + pub fn application_name_offset(mut self, application_name_offset: u32) -> Self { + self.application_name_offset = application_name_offset; + self + } + #[inline] + pub fn application_version(mut self, application_version: u32) -> Self { + self.application_version = application_version; + self + } + #[inline] + pub fn engine_name_offset(mut self, engine_name_offset: u32) -> Self { + self.engine_name_offset = engine_name_offset; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DecompressMemoryRegionNV { + pub src_address: DeviceAddress, + pub dst_address: DeviceAddress, + pub compressed_size: DeviceSize, + pub decompressed_size: DeviceSize, + pub decompression_method: MemoryDecompressionMethodFlagsNV, +} +impl DecompressMemoryRegionNV { + #[inline] + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.src_address = src_address; + self + } + #[inline] + pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self { + self.dst_address = dst_address; + self + } + #[inline] + pub fn compressed_size(mut self, compressed_size: DeviceSize) -> Self { + self.compressed_size = compressed_size; + self + } + #[inline] + pub fn decompressed_size(mut self, decompressed_size: DeviceSize) -> Self { + self.decompressed_size = decompressed_size; + self + } + #[inline] + pub fn decompression_method( + mut self, + decompression_method: MemoryDecompressionMethodFlagsNV, + ) -> Self { + self.decompression_method = decompression_method; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_core_mask: u64, + pub shader_core_count: u32, + pub shader_warps_per_core: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_core_mask: u64::default(), + shader_core_count: u32::default(), + shader_warps_per_core: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'_> {} +impl<'a> PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { + #[inline] + pub fn shader_core_mask(mut self, shader_core_mask: u64) -> Self { + self.shader_core_mask = shader_core_mask; + self + } + #[inline] + pub fn shader_core_count(mut self, shader_core_count: u32) -> Self { + self.shader_core_count = shader_core_count; + self + } + #[inline] + pub fn shader_warps_per_core(mut self, shader_warps_per_core: u32) -> Self { + self.shader_warps_per_core = shader_warps_per_core; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_core_builtins: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_core_builtins: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'_> {} +impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { + #[inline] + pub fn shader_core_builtins(mut self, shader_core_builtins: bool) -> Self { + self.shader_core_builtins = shader_core_builtins.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_invocation_reorder: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_invocation_reorder: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'_> {} +impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { + #[inline] + pub fn ray_tracing_invocation_reorder(mut self, ray_tracing_invocation_reorder: bool) -> Self { + self.ray_tracing_invocation_reorder = ray_tracing_invocation_reorder.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_invocation_reorder_reordering_hint: + RayTracingInvocationReorderModeNV::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'_> +{ +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { + #[inline] + pub fn ray_tracing_invocation_reorder_reordering_hint( + mut self, + ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV, + ) -> Self { + self.ray_tracing_invocation_reorder_reordering_hint = + ray_tracing_invocation_reorder_reordering_hint; + self + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 4c18550..40c534d 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1118,6 +1118,24 @@ impl ObjectType { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] +#[doc = ""] +pub struct RayTracingInvocationReorderModeNV(pub(crate) i32); +impl RayTracingInvocationReorderModeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl RayTracingInvocationReorderModeNV { + pub const NONE: Self = Self(0); + pub const REORDER: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] #[doc = ""] pub struct SemaphoreType(pub(crate) i32); impl SemaphoreType { @@ -1803,6 +1821,8 @@ impl DriverId { pub const MESA_VENUS: Self = Self(22); #[doc = "Mesa open source project"] pub const MESA_DOZEN: Self = Self(23); + #[doc = "Mesa open source project"] + pub const MESA_NVK: Self = Self(24); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -2463,6 +2483,24 @@ impl AccelerationStructureMotionInstanceTypeNV { } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] +#[doc = ""] +pub struct DeviceAddressBindingTypeEXT(pub(crate) i32); +impl DeviceAddressBindingTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceAddressBindingTypeEXT { + pub const BIND: Self = Self(0); + pub const UNBIND: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] #[doc = ""] pub struct QueryResultStatusKHR(pub(crate) i32); impl QueryResultStatusKHR { @@ -2579,6 +2617,184 @@ impl PipelineRobustnessImageBehaviorEXT { pub const ROBUST_IMAGE_ACCESS: Self = Self(2); pub const ROBUST_IMAGE_ACCESS_2: Self = Self(3); } +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpticalFlowPerformanceLevelNV(pub(crate) i32); +impl OpticalFlowPerformanceLevelNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpticalFlowPerformanceLevelNV { + pub const UNKNOWN: Self = Self(0); + pub const SLOW: Self = Self(1); + pub const MEDIUM: Self = Self(2); + pub const FAST: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpticalFlowSessionBindingPointNV(pub(crate) i32); +impl OpticalFlowSessionBindingPointNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpticalFlowSessionBindingPointNV { + pub const UNKNOWN: Self = Self(0); + pub const INPUT: Self = Self(1); + pub const REFERENCE: Self = Self(2); + pub const HINT: Self = Self(3); + pub const FLOW_VECTOR: Self = Self(4); + pub const BACKWARD_FLOW_VECTOR: Self = Self(5); + pub const COST: Self = Self(6); + pub const BACKWARD_COST: Self = Self(7); + pub const GLOBAL_FLOW: Self = Self(8); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct MicromapTypeEXT(pub(crate) i32); +impl MicromapTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl MicromapTypeEXT { + pub const OPACITY_MICROMAP: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CopyMicromapModeEXT(pub(crate) i32); +impl CopyMicromapModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CopyMicromapModeEXT { + pub const CLONE: Self = Self(0); + pub const SERIALIZE: Self = Self(1); + pub const DESERIALIZE: Self = Self(2); + pub const COMPACT: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BuildMicromapModeEXT(pub(crate) i32); +impl BuildMicromapModeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BuildMicromapModeEXT { + pub const BUILD: Self = Self(0); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpacityMicromapFormatEXT(pub(crate) i32); +impl OpacityMicromapFormatEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpacityMicromapFormatEXT { + pub const TYPE_2_STATE: Self = Self(1); + pub const TYPE_4_STATE: Self = Self(2); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OpacityMicromapSpecialIndexEXT(pub(crate) i32); +impl OpacityMicromapSpecialIndexEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OpacityMicromapSpecialIndexEXT { + pub const FULLY_TRANSPARENT: Self = Self(-1); + pub const FULLY_OPAQUE: Self = Self(-2); + pub const FULLY_UNKNOWN_TRANSPARENT: Self = Self(-3); + pub const FULLY_UNKNOWN_OPAQUE: Self = Self(-4); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceFaultAddressTypeEXT(pub(crate) i32); +impl DeviceFaultAddressTypeEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceFaultAddressTypeEXT { + #[doc = "Currently unused"] + pub const NONE: Self = Self(0); + pub const READ_INVALID: Self = Self(1); + pub const WRITE_INVALID: Self = Self(2); + pub const EXECUTE_INVALID: Self = Self(3); + pub const INSTRUCTION_POINTER_UNKNOWN: Self = Self(4); + pub const INSTRUCTION_POINTER_INVALID: Self = Self(5); + pub const INSTRUCTION_POINTER_FAULT: Self = Self(6); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct DeviceFaultVendorBinaryHeaderVersionEXT(pub(crate) i32); +impl DeviceFaultVendorBinaryHeaderVersionEXT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl DeviceFaultVendorBinaryHeaderVersionEXT { + pub const ONE: Self = Self(1); +} impl fmt::Debug for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -2625,6 +2841,8 @@ impl fmt::Debug for ObjectType { Self::DEFERRED_OPERATION_KHR => Some("DEFERRED_OPERATION_KHR"), Self::INDIRECT_COMMANDS_LAYOUT_NV => Some("INDIRECT_COMMANDS_LAYOUT_NV"), Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"), + Self::MICROMAP_EXT => Some("MICROMAP_EXT"), + Self::OPTICAL_FLOW_SESSION_NV => Some("OPTICAL_FLOW_SESSION_NV"), Self::SAMPLER_YCBCR_CONVERSION => Some("SAMPLER_YCBCR_CONVERSION"), Self::DESCRIPTOR_UPDATE_TEMPLATE => Some("DESCRIPTOR_UPDATE_TEMPLATE"), Self::PRIVATE_DATA_SLOT => Some("PRIVATE_DATA_SLOT"), diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index d42cbdd..4f12a2f 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -1846,7 +1846,7 @@ impl KhrVideoQueueFn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_queue\0") } } - pub const SPEC_VERSION: u32 = 5u32; + pub const SPEC_VERSION: u32 = 7u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn( @@ -2253,7 +2253,7 @@ impl KhrVideoDecodeQueueFn { #[allow(non_camel_case_types)] pub type PFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn( command_buffer: CommandBuffer, - p_frame_info: *const VideoDecodeInfoKHR, + p_decode_info: *const VideoDecodeInfoKHR, ); #[derive(Clone)] pub struct KhrVideoDecodeQueueFn { @@ -2270,7 +2270,7 @@ impl KhrVideoDecodeQueueFn { cmd_decode_video_khr: unsafe { unsafe extern "system" fn cmd_decode_video_khr( _command_buffer: CommandBuffer, - _p_frame_info: *const VideoDecodeInfoKHR, + _p_decode_info: *const VideoDecodeInfoKHR, ) { panic!(concat!("Unable to load ", stringify!(cmd_decode_video_khr))) } @@ -3096,7 +3096,7 @@ impl ExtVideoEncodeH264Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") } } - pub const SPEC_VERSION: u32 = 8u32; + pub const SPEC_VERSION: u32 = 9u32; } #[derive(Clone)] pub struct ExtVideoEncodeH264Fn {} @@ -3133,7 +3133,7 @@ impl ExtVideoEncodeH265Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h265\0") } } - pub const SPEC_VERSION: u32 = 8u32; + pub const SPEC_VERSION: u32 = 9u32; } #[derive(Clone)] pub struct ExtVideoEncodeH265Fn {} @@ -3170,7 +3170,7 @@ impl ExtVideoDecodeH264Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_decode_h264\0") } } - pub const SPEC_VERSION: u32 = 6u32; + pub const SPEC_VERSION: u32 = 7u32; } #[derive(Clone)] pub struct ExtVideoDecodeH264Fn {} @@ -3188,7 +3188,6 @@ impl ExtVideoDecodeH264Fn { impl StructureType { pub const VIDEO_DECODE_H264_CAPABILITIES_EXT: Self = Self(1_000_040_000); pub const VIDEO_DECODE_H264_PICTURE_INFO_EXT: Self = Self(1_000_040_001); - pub const VIDEO_DECODE_H264_MVC_INFO_EXT: Self = Self(1_000_040_002); pub const VIDEO_DECODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_040_003); pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_040_004); pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_040_005); @@ -11688,7 +11687,7 @@ impl ExtVideoDecodeH265Fn { pub const fn name() -> &'static ::std::ffi::CStr { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_decode_h265\0") } } - pub const SPEC_VERSION: u32 = 4u32; + pub const SPEC_VERSION: u32 = 5u32; } #[derive(Clone)] pub struct ExtVideoDecodeH265Fn {} @@ -16308,18 +16307,18 @@ impl NvExtension292Fn { Self {} } } -impl NvExtension293Fn { +impl NvPresentBarrierFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_293\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_present_barrier\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct NvExtension293Fn {} -unsafe impl Send for NvExtension293Fn {} -unsafe impl Sync for NvExtension293Fn {} -impl NvExtension293Fn { +pub struct NvPresentBarrierFn {} +unsafe impl Send for NvPresentBarrierFn {} +unsafe impl Sync for NvPresentBarrierFn {} +impl NvPresentBarrierFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -16327,6 +16326,12 @@ impl NvExtension293Fn { Self {} } } +#[doc = "Generated from 'VK_NV_present_barrier'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: Self = Self(1_000_292_000); + pub const SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: Self = Self(1_000_292_001); + pub const SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: Self = Self(1_000_292_002); +} impl KhrShaderNonSemanticInfoFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -17356,62 +17361,409 @@ impl AmdExtension316Fn { Self {} } } -impl AmdExtension317Fn { +impl ExtDescriptorBufferFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_317\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_buffer\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn( + device: Device, + layout: DescriptorSetLayout, + p_layout_size_in_bytes: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn( + device: Device, + layout: DescriptorSetLayout, + binding: u32, + p_offset: *mut DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDescriptorEXT = unsafe extern "system" fn( + device: Device, + p_descriptor_info: *const DescriptorGetInfoEXT, + data_size: usize, + p_descriptor: *mut c_void, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + buffer_count: u32, + p_binding_infos: *const DescriptorBufferBindingInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + first_set: u32, + set_count: u32, + p_buffer_indices: *const u32, + p_offsets: *const DeviceSize, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + pipeline_bind_point: PipelineBindPoint, + layout: PipelineLayout, + set: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const BufferCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const ImageCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const ImageViewCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn( + device: Device, + p_info: *const SamplerCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = + unsafe extern "system" fn( + device: Device, + p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT, + p_data: *mut c_void, + ) -> Result; #[derive(Clone)] -pub struct AmdExtension317Fn {} -unsafe impl Send for AmdExtension317Fn {} -unsafe impl Sync for AmdExtension317Fn {} -impl AmdExtension317Fn { +pub struct ExtDescriptorBufferFn { + pub get_descriptor_set_layout_size_ext: PFN_vkGetDescriptorSetLayoutSizeEXT, + pub get_descriptor_set_layout_binding_offset_ext: PFN_vkGetDescriptorSetLayoutBindingOffsetEXT, + pub get_descriptor_ext: PFN_vkGetDescriptorEXT, + pub cmd_bind_descriptor_buffers_ext: PFN_vkCmdBindDescriptorBuffersEXT, + pub cmd_set_descriptor_buffer_offsets_ext: PFN_vkCmdSetDescriptorBufferOffsetsEXT, + pub cmd_bind_descriptor_buffer_embedded_samplers_ext: + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, + pub get_buffer_opaque_capture_descriptor_data_ext: + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT, + pub get_image_opaque_capture_descriptor_data_ext: PFN_vkGetImageOpaqueCaptureDescriptorDataEXT, + pub get_image_view_opaque_capture_descriptor_data_ext: + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT, + pub get_sampler_opaque_capture_descriptor_data_ext: + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT, + pub get_acceleration_structure_opaque_capture_descriptor_data_ext: + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, +} +unsafe impl Send for ExtDescriptorBufferFn {} +unsafe impl Sync for ExtDescriptorBufferFn {} +impl ExtDescriptorBufferFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + get_descriptor_set_layout_size_ext: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_size_ext( + _device: Device, + _layout: DescriptorSetLayout, + _p_layout_size_in_bytes: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_size_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutSizeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_size_ext + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_set_layout_binding_offset_ext: unsafe { + unsafe extern "system" fn get_descriptor_set_layout_binding_offset_ext( + _device: Device, + _layout: DescriptorSetLayout, + _binding: u32, + _p_offset: *mut DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_descriptor_set_layout_binding_offset_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDescriptorSetLayoutBindingOffsetEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_descriptor_set_layout_binding_offset_ext + } else { + ::std::mem::transmute(val) + } + }, + get_descriptor_ext: unsafe { + unsafe extern "system" fn get_descriptor_ext( + _device: Device, + _p_descriptor_info: *const DescriptorGetInfoEXT, + _data_size: usize, + _p_descriptor: *mut c_void, + ) { + panic!(concat!("Unable to load ", stringify!(get_descriptor_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDescriptorEXT\0"); + let val = _f(cname); + if val.is_null() { + get_descriptor_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_buffers_ext: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_buffers_ext( + _command_buffer: CommandBuffer, + _buffer_count: u32, + _p_binding_infos: *const DescriptorBufferBindingInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_buffers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindDescriptorBuffersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_buffers_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_descriptor_buffer_offsets_ext: unsafe { + unsafe extern "system" fn cmd_set_descriptor_buffer_offsets_ext( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _first_set: u32, + _set_count: u32, + _p_buffer_indices: *const u32, + _p_offsets: *const DeviceSize, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_descriptor_buffer_offsets_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDescriptorBufferOffsetsEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_descriptor_buffer_offsets_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_bind_descriptor_buffer_embedded_samplers_ext: unsafe { + unsafe extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers_ext( + _command_buffer: CommandBuffer, + _pipeline_bind_point: PipelineBindPoint, + _layout: PipelineLayout, + _set: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_bind_descriptor_buffer_embedded_samplers_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdBindDescriptorBufferEmbeddedSamplersEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_bind_descriptor_buffer_embedded_samplers_ext + } else { + ::std::mem::transmute(val) + } + }, + get_buffer_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_buffer_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const BufferCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_buffer_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetBufferOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_buffer_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_image_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_image_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const ImageCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_image_view_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_image_view_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const ImageViewCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_image_view_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetImageViewOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_image_view_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_sampler_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_sampler_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const SamplerCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_sampler_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetSamplerOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_sampler_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + get_acceleration_structure_opaque_capture_descriptor_data_ext: unsafe { + unsafe extern "system" fn get_acceleration_structure_opaque_capture_descriptor_data_ext( + _device: Device, + _p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT, + _p_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_acceleration_structure_opaque_capture_descriptor_data_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_acceleration_structure_opaque_capture_descriptor_data_ext + } else { + ::std::mem::transmute(val) + } + }, + } } } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl AccelerationStructureCreateFlagsKHR { - pub const RESERVED_3_AMD: Self = Self(0b1000); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl AccessFlags2 { - pub const RESERVED_41_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const DESCRIPTOR_BUFFER_READ_EXT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl BufferCreateFlags { - pub const RESERVED_5_AMD: Self = Self(0b10_0000); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b10_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl BufferUsageFlags { - pub const RESERVED_21_AMD: Self = Self(0b10_0000_0000_0000_0000_0000); - pub const RESERVED_22_AMD: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const SAMPLER_DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000); + pub const RESOURCE_DESCRIPTOR_BUFFER_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); + pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT: Self = + Self(0b100_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl DescriptorSetLayoutCreateFlags { - pub const RESERVED_4_AMD: Self = Self(0b1_0000); - pub const RESERVED_5_AMD: Self = Self(0b10_0000); + pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b1_0000); + pub const EMBEDDED_IMMUTABLE_SAMPLERS_EXT: Self = Self(0b10_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl ImageCreateFlags { - pub const RESERVED_16_AMD: Self = Self(0b1_0000_0000_0000_0000); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl ImageViewCreateFlags { - pub const RESERVED_2_AMD: Self = Self(0b100); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b100); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl PipelineCreateFlags { - pub const RESERVED_29_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); + pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_AMD_extension_317'"] +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] impl SamplerCreateFlags { - pub const RESERVED_3_AMD: Self = Self(0b1000); + pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_descriptor_buffer'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: Self = Self(1_000_316_000); + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: Self = + Self(1_000_316_001); + pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: Self = Self(1_000_316_002); + pub const DESCRIPTOR_ADDRESS_INFO_EXT: Self = Self(1_000_316_003); + pub const DESCRIPTOR_GET_INFO_EXT: Self = Self(1_000_316_004); + pub const BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_005); + pub const IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_006); + pub const IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_007); + pub const SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_008); + pub const OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: Self = Self(1_000_316_010); + pub const DESCRIPTOR_BUFFER_BINDING_INFO_EXT: Self = Self(1_000_316_011); + pub const DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: Self = + Self(1_000_316_012); + pub const ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_009); } impl AmdExtension318Fn { #[inline] @@ -18402,25 +18754,60 @@ impl Format { impl StructureType { pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: Self = Self(1_000_340_000); } -impl ExtExtension342Fn { +impl ExtDeviceFaultFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_342\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_fault\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn( + device: Device, + p_fault_counts: *mut DeviceFaultCountsEXT, + p_fault_info: *mut DeviceFaultInfoEXT, +) -> Result; #[derive(Clone)] -pub struct ExtExtension342Fn {} -unsafe impl Send for ExtExtension342Fn {} -unsafe impl Sync for ExtExtension342Fn {} -impl ExtExtension342Fn { +pub struct ExtDeviceFaultFn { + pub get_device_fault_info_ext: PFN_vkGetDeviceFaultInfoEXT, +} +unsafe impl Send for ExtDeviceFaultFn {} +unsafe impl Sync for ExtDeviceFaultFn {} +impl ExtDeviceFaultFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + get_device_fault_info_ext: unsafe { + unsafe extern "system" fn get_device_fault_info_ext( + _device: Device, + _p_fault_counts: *mut DeviceFaultCountsEXT, + _p_fault_info: *mut DeviceFaultInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_device_fault_info_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceFaultInfoEXT\0"); + let val = _f(cname); + if val.is_null() { + get_device_fault_info_ext + } else { + ::std::mem::transmute(val) + } + }, + } } } +#[doc = "Generated from 'VK_EXT_device_fault'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FAULT_FEATURES_EXT: Self = Self(1_000_341_000); + pub const DEVICE_FAULT_COUNTS_EXT: Self = Self(1_000_341_001); + pub const DEVICE_FAULT_INFO_EXT: Self = Self(1_000_341_002); +} impl ArmRasterizationOrderAttachmentAccessFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -18830,18 +19217,22 @@ impl ExtPhysicalDeviceDrmFn { impl StructureType { pub const PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: Self = Self(1_000_353_000); } -impl ExtExtension355Fn { +impl ExtDeviceAddressBindingReportFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_355\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_device_address_binding_report\0", + ) + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtExtension355Fn {} -unsafe impl Send for ExtExtension355Fn {} -unsafe impl Sync for ExtExtension355Fn {} -impl ExtExtension355Fn { +pub struct ExtDeviceAddressBindingReportFn {} +unsafe impl Send for ExtDeviceAddressBindingReportFn {} +unsafe impl Sync for ExtDeviceAddressBindingReportFn {} +impl ExtDeviceAddressBindingReportFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -18849,6 +19240,15 @@ impl ExtExtension355Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_device_address_binding_report'"] +impl DebugUtilsMessageTypeFlagsEXT { + pub const DEVICE_ADDRESS_BINDING: Self = Self(0b1000); +} +#[doc = "Generated from 'VK_EXT_device_address_binding_report'"] +impl StructureType { + pub const PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: Self = Self(1_000_354_000); + pub const DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: Self = Self(1_000_354_001); +} impl ExtDepthClipControlFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -20582,54 +20982,462 @@ impl KhrExtension396Fn { Self {} } } -impl NvExtension397Fn { +impl ExtOpacityMicromapFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_397\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_opacity_micromap\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 2u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCreateMicromapEXT = unsafe extern "system" fn( + device: Device, + p_create_info: *const MicromapCreateInfoEXT, + p_allocator: *const AllocationCallbacks, + p_micromap: *mut MicromapEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyMicromapEXT = unsafe extern "system" fn( + device: Device, + micromap: MicromapEXT, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdBuildMicromapsEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + info_count: u32, + p_infos: *const MicromapBuildInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBuildMicromapsEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + info_count: u32, + p_infos: *const MicromapBuildInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMicromapEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMicromapInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMicromapToMemoryEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMicromapToMemoryInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCopyMemoryToMicromapEXT = unsafe extern "system" fn( + device: Device, + deferred_operation: DeferredOperationKHR, + p_info: *const CopyMemoryToMicromapInfoEXT, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkWriteMicromapsPropertiesEXT = unsafe extern "system" fn( + device: Device, + micromap_count: u32, + p_micromaps: *const MicromapEXT, + query_type: QueryType, + data_size: usize, + p_data: *mut c_void, + stride: usize, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMicromapEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, p_info: *const CopyMicromapInfoEXT); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMicromapToMemoryEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyMicromapToMemoryInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryToMicromapEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_info: *const CopyMemoryToMicromapInfoEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdWriteMicromapsPropertiesEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + micromap_count: u32, + p_micromaps: *const MicromapEXT, + query_type: QueryType, + query_pool: QueryPool, + first_query: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetDeviceMicromapCompatibilityEXT = unsafe extern "system" fn( + device: Device, + p_version_info: *const MicromapVersionInfoEXT, + p_compatibility: *mut AccelerationStructureCompatibilityKHR, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetMicromapBuildSizesEXT = unsafe extern "system" fn( + device: Device, + build_type: AccelerationStructureBuildTypeKHR, + p_build_info: *const MicromapBuildInfoEXT, + p_size_info: *mut MicromapBuildSizesInfoEXT, +); #[derive(Clone)] -pub struct NvExtension397Fn {} -unsafe impl Send for NvExtension397Fn {} -unsafe impl Sync for NvExtension397Fn {} -impl NvExtension397Fn { +pub struct ExtOpacityMicromapFn { + pub create_micromap_ext: PFN_vkCreateMicromapEXT, + pub destroy_micromap_ext: PFN_vkDestroyMicromapEXT, + pub cmd_build_micromaps_ext: PFN_vkCmdBuildMicromapsEXT, + pub build_micromaps_ext: PFN_vkBuildMicromapsEXT, + pub copy_micromap_ext: PFN_vkCopyMicromapEXT, + pub copy_micromap_to_memory_ext: PFN_vkCopyMicromapToMemoryEXT, + pub copy_memory_to_micromap_ext: PFN_vkCopyMemoryToMicromapEXT, + pub write_micromaps_properties_ext: PFN_vkWriteMicromapsPropertiesEXT, + pub cmd_copy_micromap_ext: PFN_vkCmdCopyMicromapEXT, + pub cmd_copy_micromap_to_memory_ext: PFN_vkCmdCopyMicromapToMemoryEXT, + pub cmd_copy_memory_to_micromap_ext: PFN_vkCmdCopyMemoryToMicromapEXT, + pub cmd_write_micromaps_properties_ext: PFN_vkCmdWriteMicromapsPropertiesEXT, + pub get_device_micromap_compatibility_ext: PFN_vkGetDeviceMicromapCompatibilityEXT, + pub get_micromap_build_sizes_ext: PFN_vkGetMicromapBuildSizesEXT, +} +unsafe impl Send for ExtOpacityMicromapFn {} +unsafe impl Sync for ExtOpacityMicromapFn {} +impl ExtOpacityMicromapFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + create_micromap_ext: unsafe { + unsafe extern "system" fn create_micromap_ext( + _device: Device, + _p_create_info: *const MicromapCreateInfoEXT, + _p_allocator: *const AllocationCallbacks, + _p_micromap: *mut MicromapEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(create_micromap_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + create_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + destroy_micromap_ext: unsafe { + unsafe extern "system" fn destroy_micromap_ext( + _device: Device, + _micromap: MicromapEXT, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!("Unable to load ", stringify!(destroy_micromap_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + destroy_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_build_micromaps_ext: unsafe { + unsafe extern "system" fn cmd_build_micromaps_ext( + _command_buffer: CommandBuffer, + _info_count: u32, + _p_infos: *const MicromapBuildInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_build_micromaps_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBuildMicromapsEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_build_micromaps_ext + } else { + ::std::mem::transmute(val) + } + }, + build_micromaps_ext: unsafe { + unsafe extern "system" fn build_micromaps_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _info_count: u32, + _p_infos: *const MicromapBuildInfoEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(build_micromaps_ext))) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBuildMicromapsEXT\0"); + let val = _f(cname); + if val.is_null() { + build_micromaps_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_micromap_ext: unsafe { + unsafe extern "system" fn copy_micromap_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMicromapInfoEXT, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(copy_micromap_ext))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_micromap_to_memory_ext: unsafe { + unsafe extern "system" fn copy_micromap_to_memory_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMicromapToMemoryInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_micromap_to_memory_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapToMemoryEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_micromap_to_memory_ext + } else { + ::std::mem::transmute(val) + } + }, + copy_memory_to_micromap_ext: unsafe { + unsafe extern "system" fn copy_memory_to_micromap_ext( + _device: Device, + _deferred_operation: DeferredOperationKHR, + _p_info: *const CopyMemoryToMicromapInfoEXT, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(copy_memory_to_micromap_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + copy_memory_to_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + write_micromaps_properties_ext: unsafe { + unsafe extern "system" fn write_micromaps_properties_ext( + _device: Device, + _micromap_count: u32, + _p_micromaps: *const MicromapEXT, + _query_type: QueryType, + _data_size: usize, + _p_data: *mut c_void, + _stride: usize, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(write_micromaps_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkWriteMicromapsPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + write_micromaps_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_micromap_ext: unsafe { + unsafe extern "system" fn cmd_copy_micromap_ext( + _command_buffer: CommandBuffer, + _p_info: *const CopyMicromapInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_micromap_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_micromap_to_memory_ext: unsafe { + unsafe extern "system" fn cmd_copy_micromap_to_memory_ext( + _command_buffer: CommandBuffer, + _p_info: *const CopyMicromapToMemoryInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_micromap_to_memory_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMicromapToMemoryEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_micromap_to_memory_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_memory_to_micromap_ext: unsafe { + unsafe extern "system" fn cmd_copy_memory_to_micromap_ext( + _command_buffer: CommandBuffer, + _p_info: *const CopyMemoryToMicromapInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_to_micromap_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMemoryToMicromapEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_to_micromap_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_write_micromaps_properties_ext: unsafe { + unsafe extern "system" fn cmd_write_micromaps_properties_ext( + _command_buffer: CommandBuffer, + _micromap_count: u32, + _p_micromaps: *const MicromapEXT, + _query_type: QueryType, + _query_pool: QueryPool, + _first_query: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_write_micromaps_properties_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdWriteMicromapsPropertiesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_write_micromaps_properties_ext + } else { + ::std::mem::transmute(val) + } + }, + get_device_micromap_compatibility_ext: unsafe { + unsafe extern "system" fn get_device_micromap_compatibility_ext( + _device: Device, + _p_version_info: *const MicromapVersionInfoEXT, + _p_compatibility: *mut AccelerationStructureCompatibilityKHR, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_device_micromap_compatibility_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetDeviceMicromapCompatibilityEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_device_micromap_compatibility_ext + } else { + ::std::mem::transmute(val) + } + }, + get_micromap_build_sizes_ext: unsafe { + unsafe extern "system" fn get_micromap_build_sizes_ext( + _device: Device, + _build_type: AccelerationStructureBuildTypeKHR, + _p_build_info: *const MicromapBuildInfoEXT, + _p_size_info: *mut MicromapBuildSizesInfoEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_micromap_build_sizes_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetMicromapBuildSizesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + get_micromap_build_sizes_ext + } else { + ::std::mem::transmute(val) + } + }, + } } } -#[doc = "Generated from 'VK_NV_extension_397'"] +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl AccessFlags2 { - pub const RESERVED_44_NV: Self = + pub const MICROMAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); - pub const RESERVED_45_NV: Self = + pub const MICROMAP_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_NV_extension_397'"] +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl BufferUsageFlags { - pub const RESERVED_23_NV: Self = Self(0b1000_0000_0000_0000_0000_0000); - pub const RESERVED_24_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const MICROMAP_BUILD_INPUT_READ_ONLY_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const MICROMAP_STORAGE_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_NV_extension_397'"] +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl BuildAccelerationStructureFlagsKHR { - pub const RESERVED_6_NV: Self = Self(0b100_0000); - pub const RESERVED_7_NV: Self = Self(0b1000_0000); + pub const ALLOW_OPACITY_MICROMAP_UPDATE_EXT: Self = Self(0b100_0000); + pub const ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b1000_0000); + pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: Self = Self(0b1_0000_0000); } -#[doc = "Generated from 'VK_NV_extension_397'"] +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl GeometryInstanceFlagsKHR { - pub const RESERVED_4_NV: Self = Self(0b1_0000); - pub const RESERVED_5_NV: Self = Self(0b10_0000); + pub const FORCE_OPACITY_MICROMAP_2_STATE_EXT: Self = Self(0b1_0000); + pub const DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b10_0000); } -#[doc = "Generated from 'VK_NV_extension_397'"] +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl ObjectType { + pub const MICROMAP_EXT: Self = Self(1_000_396_000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl PipelineCreateFlags { - pub const RESERVED_24_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_NV_extension_397'"] +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] impl PipelineStageFlags2 { - pub const RESERVED_30_NV: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); + pub const MICROMAP_BUILD_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl QueryType { + pub const MICROMAP_SERIALIZATION_SIZE_EXT: Self = Self(1_000_396_000); + pub const MICROMAP_COMPACTED_SIZE_EXT: Self = Self(1_000_396_001); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl StructureType { + pub const MICROMAP_BUILD_INFO_EXT: Self = Self(1_000_396_000); + pub const MICROMAP_VERSION_INFO_EXT: Self = Self(1_000_396_001); + pub const COPY_MICROMAP_INFO_EXT: Self = Self(1_000_396_002); + pub const COPY_MICROMAP_TO_MEMORY_INFO_EXT: Self = Self(1_000_396_003); + pub const COPY_MEMORY_TO_MICROMAP_INFO_EXT: Self = Self(1_000_396_004); + pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: Self = Self(1_000_396_005); + pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: Self = Self(1_000_396_006); + pub const MICROMAP_CREATE_INFO_EXT: Self = Self(1_000_396_007); + pub const MICROMAP_BUILD_SIZES_INFO_EXT: Self = Self(1_000_396_008); + pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: Self = Self(1_000_396_009); } impl NvExtension398Fn { #[inline] @@ -20800,6 +21608,15 @@ impl HuaweiExtension405Fn { Self {} } } +#[doc = "Generated from 'VK_HUAWEI_extension_405'"] +impl PipelineStageFlags2 { + pub const RESEVED_41_HUAWEI: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_HUAWEI_extension_405'"] +impl ShaderStageFlags { + pub const RESERVED_19_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000); +} impl HuaweiExtension406Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -21231,6 +22048,10 @@ impl ExtExtension420Fn { Self {} } } +#[doc = "Generated from 'VK_EXT_extension_420'"] +impl SwapchainCreateFlagsKHR { + pub const RESERVED_4_EXT: Self = Self(0b1_0000); +} impl ValveDescriptorSetHostMappingFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -21444,44 +22265,180 @@ impl StructureType { Self(1_000_425_001); pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: Self = Self(1_000_425_002); } -impl NvExtension427Fn { +impl NvCopyMemoryIndirectFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_427\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_copy_memory_indirect\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryIndirectNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + copy_buffer_address: DeviceAddress, + copy_count: u32, + stride: u32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCopyMemoryToImageIndirectNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + copy_buffer_address: DeviceAddress, + copy_count: u32, + stride: u32, + dst_image: Image, + dst_image_layout: ImageLayout, + p_image_subresources: *const ImageSubresourceLayers, +); #[derive(Clone)] -pub struct NvExtension427Fn {} -unsafe impl Send for NvExtension427Fn {} -unsafe impl Sync for NvExtension427Fn {} -impl NvExtension427Fn { +pub struct NvCopyMemoryIndirectFn { + pub cmd_copy_memory_indirect_nv: PFN_vkCmdCopyMemoryIndirectNV, + pub cmd_copy_memory_to_image_indirect_nv: PFN_vkCmdCopyMemoryToImageIndirectNV, +} +unsafe impl Send for NvCopyMemoryIndirectFn {} +unsafe impl Sync for NvCopyMemoryIndirectFn {} +impl NvCopyMemoryIndirectFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + cmd_copy_memory_indirect_nv: unsafe { + unsafe extern "system" fn cmd_copy_memory_indirect_nv( + _command_buffer: CommandBuffer, + _copy_buffer_address: DeviceAddress, + _copy_count: u32, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_indirect_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMemoryIndirectNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_indirect_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_copy_memory_to_image_indirect_nv: unsafe { + unsafe extern "system" fn cmd_copy_memory_to_image_indirect_nv( + _command_buffer: CommandBuffer, + _copy_buffer_address: DeviceAddress, + _copy_count: u32, + _stride: u32, + _dst_image: Image, + _dst_image_layout: ImageLayout, + _p_image_subresources: *const ImageSubresourceLayers, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_copy_memory_to_image_indirect_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdCopyMemoryToImageIndirectNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_copy_memory_to_image_indirect_nv + } else { + ::std::mem::transmute(val) + } + }, + } } } -impl NvExtension428Fn { +#[doc = "Generated from 'VK_NV_copy_memory_indirect'"] +impl StructureType { + pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: Self = Self(1_000_426_000); + pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: Self = Self(1_000_426_001); +} +impl NvMemoryDecompressionFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_428\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_memory_decompression\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDecompressMemoryNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + decompress_region_count: u32, + p_decompress_memory_regions: *const DecompressMemoryRegionNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdDecompressMemoryIndirectCountNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + indirect_commands_address: DeviceAddress, + indirect_commands_count_address: DeviceAddress, + stride: u32, +); #[derive(Clone)] -pub struct NvExtension428Fn {} -unsafe impl Send for NvExtension428Fn {} -unsafe impl Sync for NvExtension428Fn {} -impl NvExtension428Fn { +pub struct NvMemoryDecompressionFn { + pub cmd_decompress_memory_nv: PFN_vkCmdDecompressMemoryNV, + pub cmd_decompress_memory_indirect_count_nv: PFN_vkCmdDecompressMemoryIndirectCountNV, +} +unsafe impl Send for NvMemoryDecompressionFn {} +unsafe impl Sync for NvMemoryDecompressionFn {} +impl NvMemoryDecompressionFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + cmd_decompress_memory_nv: unsafe { + unsafe extern "system" fn cmd_decompress_memory_nv( + _command_buffer: CommandBuffer, + _decompress_region_count: u32, + _p_decompress_memory_regions: *const DecompressMemoryRegionNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_decompress_memory_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDecompressMemoryNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_decompress_memory_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_decompress_memory_indirect_count_nv: unsafe { + unsafe extern "system" fn cmd_decompress_memory_indirect_count_nv( + _command_buffer: CommandBuffer, + _indirect_commands_address: DeviceAddress, + _indirect_commands_count_address: DeviceAddress, + _stride: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_decompress_memory_indirect_count_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdDecompressMemoryIndirectCountNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_decompress_memory_indirect_count_nv + } else { + ::std::mem::transmute(val) + } + }, + } } } +#[doc = "Generated from 'VK_NV_memory_decompression'"] +impl StructureType { + pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: Self = Self(1_000_427_000); + pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: Self = Self(1_000_427_001); +} impl NvExtension429Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -22061,25 +23018,867 @@ impl GoogleExtension455Fn { Self {} } } -impl NvExtension456Fn { +impl ExtExtendedDynamicState3Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_456\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state3\0") + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 2u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetTessellationDomainOriginEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + domain_origin: TessellationDomainOrigin, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthClampEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clamp_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetPolygonModeEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, polygon_mode: PolygonMode); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRasterizationSamplesEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + rasterization_samples: SampleCountFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetSampleMaskEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + samples: SampleCountFlags, + p_sample_mask: *const SampleMask, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetAlphaToCoverageEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_coverage_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetAlphaToOneEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_one_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLogicOpEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorBlendEnableEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_blend_enables: *const Bool32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorBlendEquationEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_blend_equations: *const ColorBlendEquationEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorWriteMaskEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_write_masks: *const ColorComponentFlags, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRasterizationStreamEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, rasterization_stream: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetConservativeRasterizationModeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + conservative_rasterization_mode: ConservativeRasterizationModeEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + extra_primitive_overestimation_size: f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthClipEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clip_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetSampleLocationsEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, sample_locations_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetColorBlendAdvancedEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_attachment: u32, + attachment_count: u32, + p_color_blend_advanced: *const ColorBlendAdvancedEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetProvokingVertexModeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + provoking_vertex_mode: ProvokingVertexModeEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineRasterizationModeEXT = unsafe extern "system" fn( + command_buffer: CommandBuffer, + line_rasterization_mode: LineRasterizationModeEXT, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetLineStippleEnableEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, stippled_line_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetDepthClipNegativeOneToOneEXT = + unsafe extern "system" fn(command_buffer: CommandBuffer, negative_one_to_one: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportWScalingEnableNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, viewport_w_scaling_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetViewportSwizzleNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + first_viewport: u32, + viewport_count: u32, + p_viewport_swizzles: *const ViewportSwizzleNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageToColorEnableNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageToColorLocationNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_location: u32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageModulationModeNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_modulation_mode: CoverageModulationModeNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageModulationTableEnableNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_modulation_table_enable: Bool32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageModulationTableNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_modulation_table_count: u32, + p_coverage_modulation_table: *const f32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetShadingRateImageEnableNV = + unsafe extern "system" fn(command_buffer: CommandBuffer, shading_rate_image_enable: Bool32); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetRepresentativeFragmentTestEnableNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + representative_fragment_test_enable: Bool32, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdSetCoverageReductionModeNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + coverage_reduction_mode: CoverageReductionModeNV, +); #[derive(Clone)] -pub struct NvExtension456Fn {} -unsafe impl Send for NvExtension456Fn {} -unsafe impl Sync for NvExtension456Fn {} -impl NvExtension456Fn { +pub struct ExtExtendedDynamicState3Fn { + pub cmd_set_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEXT, + pub cmd_set_depth_clamp_enable_ext: PFN_vkCmdSetDepthClampEnableEXT, + pub cmd_set_polygon_mode_ext: PFN_vkCmdSetPolygonModeEXT, + pub cmd_set_rasterization_samples_ext: PFN_vkCmdSetRasterizationSamplesEXT, + pub cmd_set_sample_mask_ext: PFN_vkCmdSetSampleMaskEXT, + pub cmd_set_alpha_to_coverage_enable_ext: PFN_vkCmdSetAlphaToCoverageEnableEXT, + pub cmd_set_alpha_to_one_enable_ext: PFN_vkCmdSetAlphaToOneEnableEXT, + pub cmd_set_logic_op_enable_ext: PFN_vkCmdSetLogicOpEnableEXT, + pub cmd_set_color_blend_enable_ext: PFN_vkCmdSetColorBlendEnableEXT, + pub cmd_set_color_blend_equation_ext: PFN_vkCmdSetColorBlendEquationEXT, + pub cmd_set_color_write_mask_ext: PFN_vkCmdSetColorWriteMaskEXT, + pub cmd_set_rasterization_stream_ext: PFN_vkCmdSetRasterizationStreamEXT, + pub cmd_set_conservative_rasterization_mode_ext: PFN_vkCmdSetConservativeRasterizationModeEXT, + pub cmd_set_extra_primitive_overestimation_size_ext: + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT, + pub cmd_set_depth_clip_enable_ext: PFN_vkCmdSetDepthClipEnableEXT, + pub cmd_set_sample_locations_enable_ext: PFN_vkCmdSetSampleLocationsEnableEXT, + pub cmd_set_color_blend_advanced_ext: PFN_vkCmdSetColorBlendAdvancedEXT, + pub cmd_set_provoking_vertex_mode_ext: PFN_vkCmdSetProvokingVertexModeEXT, + pub cmd_set_line_rasterization_mode_ext: PFN_vkCmdSetLineRasterizationModeEXT, + pub cmd_set_line_stipple_enable_ext: PFN_vkCmdSetLineStippleEnableEXT, + pub cmd_set_depth_clip_negative_one_to_one_ext: PFN_vkCmdSetDepthClipNegativeOneToOneEXT, + pub cmd_set_viewport_w_scaling_enable_nv: PFN_vkCmdSetViewportWScalingEnableNV, + pub cmd_set_viewport_swizzle_nv: PFN_vkCmdSetViewportSwizzleNV, + pub cmd_set_coverage_to_color_enable_nv: PFN_vkCmdSetCoverageToColorEnableNV, + pub cmd_set_coverage_to_color_location_nv: PFN_vkCmdSetCoverageToColorLocationNV, + pub cmd_set_coverage_modulation_mode_nv: PFN_vkCmdSetCoverageModulationModeNV, + pub cmd_set_coverage_modulation_table_enable_nv: PFN_vkCmdSetCoverageModulationTableEnableNV, + pub cmd_set_coverage_modulation_table_nv: PFN_vkCmdSetCoverageModulationTableNV, + pub cmd_set_shading_rate_image_enable_nv: PFN_vkCmdSetShadingRateImageEnableNV, + pub cmd_set_representative_fragment_test_enable_nv: + PFN_vkCmdSetRepresentativeFragmentTestEnableNV, + pub cmd_set_coverage_reduction_mode_nv: PFN_vkCmdSetCoverageReductionModeNV, +} +unsafe impl Send for ExtExtendedDynamicState3Fn {} +unsafe impl Sync for ExtExtendedDynamicState3Fn {} +impl ExtExtendedDynamicState3Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + cmd_set_tessellation_domain_origin_ext: unsafe { + unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext( + _command_buffer: CommandBuffer, + _domain_origin: TessellationDomainOrigin, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_tessellation_domain_origin_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetTessellationDomainOriginEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_tessellation_domain_origin_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clamp_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clamp_enable_ext( + _command_buffer: CommandBuffer, + _depth_clamp_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clamp_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClampEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clamp_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_polygon_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_polygon_mode_ext( + _command_buffer: CommandBuffer, + _polygon_mode: PolygonMode, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_polygon_mode_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_polygon_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterization_samples_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterization_samples_ext( + _command_buffer: CommandBuffer, + _rasterization_samples: SampleCountFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterization_samples_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizationSamplesEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterization_samples_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_sample_mask_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_mask_ext( + _command_buffer: CommandBuffer, + _samples: SampleCountFlags, + _p_sample_mask: *const SampleMask, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_mask_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_mask_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_alpha_to_coverage_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext( + _command_buffer: CommandBuffer, + _alpha_to_coverage_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_alpha_to_coverage_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetAlphaToCoverageEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_alpha_to_coverage_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_alpha_to_one_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext( + _command_buffer: CommandBuffer, + _alpha_to_one_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_alpha_to_one_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetAlphaToOneEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_alpha_to_one_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_logic_op_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_logic_op_enable_ext( + _command_buffer: CommandBuffer, + _logic_op_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_logic_op_enable_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_logic_op_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_enable_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_enables: *const Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_equation_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_equation_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_equations: *const ColorBlendEquationEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_equation_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendEquationEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_equation_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_write_mask_ext: unsafe { + unsafe extern "system" fn cmd_set_color_write_mask_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_write_masks: *const ColorComponentFlags, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_write_mask_ext) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_color_write_mask_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_rasterization_stream_ext: unsafe { + unsafe extern "system" fn cmd_set_rasterization_stream_ext( + _command_buffer: CommandBuffer, + _rasterization_stream: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_rasterization_stream_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRasterizationStreamEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_rasterization_stream_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_conservative_rasterization_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext( + _command_buffer: CommandBuffer, + _conservative_rasterization_mode: ConservativeRasterizationModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_conservative_rasterization_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetConservativeRasterizationModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_conservative_rasterization_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_extra_primitive_overestimation_size_ext: unsafe { + unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext( + _command_buffer: CommandBuffer, + _extra_primitive_overestimation_size: f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_extra_primitive_overestimation_size_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_extra_primitive_overestimation_size_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clip_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clip_enable_ext( + _command_buffer: CommandBuffer, + _depth_clip_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clip_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClipEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clip_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_sample_locations_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_sample_locations_enable_ext( + _command_buffer: CommandBuffer, + _sample_locations_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_sample_locations_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetSampleLocationsEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_sample_locations_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_color_blend_advanced_ext: unsafe { + unsafe extern "system" fn cmd_set_color_blend_advanced_ext( + _command_buffer: CommandBuffer, + _first_attachment: u32, + _attachment_count: u32, + _p_color_blend_advanced: *const ColorBlendAdvancedEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_color_blend_advanced_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetColorBlendAdvancedEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_color_blend_advanced_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_provoking_vertex_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext( + _command_buffer: CommandBuffer, + _provoking_vertex_mode: ProvokingVertexModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_provoking_vertex_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetProvokingVertexModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_provoking_vertex_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_rasterization_mode_ext: unsafe { + unsafe extern "system" fn cmd_set_line_rasterization_mode_ext( + _command_buffer: CommandBuffer, + _line_rasterization_mode: LineRasterizationModeEXT, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_rasterization_mode_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetLineRasterizationModeEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_line_rasterization_mode_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_line_stipple_enable_ext: unsafe { + unsafe extern "system" fn cmd_set_line_stipple_enable_ext( + _command_buffer: CommandBuffer, + _stippled_line_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_line_stipple_enable_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetLineStippleEnableEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_line_stipple_enable_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_depth_clip_negative_one_to_one_ext: unsafe { + unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext( + _command_buffer: CommandBuffer, + _negative_one_to_one: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_depth_clip_negative_one_to_one_ext) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetDepthClipNegativeOneToOneEXT\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_depth_clip_negative_one_to_one_ext + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_w_scaling_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv( + _command_buffer: CommandBuffer, + _viewport_w_scaling_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_w_scaling_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetViewportWScalingEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_w_scaling_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_viewport_swizzle_nv: unsafe { + unsafe extern "system" fn cmd_set_viewport_swizzle_nv( + _command_buffer: CommandBuffer, + _first_viewport: u32, + _viewport_count: u32, + _p_viewport_swizzles: *const ViewportSwizzleNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_viewport_swizzle_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_set_viewport_swizzle_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_to_color_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv( + _command_buffer: CommandBuffer, + _coverage_to_color_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_to_color_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageToColorEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_to_color_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_to_color_location_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_to_color_location_nv( + _command_buffer: CommandBuffer, + _coverage_to_color_location: u32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_to_color_location_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageToColorLocationNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_to_color_location_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_mode_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_mode: CoverageModulationModeNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_mode_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationModeNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_mode_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_table_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_table_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_table_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationTableEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_table_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_modulation_table_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_modulation_table_nv( + _command_buffer: CommandBuffer, + _coverage_modulation_table_count: u32, + _p_coverage_modulation_table: *const f32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_modulation_table_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageModulationTableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_modulation_table_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_shading_rate_image_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv( + _command_buffer: CommandBuffer, + _shading_rate_image_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_shading_rate_image_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetShadingRateImageEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_shading_rate_image_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_representative_fragment_test_enable_nv: unsafe { + unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv( + _command_buffer: CommandBuffer, + _representative_fragment_test_enable: Bool32, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_representative_fragment_test_enable_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetRepresentativeFragmentTestEnableNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_representative_fragment_test_enable_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_set_coverage_reduction_mode_nv: unsafe { + unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv( + _command_buffer: CommandBuffer, + _coverage_reduction_mode: CoverageReductionModeNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_set_coverage_reduction_mode_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCmdSetCoverageReductionModeNV\0", + ); + let val = _f(cname); + if val.is_null() { + cmd_set_coverage_reduction_mode_nv + } else { + ::std::mem::transmute(val) + } + }, + } } } +#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"] +impl DynamicState { + pub const TESSELLATION_DOMAIN_ORIGIN_EXT: Self = Self(1_000_455_002); + pub const DEPTH_CLAMP_ENABLE_EXT: Self = Self(1_000_455_003); + pub const POLYGON_MODE_EXT: Self = Self(1_000_455_004); + pub const RASTERIZATION_SAMPLES_EXT: Self = Self(1_000_455_005); + pub const SAMPLE_MASK_EXT: Self = Self(1_000_455_006); + pub const ALPHA_TO_COVERAGE_ENABLE_EXT: Self = Self(1_000_455_007); + pub const ALPHA_TO_ONE_ENABLE_EXT: Self = Self(1_000_455_008); + pub const LOGIC_OP_ENABLE_EXT: Self = Self(1_000_455_009); + pub const COLOR_BLEND_ENABLE_EXT: Self = Self(1_000_455_010); + pub const COLOR_BLEND_EQUATION_EXT: Self = Self(1_000_455_011); + pub const COLOR_WRITE_MASK_EXT: Self = Self(1_000_455_012); + pub const RASTERIZATION_STREAM_EXT: Self = Self(1_000_455_013); + pub const CONSERVATIVE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_014); + pub const EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: Self = Self(1_000_455_015); + pub const DEPTH_CLIP_ENABLE_EXT: Self = Self(1_000_455_016); + pub const SAMPLE_LOCATIONS_ENABLE_EXT: Self = Self(1_000_455_017); + pub const COLOR_BLEND_ADVANCED_EXT: Self = Self(1_000_455_018); + pub const PROVOKING_VERTEX_MODE_EXT: Self = Self(1_000_455_019); + pub const LINE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_020); + pub const LINE_STIPPLE_ENABLE_EXT: Self = Self(1_000_455_021); + pub const DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: Self = Self(1_000_455_022); + pub const VIEWPORT_W_SCALING_ENABLE_NV: Self = Self(1_000_455_023); + pub const VIEWPORT_SWIZZLE_NV: Self = Self(1_000_455_024); + pub const COVERAGE_TO_COLOR_ENABLE_NV: Self = Self(1_000_455_025); + pub const COVERAGE_TO_COLOR_LOCATION_NV: Self = Self(1_000_455_026); + pub const COVERAGE_MODULATION_MODE_NV: Self = Self(1_000_455_027); + pub const COVERAGE_MODULATION_TABLE_ENABLE_NV: Self = Self(1_000_455_028); + pub const COVERAGE_MODULATION_TABLE_NV: Self = Self(1_000_455_029); + pub const SHADING_RATE_IMAGE_ENABLE_NV: Self = Self(1_000_455_030); + pub const REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: Self = Self(1_000_455_031); + pub const COVERAGE_REDUCTION_MODE_NV: Self = Self(1_000_455_032); +} +#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: Self = Self(1_000_455_000); + pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: Self = Self(1_000_455_001); +} impl ExtExtension457Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -22336,44 +24135,216 @@ impl SubpassDescriptionFlags { pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT: Self = Self(0b10_0000); pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT: Self = Self(0b100_0000); } -impl NvExtension465Fn { +impl NvOpticalFlowFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_465\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_optical_flow\0") } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } +#[allow(non_camel_case_types)] +pub type PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = unsafe extern "system" fn( + physical_device: PhysicalDevice, + p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV, + p_format_count: *mut u32, + p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateOpticalFlowSessionNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const OpticalFlowSessionCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_session: *mut OpticalFlowSessionNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyOpticalFlowSessionNV = unsafe extern "system" fn( + device: Device, + session: OpticalFlowSessionNV, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkBindOpticalFlowSessionImageNV = unsafe extern "system" fn( + device: Device, + session: OpticalFlowSessionNV, + binding_point: OpticalFlowSessionBindingPointNV, + view: ImageView, + layout: ImageLayout, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCmdOpticalFlowExecuteNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + session: OpticalFlowSessionNV, + p_execute_info: *const OpticalFlowExecuteInfoNV, +); #[derive(Clone)] -pub struct NvExtension465Fn {} -unsafe impl Send for NvExtension465Fn {} -unsafe impl Sync for NvExtension465Fn {} -impl NvExtension465Fn { +pub struct NvOpticalFlowFn { + pub get_physical_device_optical_flow_image_formats_nv: + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV, + pub create_optical_flow_session_nv: PFN_vkCreateOpticalFlowSessionNV, + pub destroy_optical_flow_session_nv: PFN_vkDestroyOpticalFlowSessionNV, + pub bind_optical_flow_session_image_nv: PFN_vkBindOpticalFlowSessionImageNV, + pub cmd_optical_flow_execute_nv: PFN_vkCmdOpticalFlowExecuteNV, +} +unsafe impl Send for NvOpticalFlowFn {} +unsafe impl Sync for NvOpticalFlowFn {} +impl NvOpticalFlowFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { - Self {} + Self { + get_physical_device_optical_flow_image_formats_nv: unsafe { + unsafe extern "system" fn get_physical_device_optical_flow_image_formats_nv( + _physical_device: PhysicalDevice, + _p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV, + _p_format_count: *mut u32, + _p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_physical_device_optical_flow_image_formats_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkGetPhysicalDeviceOpticalFlowImageFormatsNV\0", + ); + let val = _f(cname); + if val.is_null() { + get_physical_device_optical_flow_image_formats_nv + } else { + ::std::mem::transmute(val) + } + }, + create_optical_flow_session_nv: unsafe { + unsafe extern "system" fn create_optical_flow_session_nv( + _device: Device, + _p_create_info: *const OpticalFlowSessionCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_session: *mut OpticalFlowSessionNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_optical_flow_session_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkCreateOpticalFlowSessionNV\0", + ); + let val = _f(cname); + if val.is_null() { + create_optical_flow_session_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_optical_flow_session_nv: unsafe { + unsafe extern "system" fn destroy_optical_flow_session_nv( + _device: Device, + _session: OpticalFlowSessionNV, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_optical_flow_session_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkDestroyOpticalFlowSessionNV\0", + ); + let val = _f(cname); + if val.is_null() { + destroy_optical_flow_session_nv + } else { + ::std::mem::transmute(val) + } + }, + bind_optical_flow_session_image_nv: unsafe { + unsafe extern "system" fn bind_optical_flow_session_image_nv( + _device: Device, + _session: OpticalFlowSessionNV, + _binding_point: OpticalFlowSessionBindingPointNV, + _view: ImageView, + _layout: ImageLayout, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(bind_optical_flow_session_image_nv) + )) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"vkBindOpticalFlowSessionImageNV\0", + ); + let val = _f(cname); + if val.is_null() { + bind_optical_flow_session_image_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_optical_flow_execute_nv: unsafe { + unsafe extern "system" fn cmd_optical_flow_execute_nv( + _command_buffer: CommandBuffer, + _session: OpticalFlowSessionNV, + _p_execute_info: *const OpticalFlowExecuteInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_optical_flow_execute_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdOpticalFlowExecuteNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_optical_flow_execute_nv + } else { + ::std::mem::transmute(val) + } + }, + } } } -#[doc = "Generated from 'VK_NV_extension_465'"] +#[doc = "Generated from 'VK_NV_optical_flow'"] impl AccessFlags2 { - pub const RESERVED_42_NV: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); - pub const RESERVED_43_NV: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_READ_NV: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_WRITE_NV: Self = + Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_NV_extension_465'"] +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl Format { + pub const R16G16_S10_5_NV: Self = Self(1_000_464_000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] impl FormatFeatureFlags2 { - pub const RESERVED_40_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); - pub const RESERVED_41_NV: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); - pub const RESERVED_42_NV: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); - pub const RESERVED_43_NV: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_IMAGE_NV: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_VECTOR_NV: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_COST_NV: Self = + Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_NV_extension_465'"] +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl ObjectType { + pub const OPTICAL_FLOW_SESSION_NV: Self = Self(1_000_464_000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] impl PipelineStageFlags2 { - pub const RESERVED_29_NV: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); + pub const OPTICAL_FLOW_NV: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000); } -#[doc = "Generated from 'VK_NV_extension_465'"] +#[doc = "Generated from 'VK_NV_optical_flow'"] impl QueueFlags { - pub const RESERVED_8_NV: Self = Self(0b1_0000_0000); + pub const OPTICAL_FLOW_NV: Self = Self(0b1_0000_0000); +} +#[doc = "Generated from 'VK_NV_optical_flow'"] +impl StructureType { + pub const PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: Self = Self(1_000_464_000); + pub const PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: Self = Self(1_000_464_001); + pub const OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: Self = Self(1_000_464_002); + pub const OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: Self = Self(1_000_464_003); + pub const OPTICAL_FLOW_SESSION_CREATE_INFO_NV: Self = Self(1_000_464_004); + pub const OPTICAL_FLOW_EXECUTE_INFO_NV: Self = Self(1_000_464_005); + pub const OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: Self = Self(1_000_464_010); } impl ExtLegacyDitheringFn { #[inline] @@ -22406,18 +24377,20 @@ impl StructureType { impl SubpassDescriptionFlags { pub const ENABLE_LEGACY_DITHERING_EXT: Self = Self(0b1000_0000); } -impl ExtExtension467Fn { +impl ExtPipelineProtectedAccessFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_467\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_protected_access\0") + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct ExtExtension467Fn {} -unsafe impl Send for ExtExtension467Fn {} -unsafe impl Sync for ExtExtension467Fn {} -impl ExtExtension467Fn { +pub struct ExtPipelineProtectedAccessFn {} +unsafe impl Send for ExtPipelineProtectedAccessFn {} +unsafe impl Sync for ExtPipelineProtectedAccessFn {} +impl ExtPipelineProtectedAccessFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -22425,10 +24398,14 @@ impl ExtExtension467Fn { Self {} } } -#[doc = "Generated from 'VK_EXT_extension_467'"] +#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"] impl PipelineCreateFlags { - pub const RESERVED_27_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); - pub const RESERVED_30_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); + pub const NO_PROTECTED_ACCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); + pub const PROTECTED_ACCESS_ONLY_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"] +impl StructureType { + pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: Self = Self(1_000_466_000); } impl ExtExtension468Fn { #[inline] @@ -22943,18 +24920,22 @@ impl NvExtension490Fn { Self {} } } -impl NvExtension491Fn { +impl NvRayTracingInvocationReorderFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_491\0") } + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_NV_ray_tracing_invocation_reorder\0", + ) + } } - pub const SPEC_VERSION: u32 = 0u32; + pub const SPEC_VERSION: u32 = 1u32; } #[derive(Clone)] -pub struct NvExtension491Fn {} -unsafe impl Send for NvExtension491Fn {} -unsafe impl Sync for NvExtension491Fn {} -impl NvExtension491Fn { +pub struct NvRayTracingInvocationReorderFn {} +unsafe impl Send for NvRayTracingInvocationReorderFn {} +unsafe impl Sync for NvRayTracingInvocationReorderFn {} +impl NvRayTracingInvocationReorderFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -22962,6 +24943,13 @@ impl NvExtension491Fn { Self {} } } +#[doc = "Generated from 'VK_NV_ray_tracing_invocation_reorder'"] +impl StructureType { + pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: Self = + Self(1_000_490_000); + pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: Self = + Self(1_000_490_001); +} impl NvExtension492Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { @@ -23057,3 +25045,179 @@ impl StructureType { pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: Self = Self(1_000_351_000); pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: Self = Self(1_000_351_002); } +impl ExtExtension496Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_496\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension496Fn {} +unsafe impl Send for ExtExtension496Fn {} +unsafe impl Sync for ExtExtension496Fn {} +impl ExtExtension496Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension497Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_497\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension497Fn {} +unsafe impl Send for ExtExtension497Fn {} +unsafe impl Sync for ExtExtension497Fn {} +impl ExtExtension497Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ArmShaderCoreBuiltinsFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_shader_core_builtins\0") } + } + pub const SPEC_VERSION: u32 = 2u32; +} +#[derive(Clone)] +pub struct ArmShaderCoreBuiltinsFn {} +unsafe impl Send for ArmShaderCoreBuiltinsFn {} +unsafe impl Sync for ArmShaderCoreBuiltinsFn {} +impl ArmShaderCoreBuiltinsFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_ARM_shader_core_builtins'"] +impl StructureType { + pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: Self = Self(1_000_497_000); + pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: Self = Self(1_000_497_001); +} +impl ExtExtension499Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_499\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension499Fn {} +unsafe impl Send for ExtExtension499Fn {} +unsafe impl Sync for ExtExtension499Fn {} +impl ExtExtension499Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension500Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_500\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension500Fn {} +unsafe impl Send for ExtExtension500Fn {} +unsafe impl Sync for ExtExtension500Fn {} +impl ExtExtension500Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension501Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_501\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension501Fn {} +unsafe impl Send for ExtExtension501Fn {} +unsafe impl Sync for ExtExtension501Fn {} +impl ExtExtension501Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension502Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_502\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension502Fn {} +unsafe impl Send for ExtExtension502Fn {} +unsafe impl Sync for ExtExtension502Fn {} +impl ExtExtension502Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtExtension503Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_503\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct ExtExtension503Fn {} +unsafe impl Send for ExtExtension503Fn {} +unsafe impl Sync for ExtExtension503Fn {} +impl ExtExtension503Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl NvExtension504Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_504\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct NvExtension504Fn {} +unsafe impl Send for NvExtension504Fn {} +unsafe impl Sync for NvExtension504Fn {} +impl NvExtension504Fn { + 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 09b7fb7..02edfba 100644 --- a/ash/src/vk/native.rs +++ b/ash/src/vk/native.rs @@ -99,27 +99,27 @@ pub const StdVideoH264ProfileIdc_STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE: 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 type StdVideoH264Level = ::std::os::raw::c_uint; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_0: StdVideoH264LevelIdc = 0; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_1: StdVideoH264LevelIdc = 1; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_2: StdVideoH264LevelIdc = 2; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_1_3: StdVideoH264LevelIdc = 3; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_0: StdVideoH264LevelIdc = 4; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_1: StdVideoH264LevelIdc = 5; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_2_2: StdVideoH264LevelIdc = 6; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_0: StdVideoH264LevelIdc = 7; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_1: StdVideoH264LevelIdc = 8; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_3_2: StdVideoH264LevelIdc = 9; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_0: StdVideoH264LevelIdc = 10; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_1: StdVideoH264LevelIdc = 11; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_4_2: StdVideoH264LevelIdc = 12; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_0: StdVideoH264LevelIdc = 13; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_1: StdVideoH264LevelIdc = 14; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_5_2: StdVideoH264LevelIdc = 15; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_0: StdVideoH264LevelIdc = 16; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_1: StdVideoH264LevelIdc = 17; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_6_2: StdVideoH264LevelIdc = 18; +pub const StdVideoH264LevelIdc_STD_VIDEO_H264_LEVEL_IDC_INVALID: StdVideoH264LevelIdc = 2147483647; +pub type StdVideoH264LevelIdc = ::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; @@ -458,6 +458,7 @@ pub struct StdVideoH264HrdParameters { pub cpb_cnt_minus1: u8, pub bit_rate_scale: u8, pub cpb_size_scale: u8, + pub reserved1: u8, pub bit_rate_value_minus1: [u32; 32usize], pub cpb_size_value_minus1: [u32; 32usize], pub cbr_flag: [u8; 32usize], @@ -511,6 +512,16 @@ fn bindgen_test_layout_StdVideoH264HrdParameters() { stringify!(cpb_size_scale) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 3usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264HrdParameters), + "::", + stringify!(reserved1) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bit_rate_value_minus1) as usize - ptr as usize }, 4usize, @@ -597,14 +608,17 @@ pub struct StdVideoH264SequenceParameterSetVui { pub sar_width: u16, pub sar_height: u16, pub video_format: u8, - pub color_primaries: u8, + pub colour_primaries: u8, pub transfer_characteristics: u8, pub matrix_coefficients: u8, pub num_units_in_tick: u32, pub time_scale: u32, - pub pHrdParameters: *const StdVideoH264HrdParameters, pub max_num_reorder_frames: u8, pub max_dec_frame_buffering: u8, + pub chroma_sample_loc_type_top_field: u8, + pub chroma_sample_loc_type_bottom_field: u8, + pub reserved1: u32, + pub pHrdParameters: *const StdVideoH264HrdParameters, } #[test] fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { @@ -675,13 +689,13 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).color_primaries) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize }, 13usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), "::", - stringify!(color_primaries) + stringify!(colour_primaries) ) ); assert_eq!( @@ -724,19 +738,9 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { stringify!(time_scale) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, - 24usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH264SequenceParameterSetVui), - "::", - stringify!(pHrdParameters) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_frames) as usize - ptr as usize }, - 32usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -746,7 +750,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_dec_frame_buffering) as usize - ptr as usize }, - 33usize, + 25usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), @@ -754,6 +758,50 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { stringify!(max_dec_frame_buffering) ) ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize + }, + 26usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_top_field) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize + }, + 27usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(chroma_sample_loc_type_bottom_field) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 28usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSetVui), + "::", + stringify!(pHrdParameters) + ) + ); } #[repr(C)] #[repr(align(4))] @@ -1051,10 +1099,10 @@ impl StdVideoH264SpsFlags { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH264ScalingLists { - pub scaling_list_present_mask: u8, - pub use_default_scaling_matrix_mask: u8, + pub scaling_list_present_mask: u16, + pub use_default_scaling_matrix_mask: u16, pub ScalingList4x4: [[u8; 16usize]; 6usize], - pub ScalingList8x8: [[u8; 64usize]; 2usize], + pub ScalingList8x8: [[u8; 64usize]; 6usize], } #[test] fn bindgen_test_layout_StdVideoH264ScalingLists() { @@ -1063,12 +1111,12 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 226usize, + 484usize, concat!("Size of: ", stringify!(StdVideoH264ScalingLists)) ); assert_eq!( ::std::mem::align_of::(), - 1usize, + 2usize, concat!("Alignment of ", stringify!(StdVideoH264ScalingLists)) ); assert_eq!( @@ -1085,7 +1133,7 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() { unsafe { ::std::ptr::addr_of!((*ptr).use_default_scaling_matrix_mask) as usize - ptr as usize }, - 1usize, + 2usize, concat!( "Offset of field: ", stringify!(StdVideoH264ScalingLists), @@ -1095,7 +1143,7 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ScalingList4x4) as usize - ptr as usize }, - 2usize, + 4usize, concat!( "Offset of field: ", stringify!(StdVideoH264ScalingLists), @@ -1105,7 +1153,7 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).ScalingList8x8) as usize - ptr as usize }, - 98usize, + 100usize, concat!( "Offset of field: ", stringify!(StdVideoH264ScalingLists), @@ -1119,24 +1167,26 @@ fn bindgen_test_layout_StdVideoH264ScalingLists() { pub struct StdVideoH264SequenceParameterSet { pub flags: StdVideoH264SpsFlags, pub profile_idc: StdVideoH264ProfileIdc, - pub level_idc: StdVideoH264Level, - pub seq_parameter_set_id: u8, + pub level_idc: StdVideoH264LevelIdc, pub chroma_format_idc: StdVideoH264ChromaFormatIdc, + pub seq_parameter_set_id: u8, pub bit_depth_luma_minus8: u8, pub bit_depth_chroma_minus8: u8, pub log2_max_frame_num_minus4: u8, pub pic_order_cnt_type: StdVideoH264PocType, - pub log2_max_pic_order_cnt_lsb_minus4: u8, pub offset_for_non_ref_pic: i32, pub offset_for_top_to_bottom_field: i32, + pub log2_max_pic_order_cnt_lsb_minus4: u8, pub num_ref_frames_in_pic_order_cnt_cycle: u8, pub max_num_ref_frames: u8, + pub reserved1: u8, pub pic_width_in_mbs_minus1: u32, pub pic_height_in_map_units_minus1: u32, pub frame_crop_left_offset: u32, pub frame_crop_right_offset: u32, pub frame_crop_top_offset: u32, pub frame_crop_bottom_offset: u32, + pub reserved2: u32, pub pOffsetForRefFrame: *const i32, pub pScalingLists: *const StdVideoH264ScalingLists, pub pSequenceParameterSetVui: *const StdVideoH264SequenceParameterSetVui, @@ -1148,7 +1198,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 96usize, + 88usize, concat!("Size of: ", stringify!(StdVideoH264SequenceParameterSet)) ); assert_eq!( @@ -1189,19 +1239,9 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { stringify!(level_idc) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH264SequenceParameterSet), - "::", - stringify!(seq_parameter_set_id) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, - 16usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1209,9 +1249,19 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { stringify!(chroma_format_idc) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(seq_parameter_set_id) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize }, - 20usize, + 17usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1221,7 +1271,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize }, - 21usize, + 18usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1231,7 +1281,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).log2_max_frame_num_minus4) as usize - ptr as usize }, - 22usize, + 19usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1241,7 +1291,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pic_order_cnt_type) as usize - ptr as usize }, - 24usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1249,21 +1299,9 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { stringify!(pic_order_cnt_type) ) ); - assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize - }, - 28usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH264SequenceParameterSet), - "::", - stringify!(log2_max_pic_order_cnt_lsb_minus4) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).offset_for_non_ref_pic) as usize - ptr as usize }, - 32usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1275,7 +1313,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).offset_for_top_to_bottom_field) as usize - ptr as usize }, - 36usize, + 28usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1283,12 +1321,24 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { stringify!(offset_for_top_to_bottom_field) ) ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize + }, + 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(log2_max_pic_order_cnt_lsb_minus4) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).num_ref_frames_in_pic_order_cnt_cycle) as usize - ptr as usize }, - 40usize, + 33usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1298,7 +1348,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_num_ref_frames) as usize - ptr as usize }, - 41usize, + 34usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1306,9 +1356,19 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { stringify!(max_num_ref_frames) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(reserved1) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_mbs_minus1) as usize - ptr as usize }, - 44usize, + 36usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1320,7 +1380,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).pic_height_in_map_units_minus1) as usize - ptr as usize }, - 48usize, + 40usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1330,7 +1390,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_left_offset) as usize - ptr as usize }, - 52usize, + 44usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1340,7 +1400,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_right_offset) as usize - ptr as usize }, - 56usize, + 48usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1350,7 +1410,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_top_offset) as usize - ptr as usize }, - 60usize, + 52usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1360,7 +1420,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).frame_crop_bottom_offset) as usize - ptr as usize }, - 64usize, + 56usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1368,9 +1428,19 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { stringify!(frame_crop_bottom_offset) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 60usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH264SequenceParameterSet), + "::", + stringify!(reserved2) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pOffsetForRefFrame) as usize - ptr as usize }, - 72usize, + 64usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1380,7 +1450,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, - 80usize, + 72usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1390,7 +1460,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize }, - 88usize, + 80usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), @@ -1404,8 +1474,8 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { #[derive(Debug, Copy, Clone)] pub struct StdVideoH264PpsFlags { pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>, - pub __bindgen_padding_0: u16, + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], } #[test] fn bindgen_test_layout_StdVideoH264PpsFlags() { @@ -1466,58 +1536,47 @@ impl StdVideoH264PpsFlags { } } #[inline] - pub fn weighted_bipred_idc_flag(&self) -> u32 { + pub fn weighted_pred_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } } #[inline] - pub fn set_weighted_bipred_idc_flag(&mut self, val: u32) { + pub fn set_weighted_pred_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 weighted_pred_flag(&self) -> u32 { + pub fn bottom_field_pic_order_in_frame_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] - pub fn set_weighted_pred_flag(&mut self, val: u32) { + pub fn set_bottom_field_pic_order_in_frame_present_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 pic_order_present_flag(&self) -> u32 { + pub fn entropy_coding_mode_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] - pub fn set_pic_order_present_flag(&mut self, val: u32) { + pub fn set_entropy_coding_mode_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 entropy_coding_mode_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } - } - #[inline] - pub fn set_entropy_coding_mode_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 pic_scaling_matrix_present_flag(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } + unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] 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) + self._bitfield_1.set(7usize, 1u8, val as u64) } } #[inline] @@ -1526,13 +1585,12 @@ impl StdVideoH264PpsFlags { redundant_pic_cnt_present_flag: u32, constrained_intra_pred_flag: u32, deblocking_filter_control_present_flag: u32, - weighted_bipred_idc_flag: u32, weighted_pred_flag: u32, - pic_order_present_flag: u32, + bottom_field_pic_order_in_frame_present_flag: u32, entropy_coding_mode_flag: u32, pic_scaling_matrix_present_flag: u32, - ) -> __BindgenBitfieldUnit<[u8; 2usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default(); + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { let transform_8x8_mode_flag: u32 = unsafe { ::std::mem::transmute(transform_8x8_mode_flag) }; @@ -1554,25 +1612,20 @@ impl StdVideoH264PpsFlags { deblocking_filter_control_present_flag as u64 }); __bindgen_bitfield_unit.set(4usize, 1u8, { - let weighted_bipred_idc_flag: u32 = - unsafe { ::std::mem::transmute(weighted_bipred_idc_flag) }; - weighted_bipred_idc_flag as u64 - }); - __bindgen_bitfield_unit.set(5usize, 1u8, { let weighted_pred_flag: u32 = unsafe { ::std::mem::transmute(weighted_pred_flag) }; weighted_pred_flag as u64 }); - __bindgen_bitfield_unit.set(6usize, 1u8, { - let pic_order_present_flag: u32 = - unsafe { ::std::mem::transmute(pic_order_present_flag) }; - pic_order_present_flag as u64 + __bindgen_bitfield_unit.set(5usize, 1u8, { + let bottom_field_pic_order_in_frame_present_flag: u32 = + unsafe { ::std::mem::transmute(bottom_field_pic_order_in_frame_present_flag) }; + bottom_field_pic_order_in_frame_present_flag as u64 }); - __bindgen_bitfield_unit.set(7usize, 1u8, { + __bindgen_bitfield_unit.set(6usize, 1u8, { let entropy_coding_mode_flag: u32 = unsafe { ::std::mem::transmute(entropy_coding_mode_flag) }; entropy_coding_mode_flag as u64 }); - __bindgen_bitfield_unit.set(8usize, 1u8, { + __bindgen_bitfield_unit.set(7usize, 1u8, { let pic_scaling_matrix_present_flag: u32 = unsafe { ::std::mem::transmute(pic_scaling_matrix_present_flag) }; pic_scaling_matrix_present_flag as u64 @@ -1864,7 +1917,8 @@ pub struct StdVideoDecodeH264PictureInfo { pub flags: StdVideoDecodeH264PictureInfoFlags, pub seq_parameter_set_id: u8, pub pic_parameter_set_id: u8, - pub reserved: u16, + pub reserved1: u8, + pub reserved2: u8, pub frame_num: u16, pub idr_pic_id: u16, pub PicOrderCnt: [i32; 2usize], @@ -1915,13 +1969,23 @@ fn bindgen_test_layout_StdVideoDecodeH264PictureInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, 6usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH264PictureInfo), "::", - stringify!(reserved) + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoDecodeH264PictureInfo), + "::", + stringify!(reserved2) ) ); assert_eq!( @@ -2119,302 +2183,17 @@ fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() { ) ); } -#[repr(C)] -#[repr(align(4))] -#[derive(Debug, Copy, Clone)] -pub struct StdVideoDecodeH264MvcElementFlags { - pub _bitfield_align_1: [u8; 0], - pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, - pub __bindgen_padding_0: [u8; 3usize], -} -#[test] -fn bindgen_test_layout_StdVideoDecodeH264MvcElementFlags() { - assert_eq!( - ::std::mem::size_of::(), - 4usize, - concat!("Size of: ", stringify!(StdVideoDecodeH264MvcElementFlags)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!( - "Alignment of ", - stringify!(StdVideoDecodeH264MvcElementFlags) - ) - ); -} -impl StdVideoDecodeH264MvcElementFlags { - #[inline] - pub fn non_idr(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } - } - #[inline] - pub fn set_non_idr(&mut self, val: u32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(0usize, 1u8, val as u64) - } - } - #[inline] - pub fn anchor_pic(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } - } - #[inline] - pub fn set_anchor_pic(&mut self, val: u32) { - unsafe { - let val: u32 = ::std::mem::transmute(val); - self._bitfield_1.set(1usize, 1u8, val as u64) - } - } - #[inline] - pub fn inter_view(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_inter_view(&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( - non_idr: u32, - anchor_pic: u32, - inter_view: u32, - ) -> __BindgenBitfieldUnit<[u8; 1usize]> { - let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); - __bindgen_bitfield_unit.set(0usize, 1u8, { - let non_idr: u32 = unsafe { ::std::mem::transmute(non_idr) }; - non_idr as u64 - }); - __bindgen_bitfield_unit.set(1usize, 1u8, { - let anchor_pic: u32 = unsafe { ::std::mem::transmute(anchor_pic) }; - anchor_pic as u64 - }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let inter_view: u32 = unsafe { ::std::mem::transmute(inter_view) }; - inter_view as u64 - }); - __bindgen_bitfield_unit - } -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct StdVideoDecodeH264MvcElement { - pub flags: StdVideoDecodeH264MvcElementFlags, - pub viewOrderIndex: u16, - pub viewId: u16, - pub temporalId: u16, - pub priorityId: u16, - pub numOfAnchorRefsInL0: u16, - pub viewIdOfAnchorRefsInL0: [u16; 15usize], - pub numOfAnchorRefsInL1: u16, - pub viewIdOfAnchorRefsInL1: [u16; 15usize], - pub numOfNonAnchorRefsInL0: u16, - pub viewIdOfNonAnchorRefsInL0: [u16; 15usize], - pub numOfNonAnchorRefsInL1: u16, - pub viewIdOfNonAnchorRefsInL1: [u16; 15usize], -} -#[test] -fn bindgen_test_layout_StdVideoDecodeH264MvcElement() { - const UNINIT: ::std::mem::MaybeUninit = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::(), - 140usize, - concat!("Size of: ", stringify!(StdVideoDecodeH264MvcElement)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(StdVideoDecodeH264MvcElement)) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(flags) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).viewOrderIndex) as usize - ptr as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(viewOrderIndex) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).viewId) as usize - ptr as usize }, - 6usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(viewId) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).temporalId) as usize - ptr as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(temporalId) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).priorityId) as usize - ptr as usize }, - 10usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(priorityId) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).numOfAnchorRefsInL0) as usize - ptr as usize }, - 12usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(numOfAnchorRefsInL0) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).viewIdOfAnchorRefsInL0) as usize - ptr as usize }, - 14usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(viewIdOfAnchorRefsInL0) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).numOfAnchorRefsInL1) as usize - ptr as usize }, - 44usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(numOfAnchorRefsInL1) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).viewIdOfAnchorRefsInL1) as usize - ptr as usize }, - 46usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(viewIdOfAnchorRefsInL1) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).numOfNonAnchorRefsInL0) as usize - ptr as usize }, - 76usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(numOfNonAnchorRefsInL0) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).viewIdOfNonAnchorRefsInL0) as usize - ptr as usize }, - 78usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(viewIdOfNonAnchorRefsInL0) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).numOfNonAnchorRefsInL1) as usize - ptr as usize }, - 108usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(numOfNonAnchorRefsInL1) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).viewIdOfNonAnchorRefsInL1) as usize - ptr as usize }, - 110usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264MvcElement), - "::", - stringify!(viewIdOfNonAnchorRefsInL1) - ) - ); -} -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct StdVideoDecodeH264Mvc { - pub viewId0: u32, - pub mvcElementCount: u32, - pub pMvcElements: *const StdVideoDecodeH264MvcElement, -} -#[test] -fn bindgen_test_layout_StdVideoDecodeH264Mvc() { - const UNINIT: ::std::mem::MaybeUninit = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::(), - 16usize, - concat!("Size of: ", stringify!(StdVideoDecodeH264Mvc)) - ); - assert_eq!( - ::std::mem::align_of::(), - 8usize, - concat!("Alignment of ", stringify!(StdVideoDecodeH264Mvc)) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).viewId0) as usize - ptr as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264Mvc), - "::", - stringify!(viewId0) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).mvcElementCount) as usize - ptr as usize }, - 4usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264Mvc), - "::", - stringify!(mvcElementCount) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pMvcElements) as usize - ptr as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(StdVideoDecodeH264Mvc), - "::", - stringify!(pMvcElements) - ) - ); -} +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME: + StdVideoH265ChromaFormatIdc = 0; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_420: + StdVideoH265ChromaFormatIdc = 1; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_422: + StdVideoH265ChromaFormatIdc = 2; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_444: + StdVideoH265ChromaFormatIdc = 3; +pub const StdVideoH265ChromaFormatIdc_STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID: + StdVideoH265ChromaFormatIdc = 2147483647; +pub type StdVideoH265ChromaFormatIdc = ::std::os::raw::c_uint; 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: @@ -2426,21 +2205,21 @@ pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: StdV 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 type StdVideoH265Level = ::std::os::raw::c_uint; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_1_0: StdVideoH265LevelIdc = 0; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_0: StdVideoH265LevelIdc = 1; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_2_1: StdVideoH265LevelIdc = 2; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_0: StdVideoH265LevelIdc = 3; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_3_1: StdVideoH265LevelIdc = 4; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_0: StdVideoH265LevelIdc = 5; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_4_1: StdVideoH265LevelIdc = 6; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_0: StdVideoH265LevelIdc = 7; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_1: StdVideoH265LevelIdc = 8; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_5_2: StdVideoH265LevelIdc = 9; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_0: StdVideoH265LevelIdc = 10; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_1: StdVideoH265LevelIdc = 11; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_6_2: StdVideoH265LevelIdc = 12; +pub const StdVideoH265LevelIdc_STD_VIDEO_H265_LEVEL_IDC_INVALID: StdVideoH265LevelIdc = 2147483647; +pub type StdVideoH265LevelIdc = ::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; @@ -2454,6 +2233,45 @@ pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_IDR: StdVideoH265P pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_INVALID: StdVideoH265PictureType = 2147483647; pub type StdVideoH265PictureType = ::std::os::raw::c_uint; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED: + StdVideoH265AspectRatioIdc = 0; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE: + StdVideoH265AspectRatioIdc = 1; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11: + StdVideoH265AspectRatioIdc = 2; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11: + StdVideoH265AspectRatioIdc = 3; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11: + StdVideoH265AspectRatioIdc = 4; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33: + StdVideoH265AspectRatioIdc = 5; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11: + StdVideoH265AspectRatioIdc = 6; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11: + StdVideoH265AspectRatioIdc = 7; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11: + StdVideoH265AspectRatioIdc = 8; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33: + StdVideoH265AspectRatioIdc = 9; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11: + StdVideoH265AspectRatioIdc = 10; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11: + StdVideoH265AspectRatioIdc = 11; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33: + StdVideoH265AspectRatioIdc = 12; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99: + StdVideoH265AspectRatioIdc = 13; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3: + StdVideoH265AspectRatioIdc = 14; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2: + StdVideoH265AspectRatioIdc = 15; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1: + StdVideoH265AspectRatioIdc = 16; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR: + StdVideoH265AspectRatioIdc = 255; +pub const StdVideoH265AspectRatioIdc_STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID: + StdVideoH265AspectRatioIdc = 2147483647; +pub type StdVideoH265AspectRatioIdc = ::std::os::raw::c_uint; #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH265DecPicBufMgr { @@ -2748,8 +2566,9 @@ 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 pSubLayerHrdParametersNal: [*const StdVideoH265SubLayerHrdParameters; 7usize], - pub pSubLayerHrdParametersVcl: [*const StdVideoH265SubLayerHrdParameters; 7usize], + pub reserved: [u16; 3usize], + pub pSubLayerHrdParametersNal: *const StdVideoH265SubLayerHrdParameters, + pub pSubLayerHrdParametersVcl: *const StdVideoH265SubLayerHrdParameters, } #[test] fn bindgen_test_layout_StdVideoH265HrdParameters() { @@ -2758,7 +2577,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 152usize, + 56usize, concat!("Size of: ", stringify!(StdVideoH265HrdParameters)) ); assert_eq!( @@ -2900,6 +2719,16 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { stringify!(elemental_duration_in_tc_minus1) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265HrdParameters), + "::", + stringify!(reserved) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersNal) as usize - ptr as usize }, 40usize, @@ -2912,7 +2741,7 @@ fn bindgen_test_layout_StdVideoH265HrdParameters() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pSubLayerHrdParametersVcl) as usize - ptr as usize }, - 96usize, + 48usize, concat!( "Offset of field: ", stringify!(StdVideoH265HrdParameters), @@ -3019,16 +2848,189 @@ impl StdVideoH265VpsFlags { } } #[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ProfileTierLevelFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ProfileTierLevelFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevelFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265ProfileTierLevelFlags) + ) + ); +} +impl StdVideoH265ProfileTierLevelFlags { + #[inline] + pub fn general_tier_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_tier_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 general_progressive_source_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_progressive_source_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 general_interlaced_source_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_interlaced_source_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 general_non_packed_constraint_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_non_packed_constraint_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 general_frame_only_constraint_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } + } + #[inline] + pub fn set_general_frame_only_constraint_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 new_bitfield_1( + general_tier_flag: u32, + general_progressive_source_flag: u32, + general_interlaced_source_flag: u32, + general_non_packed_constraint_flag: u32, + general_frame_only_constraint_flag: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let general_tier_flag: u32 = unsafe { ::std::mem::transmute(general_tier_flag) }; + general_tier_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let general_progressive_source_flag: u32 = + unsafe { ::std::mem::transmute(general_progressive_source_flag) }; + general_progressive_source_flag as u64 + }); + __bindgen_bitfield_unit.set(2usize, 1u8, { + let general_interlaced_source_flag: u32 = + unsafe { ::std::mem::transmute(general_interlaced_source_flag) }; + general_interlaced_source_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let general_non_packed_constraint_flag: u32 = + unsafe { ::std::mem::transmute(general_non_packed_constraint_flag) }; + general_non_packed_constraint_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { + let general_frame_only_constraint_flag: u32 = + unsafe { ::std::mem::transmute(general_frame_only_constraint_flag) }; + general_frame_only_constraint_flag as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ProfileTierLevel { + pub flags: StdVideoH265ProfileTierLevelFlags, + pub general_profile_idc: StdVideoH265ProfileIdc, + pub general_level_idc: StdVideoH265LevelIdc, +} +#[test] +fn bindgen_test_layout_StdVideoH265ProfileTierLevel() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 12usize, + concat!("Size of: ", stringify!(StdVideoH265ProfileTierLevel)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265ProfileTierLevel)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ProfileTierLevel), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).general_profile_idc) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ProfileTierLevel), + "::", + stringify!(general_profile_idc) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).general_level_idc) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ProfileTierLevel), + "::", + stringify!(general_level_idc) + ) + ); +} +#[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH265VideoParameterSet { pub flags: StdVideoH265VpsFlags, pub vps_video_parameter_set_id: u8, pub vps_max_sub_layers_minus1: u8, + pub reserved1: u8, + pub reserved2: u8, pub vps_num_units_in_tick: u32, pub vps_time_scale: u32, pub vps_num_ticks_poc_diff_one_minus1: u32, + pub reserved3: u32, pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr, pub pHrdParameters: *const StdVideoH265HrdParameters, + pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel, } #[test] fn bindgen_test_layout_StdVideoH265VideoParameterSet() { @@ -3037,7 +3039,7 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 40usize, + 48usize, concat!("Size of: ", stringify!(StdVideoH265VideoParameterSet)) ); assert_eq!( @@ -3075,6 +3077,26 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { stringify!(vps_max_sub_layers_minus1) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 7usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(reserved2) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vps_num_units_in_tick) as usize - ptr as usize }, 8usize, @@ -3107,6 +3129,16 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { stringify!(vps_num_ticks_poc_diff_one_minus1) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(reserved3) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize }, 24usize, @@ -3127,6 +3159,16 @@ fn bindgen_test_layout_StdVideoH265VideoParameterSet() { stringify!(pHrdParameters) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265VideoParameterSet), + "::", + stringify!(pProfileTierLevel) + ) + ); } #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -3552,7 +3594,7 @@ impl StdVideoH265SpsVuiFlags { #[derive(Debug, Copy, Clone)] pub struct StdVideoH265SequenceParameterSetVui { pub flags: StdVideoH265SpsVuiFlags, - pub aspect_ratio_idc: u8, + pub aspect_ratio_idc: StdVideoH265AspectRatioIdc, pub sar_width: u16, pub sar_height: u16, pub video_format: u8, @@ -3561,6 +3603,8 @@ pub struct StdVideoH265SequenceParameterSetVui { pub matrix_coeffs: u8, pub chroma_sample_loc_type_top_field: u8, pub chroma_sample_loc_type_bottom_field: u8, + pub reserved1: u8, + pub reserved2: u8, pub def_disp_win_left_offset: u16, pub def_disp_win_right_offset: u16, pub def_disp_win_top_offset: u16, @@ -3568,12 +3612,13 @@ 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 pHrdParameters: *const StdVideoH265HrdParameters, pub min_spatial_segmentation_idc: u16, + pub reserved3: u16, pub max_bytes_per_pic_denom: u8, pub max_bits_per_min_cu_denom: u8, pub log2_max_mv_length_horizontal: u8, pub log2_max_mv_length_vertical: u8, + pub pHrdParameters: *const StdVideoH265HrdParameters, } #[test] fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { @@ -3615,7 +3660,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sar_width) as usize - ptr as usize }, - 6usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3625,7 +3670,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sar_height) as usize - ptr as usize }, - 8usize, + 10usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3635,7 +3680,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).video_format) as usize - ptr as usize }, - 10usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3645,7 +3690,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).colour_primaries) as usize - ptr as usize }, - 11usize, + 13usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3655,7 +3700,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).transfer_characteristics) as usize - ptr as usize }, - 12usize, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3665,7 +3710,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).matrix_coeffs) as usize - ptr as usize }, - 13usize, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3677,7 +3722,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { unsafe { ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_top_field) as usize - ptr as usize }, - 14usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3689,7 +3734,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { unsafe { ::std::ptr::addr_of!((*ptr).chroma_sample_loc_type_bottom_field) as usize - ptr as usize }, - 15usize, + 17usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3697,9 +3742,29 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { stringify!(chroma_sample_loc_type_bottom_field) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(reserved2) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_left_offset) as usize - ptr as usize }, - 16usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3709,7 +3774,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_right_offset) as usize - ptr as usize }, - 18usize, + 22usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3719,7 +3784,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_top_offset) as usize - ptr as usize }, - 20usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3729,7 +3794,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).def_disp_win_bottom_offset) as usize - ptr as usize }, - 22usize, + 26usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3739,7 +3804,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vui_num_units_in_tick) as usize - ptr as usize }, - 24usize, + 28usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3749,7 +3814,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).vui_time_scale) as usize - ptr as usize }, - 28usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3761,7 +3826,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { unsafe { ::std::ptr::addr_of!((*ptr).vui_num_ticks_poc_diff_one_minus1) as usize - ptr as usize }, - 32usize, + 36usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3769,21 +3834,11 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { stringify!(vui_num_ticks_poc_diff_one_minus1) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, - 40usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSetVui), - "::", - stringify!(pHrdParameters) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).min_spatial_segmentation_idc) as usize - ptr as usize }, - 48usize, + 40usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3791,9 +3846,19 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { stringify!(min_spatial_segmentation_idc) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 42usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(reserved3) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_bytes_per_pic_denom) as usize - ptr as usize }, - 50usize, + 44usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3803,7 +3868,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).max_bits_per_min_cu_denom) as usize - ptr as usize }, - 51usize, + 45usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3815,7 +3880,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { unsafe { ::std::ptr::addr_of!((*ptr).log2_max_mv_length_horizontal) as usize - ptr as usize }, - 52usize, + 46usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3825,7 +3890,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).log2_max_mv_length_vertical) as usize - ptr as usize }, - 53usize, + 47usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), @@ -3833,6 +3898,16 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { stringify!(log2_max_mv_length_vertical) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + 48usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSetVui), + "::", + stringify!(pHrdParameters) + ) + ); } #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -3912,295 +3987,319 @@ impl StdVideoH265SpsFlags { } } #[inline] - pub fn scaling_list_enabled_flag(&self) -> u32 { + pub fn conformance_window_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } } #[inline] - pub fn set_scaling_list_enabled_flag(&mut self, val: u32) { + pub fn set_conformance_window_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 sps_scaling_list_data_present_flag(&self) -> u32 { + pub fn sps_sub_layer_ordering_info_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) } } #[inline] - pub fn set_sps_scaling_list_data_present_flag(&mut self, val: u32) { + pub fn set_sps_sub_layer_ordering_info_present_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 amp_enabled_flag(&self) -> u32 { + pub fn scaling_list_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) } } #[inline] - pub fn set_amp_enabled_flag(&mut self, val: u32) { + pub fn set_scaling_list_enabled_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 sample_adaptive_offset_enabled_flag(&self) -> u32 { + pub fn sps_scaling_list_data_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) } } #[inline] - pub fn set_sample_adaptive_offset_enabled_flag(&mut self, val: u32) { + pub fn set_sps_scaling_list_data_present_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 pcm_enabled_flag(&self) -> u32 { + pub fn amp_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } } #[inline] - pub fn set_pcm_enabled_flag(&mut self, val: u32) { + pub fn set_amp_enabled_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 pcm_loop_filter_disabled_flag(&self) -> u32 { + pub fn sample_adaptive_offset_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) } } #[inline] - pub fn set_pcm_loop_filter_disabled_flag(&mut self, val: u32) { + pub fn set_sample_adaptive_offset_enabled_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 long_term_ref_pics_present_flag(&self) -> u32 { + pub fn pcm_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) } } #[inline] - pub fn set_long_term_ref_pics_present_flag(&mut self, val: u32) { + pub fn set_pcm_enabled_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 sps_temporal_mvp_enabled_flag(&self) -> u32 { + pub fn pcm_loop_filter_disabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) } } #[inline] - pub fn set_sps_temporal_mvp_enabled_flag(&mut self, val: u32) { + pub fn set_pcm_loop_filter_disabled_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 strong_intra_smoothing_enabled_flag(&self) -> u32 { + pub fn long_term_ref_pics_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) } } #[inline] - pub fn set_strong_intra_smoothing_enabled_flag(&mut self, val: u32) { + pub fn set_long_term_ref_pics_present_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 vui_parameters_present_flag(&self) -> u32 { + pub fn sps_temporal_mvp_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } } #[inline] - pub fn set_vui_parameters_present_flag(&mut self, val: u32) { + pub fn set_sps_temporal_mvp_enabled_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 sps_extension_present_flag(&self) -> u32 { + pub fn strong_intra_smoothing_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } } #[inline] - pub fn set_sps_extension_present_flag(&mut self, val: u32) { + pub fn set_strong_intra_smoothing_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 sps_range_extension_flag(&self) -> u32 { + pub fn vui_parameters_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } } #[inline] - pub fn set_sps_range_extension_flag(&mut self, val: u32) { + pub fn set_vui_parameters_present_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 transform_skip_rotation_enabled_flag(&self) -> u32 { + pub fn sps_extension_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 1u8) as u32) } } #[inline] - pub fn set_transform_skip_rotation_enabled_flag(&mut self, val: u32) { + pub fn set_sps_extension_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 transform_skip_context_enabled_flag(&self) -> u32 { + pub fn sps_range_extension_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 1u8) as u32) } } #[inline] - pub fn set_transform_skip_context_enabled_flag(&mut self, val: u32) { + pub fn set_sps_range_extension_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 implicit_rdpcm_enabled_flag(&self) -> u32 { + pub fn transform_skip_rotation_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(16usize, 1u8) as u32) } } #[inline] - pub fn set_implicit_rdpcm_enabled_flag(&mut self, val: u32) { + pub fn set_transform_skip_rotation_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(16usize, 1u8, val as u64) } } #[inline] - pub fn explicit_rdpcm_enabled_flag(&self) -> u32 { + pub fn transform_skip_context_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(17usize, 1u8) as u32) } } #[inline] - pub fn set_explicit_rdpcm_enabled_flag(&mut self, val: u32) { + pub fn set_transform_skip_context_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(17usize, 1u8, val as u64) } } #[inline] - pub fn extended_precision_processing_flag(&self) -> u32 { + pub fn implicit_rdpcm_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(18usize, 1u8) as u32) } } #[inline] - pub fn set_extended_precision_processing_flag(&mut self, val: u32) { + pub fn set_implicit_rdpcm_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(18usize, 1u8, val as u64) } } #[inline] - pub fn intra_smoothing_disabled_flag(&self) -> u32 { + pub fn explicit_rdpcm_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(19usize, 1u8) as u32) } } #[inline] - pub fn set_intra_smoothing_disabled_flag(&mut self, val: u32) { + pub fn set_explicit_rdpcm_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(19usize, 1u8, val as u64) } } #[inline] - pub fn high_precision_offsets_enabled_flag(&self) -> u32 { + pub fn extended_precision_processing_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(20usize, 1u8) as u32) } } #[inline] - pub fn set_high_precision_offsets_enabled_flag(&mut self, val: u32) { + pub fn set_extended_precision_processing_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(20usize, 1u8, val as u64) } } #[inline] - pub fn persistent_rice_adaptation_enabled_flag(&self) -> u32 { + pub fn intra_smoothing_disabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(21usize, 1u8) as u32) } } #[inline] - pub fn set_persistent_rice_adaptation_enabled_flag(&mut self, val: u32) { + pub fn set_intra_smoothing_disabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(21usize, 1u8, val as u64) } } #[inline] - pub fn cabac_bypass_alignment_enabled_flag(&self) -> u32 { + pub fn high_precision_offsets_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(22usize, 1u8) as u32) } } #[inline] - pub fn set_cabac_bypass_alignment_enabled_flag(&mut self, val: u32) { + pub fn set_high_precision_offsets_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(22usize, 1u8, val as u64) } } #[inline] - pub fn sps_scc_extension_flag(&self) -> u32 { + pub fn persistent_rice_adaptation_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(23usize, 1u8) as u32) } } #[inline] - pub fn set_sps_scc_extension_flag(&mut self, val: u32) { + pub fn set_persistent_rice_adaptation_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(23usize, 1u8, val as u64) } } #[inline] - pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 { + pub fn cabac_bypass_alignment_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 1u8) as u32) } } #[inline] - pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) { + pub fn set_cabac_bypass_alignment_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(24usize, 1u8, val as u64) } } #[inline] - pub fn palette_mode_enabled_flag(&self) -> u32 { + pub fn sps_scc_extension_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(25usize, 1u8) as u32) } } #[inline] - pub fn set_palette_mode_enabled_flag(&mut self, val: u32) { + pub fn set_sps_scc_extension_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(25usize, 1u8, val as u64) } } #[inline] - pub fn sps_palette_predictor_initializer_present_flag(&self) -> u32 { + pub fn sps_curr_pic_ref_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(26usize, 1u8) as u32) } } #[inline] - pub fn set_sps_palette_predictor_initializer_present_flag(&mut self, val: u32) { + pub fn set_sps_curr_pic_ref_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(26usize, 1u8, val as u64) } } #[inline] - pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 { + pub fn palette_mode_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(27usize, 1u8) as u32) } } #[inline] - pub fn set_intra_boundary_filtering_disabled_flag(&mut self, val: u32) { + pub fn set_palette_mode_enabled_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(27usize, 1u8, val as u64) } } #[inline] + pub fn sps_palette_predictor_initializers_present_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) } + } + #[inline] + pub fn set_sps_palette_predictor_initializers_present_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(28usize, 1u8, val as u64) + } + } + #[inline] + pub fn intra_boundary_filtering_disabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(29usize, 1u8) as u32) } + } + #[inline] + pub fn set_intra_boundary_filtering_disabled_flag(&mut self, val: u32) { + unsafe { + let val: u32 = ::std::mem::transmute(val); + self._bitfield_1.set(29usize, 1u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( sps_temporal_id_nesting_flag: u32, separate_colour_plane_flag: u32, + conformance_window_flag: u32, + sps_sub_layer_ordering_info_present_flag: u32, scaling_list_enabled_flag: u32, sps_scaling_list_data_present_flag: u32, amp_enabled_flag: u32, @@ -4225,7 +4324,7 @@ impl StdVideoH265SpsFlags { sps_scc_extension_flag: u32, sps_curr_pic_ref_enabled_flag: u32, palette_mode_enabled_flag: u32, - sps_palette_predictor_initializer_present_flag: u32, + sps_palette_predictor_initializers_present_flag: u32, intra_boundary_filtering_disabled_flag: u32, ) -> __BindgenBitfieldUnit<[u8; 4usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default(); @@ -4240,129 +4339,139 @@ impl StdVideoH265SpsFlags { separate_colour_plane_flag as u64 }); __bindgen_bitfield_unit.set(2usize, 1u8, { + let conformance_window_flag: u32 = + unsafe { ::std::mem::transmute(conformance_window_flag) }; + conformance_window_flag as u64 + }); + __bindgen_bitfield_unit.set(3usize, 1u8, { + let sps_sub_layer_ordering_info_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_sub_layer_ordering_info_present_flag) }; + sps_sub_layer_ordering_info_present_flag as u64 + }); + __bindgen_bitfield_unit.set(4usize, 1u8, { let scaling_list_enabled_flag: u32 = unsafe { ::std::mem::transmute(scaling_list_enabled_flag) }; scaling_list_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(3usize, 1u8, { + __bindgen_bitfield_unit.set(5usize, 1u8, { let sps_scaling_list_data_present_flag: u32 = unsafe { ::std::mem::transmute(sps_scaling_list_data_present_flag) }; sps_scaling_list_data_present_flag as u64 }); - __bindgen_bitfield_unit.set(4usize, 1u8, { + __bindgen_bitfield_unit.set(6usize, 1u8, { let amp_enabled_flag: u32 = unsafe { ::std::mem::transmute(amp_enabled_flag) }; amp_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(5usize, 1u8, { + __bindgen_bitfield_unit.set(7usize, 1u8, { let sample_adaptive_offset_enabled_flag: u32 = unsafe { ::std::mem::transmute(sample_adaptive_offset_enabled_flag) }; sample_adaptive_offset_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(6usize, 1u8, { + __bindgen_bitfield_unit.set(8usize, 1u8, { let pcm_enabled_flag: u32 = unsafe { ::std::mem::transmute(pcm_enabled_flag) }; pcm_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(7usize, 1u8, { + __bindgen_bitfield_unit.set(9usize, 1u8, { let pcm_loop_filter_disabled_flag: u32 = unsafe { ::std::mem::transmute(pcm_loop_filter_disabled_flag) }; pcm_loop_filter_disabled_flag as u64 }); - __bindgen_bitfield_unit.set(8usize, 1u8, { + __bindgen_bitfield_unit.set(10usize, 1u8, { let long_term_ref_pics_present_flag: u32 = unsafe { ::std::mem::transmute(long_term_ref_pics_present_flag) }; long_term_ref_pics_present_flag as u64 }); - __bindgen_bitfield_unit.set(9usize, 1u8, { + __bindgen_bitfield_unit.set(11usize, 1u8, { let sps_temporal_mvp_enabled_flag: u32 = unsafe { ::std::mem::transmute(sps_temporal_mvp_enabled_flag) }; sps_temporal_mvp_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(10usize, 1u8, { + __bindgen_bitfield_unit.set(12usize, 1u8, { let strong_intra_smoothing_enabled_flag: u32 = unsafe { ::std::mem::transmute(strong_intra_smoothing_enabled_flag) }; strong_intra_smoothing_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(11usize, 1u8, { + __bindgen_bitfield_unit.set(13usize, 1u8, { let vui_parameters_present_flag: u32 = unsafe { ::std::mem::transmute(vui_parameters_present_flag) }; vui_parameters_present_flag as u64 }); - __bindgen_bitfield_unit.set(12usize, 1u8, { + __bindgen_bitfield_unit.set(14usize, 1u8, { let sps_extension_present_flag: u32 = unsafe { ::std::mem::transmute(sps_extension_present_flag) }; sps_extension_present_flag as u64 }); - __bindgen_bitfield_unit.set(13usize, 1u8, { + __bindgen_bitfield_unit.set(15usize, 1u8, { let sps_range_extension_flag: u32 = unsafe { ::std::mem::transmute(sps_range_extension_flag) }; sps_range_extension_flag as u64 }); - __bindgen_bitfield_unit.set(14usize, 1u8, { + __bindgen_bitfield_unit.set(16usize, 1u8, { let transform_skip_rotation_enabled_flag: u32 = unsafe { ::std::mem::transmute(transform_skip_rotation_enabled_flag) }; transform_skip_rotation_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(15usize, 1u8, { + __bindgen_bitfield_unit.set(17usize, 1u8, { let transform_skip_context_enabled_flag: u32 = unsafe { ::std::mem::transmute(transform_skip_context_enabled_flag) }; transform_skip_context_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(16usize, 1u8, { + __bindgen_bitfield_unit.set(18usize, 1u8, { let implicit_rdpcm_enabled_flag: u32 = unsafe { ::std::mem::transmute(implicit_rdpcm_enabled_flag) }; implicit_rdpcm_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(17usize, 1u8, { + __bindgen_bitfield_unit.set(19usize, 1u8, { let explicit_rdpcm_enabled_flag: u32 = unsafe { ::std::mem::transmute(explicit_rdpcm_enabled_flag) }; explicit_rdpcm_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(18usize, 1u8, { + __bindgen_bitfield_unit.set(20usize, 1u8, { let extended_precision_processing_flag: u32 = unsafe { ::std::mem::transmute(extended_precision_processing_flag) }; extended_precision_processing_flag as u64 }); - __bindgen_bitfield_unit.set(19usize, 1u8, { + __bindgen_bitfield_unit.set(21usize, 1u8, { let intra_smoothing_disabled_flag: u32 = unsafe { ::std::mem::transmute(intra_smoothing_disabled_flag) }; intra_smoothing_disabled_flag as u64 }); - __bindgen_bitfield_unit.set(20usize, 1u8, { + __bindgen_bitfield_unit.set(22usize, 1u8, { let high_precision_offsets_enabled_flag: u32 = unsafe { ::std::mem::transmute(high_precision_offsets_enabled_flag) }; high_precision_offsets_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(21usize, 1u8, { + __bindgen_bitfield_unit.set(23usize, 1u8, { let persistent_rice_adaptation_enabled_flag: u32 = unsafe { ::std::mem::transmute(persistent_rice_adaptation_enabled_flag) }; persistent_rice_adaptation_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(22usize, 1u8, { + __bindgen_bitfield_unit.set(24usize, 1u8, { let cabac_bypass_alignment_enabled_flag: u32 = unsafe { ::std::mem::transmute(cabac_bypass_alignment_enabled_flag) }; cabac_bypass_alignment_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(23usize, 1u8, { + __bindgen_bitfield_unit.set(25usize, 1u8, { let sps_scc_extension_flag: u32 = unsafe { ::std::mem::transmute(sps_scc_extension_flag) }; sps_scc_extension_flag as u64 }); - __bindgen_bitfield_unit.set(24usize, 1u8, { + __bindgen_bitfield_unit.set(26usize, 1u8, { let sps_curr_pic_ref_enabled_flag: u32 = unsafe { ::std::mem::transmute(sps_curr_pic_ref_enabled_flag) }; sps_curr_pic_ref_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(25usize, 1u8, { + __bindgen_bitfield_unit.set(27usize, 1u8, { let palette_mode_enabled_flag: u32 = unsafe { ::std::mem::transmute(palette_mode_enabled_flag) }; palette_mode_enabled_flag as u64 }); - __bindgen_bitfield_unit.set(26usize, 1u8, { - let sps_palette_predictor_initializer_present_flag: u32 = - unsafe { ::std::mem::transmute(sps_palette_predictor_initializer_present_flag) }; - sps_palette_predictor_initializer_present_flag as u64 + __bindgen_bitfield_unit.set(28usize, 1u8, { + let sps_palette_predictor_initializers_present_flag: u32 = + unsafe { ::std::mem::transmute(sps_palette_predictor_initializers_present_flag) }; + sps_palette_predictor_initializers_present_flag as u64 }); - __bindgen_bitfield_unit.set(27usize, 1u8, { + __bindgen_bitfield_unit.set(29usize, 1u8, { let intra_boundary_filtering_disabled_flag: u32 = unsafe { ::std::mem::transmute(intra_boundary_filtering_disabled_flag) }; intra_boundary_filtering_disabled_flag as u64 @@ -4371,17 +4480,298 @@ impl StdVideoH265SpsFlags { } } #[repr(C)] +#[repr(align(4))] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ShortTermRefPicSetFlags { + pub _bitfield_align_1: [u8; 0], + pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>, + pub __bindgen_padding_0: [u8; 3usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ShortTermRefPicSetFlags() { + assert_eq!( + ::std::mem::size_of::(), + 4usize, + concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSetFlags)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!( + "Alignment of ", + stringify!(StdVideoH265ShortTermRefPicSetFlags) + ) + ); +} +impl StdVideoH265ShortTermRefPicSetFlags { + #[inline] + pub fn inter_ref_pic_set_prediction_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) } + } + #[inline] + pub fn set_inter_ref_pic_set_prediction_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 delta_rps_sign(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) } + } + #[inline] + pub fn set_delta_rps_sign(&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( + inter_ref_pic_set_prediction_flag: u32, + delta_rps_sign: u32, + ) -> __BindgenBitfieldUnit<[u8; 1usize]> { + let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); + __bindgen_bitfield_unit.set(0usize, 1u8, { + let inter_ref_pic_set_prediction_flag: u32 = + unsafe { ::std::mem::transmute(inter_ref_pic_set_prediction_flag) }; + inter_ref_pic_set_prediction_flag as u64 + }); + __bindgen_bitfield_unit.set(1usize, 1u8, { + let delta_rps_sign: u32 = unsafe { ::std::mem::transmute(delta_rps_sign) }; + delta_rps_sign as u64 + }); + __bindgen_bitfield_unit + } +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265ShortTermRefPicSet { + pub flags: StdVideoH265ShortTermRefPicSetFlags, + pub delta_idx_minus1: u32, + pub use_delta_flag: u16, + pub abs_delta_rps_minus1: u16, + pub used_by_curr_pic_flag: u16, + pub used_by_curr_pic_s0_flag: u16, + pub used_by_curr_pic_s1_flag: u16, + pub reserved1: u16, + pub reserved2: u8, + pub reserved3: u8, + pub num_negative_pics: u8, + pub num_positive_pics: u8, + pub delta_poc_s0_minus1: [u16; 16usize], + pub delta_poc_s1_minus1: [u16; 16usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265ShortTermRefPicSet() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 88usize, + concat!("Size of: ", stringify!(StdVideoH265ShortTermRefPicSet)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265ShortTermRefPicSet)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(flags) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_idx_minus1) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(delta_idx_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).use_delta_flag) as usize - ptr as usize }, + 8usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(use_delta_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).abs_delta_rps_minus1) as usize - ptr as usize }, + 10usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(abs_delta_rps_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_flag) as usize - ptr as usize }, + 12usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(used_by_curr_pic_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s0_flag) as usize - ptr as usize }, + 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(used_by_curr_pic_s0_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_s1_flag) as usize - ptr as usize }, + 16usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(used_by_curr_pic_s1_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 20usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 21usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_negative_pics) as usize - ptr as usize }, + 22usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(num_negative_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_positive_pics) as usize - ptr as usize }, + 23usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(num_positive_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s0_minus1) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(delta_poc_s0_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_s1_minus1) as usize - ptr as usize }, + 56usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265ShortTermRefPicSet), + "::", + stringify!(delta_poc_s1_minus1) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct StdVideoH265LongTermRefPicsSps { + pub used_by_curr_pic_lt_sps_flag: u32, + pub lt_ref_pic_poc_lsb_sps: [u32; 32usize], +} +#[test] +fn bindgen_test_layout_StdVideoH265LongTermRefPicsSps() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 132usize, + concat!("Size of: ", stringify!(StdVideoH265LongTermRefPicsSps)) + ); + assert_eq!( + ::std::mem::align_of::(), + 4usize, + concat!("Alignment of ", stringify!(StdVideoH265LongTermRefPicsSps)) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_sps_flag) as usize - ptr as usize + }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265LongTermRefPicsSps), + "::", + stringify!(used_by_curr_pic_lt_sps_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).lt_ref_pic_poc_lsb_sps) as usize - ptr as usize }, + 4usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265LongTermRefPicsSps), + "::", + stringify!(lt_ref_pic_poc_lsb_sps) + ) + ); +} +#[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoH265SequenceParameterSet { pub flags: StdVideoH265SpsFlags, - pub profile_idc: StdVideoH265ProfileIdc, - pub level_idc: StdVideoH265Level, + pub chroma_format_idc: StdVideoH265ChromaFormatIdc, pub pic_width_in_luma_samples: u32, pub pic_height_in_luma_samples: u32, pub sps_video_parameter_set_id: u8, pub sps_max_sub_layers_minus1: u8, pub sps_seq_parameter_set_id: u8, - pub chroma_format_idc: u8, pub bit_depth_luma_minus8: u8, pub bit_depth_chroma_minus8: u8, pub log2_max_pic_order_cnt_lsb_minus4: u8, @@ -4397,17 +4787,22 @@ pub struct StdVideoH265SequenceParameterSet { pub pcm_sample_bit_depth_chroma_minus1: u8, pub log2_min_pcm_luma_coding_block_size_minus3: u8, pub log2_diff_max_min_pcm_luma_coding_block_size: u8, + pub reserved1: u8, + pub reserved2: u8, + pub palette_max_size: u8, + pub delta_palette_max_predictor_size: u8, + pub motion_vector_resolution_control_idc: u8, + pub sps_num_palette_predictor_initializers_minus1: u8, pub conf_win_left_offset: u32, pub conf_win_right_offset: u32, pub conf_win_top_offset: u32, pub conf_win_bottom_offset: u32, + pub pProfileTierLevel: *const StdVideoH265ProfileTierLevel, pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr, pub pScalingLists: *const StdVideoH265ScalingLists, + pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet, + pub pLongTermRefPicsSps: *const StdVideoH265LongTermRefPicsSps, pub pSequenceParameterSetVui: *const StdVideoH265SequenceParameterSetVui, - pub palette_max_size: u8, - pub delta_palette_max_predictor_size: u8, - pub motion_vector_resolution_control_idc: u8, - pub sps_num_palette_predictor_initializer_minus1: u8, pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries, } #[test] @@ -4417,7 +4812,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 96usize, + 112usize, concat!("Size of: ", stringify!(StdVideoH265SequenceParameterSet)) ); assert_eq!( @@ -4439,28 +4834,18 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).profile_idc) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, 4usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(profile_idc) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).level_idc) as usize - ptr as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSet), - "::", - stringify!(level_idc) + stringify!(chroma_format_idc) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_luma_samples) as usize - ptr as usize }, - 12usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4470,7 +4855,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pic_height_in_luma_samples) as usize - ptr as usize }, - 16usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4480,7 +4865,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, - 20usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4490,7 +4875,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sps_max_sub_layers_minus1) as usize - ptr as usize }, - 21usize, + 17usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4500,7 +4885,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).sps_seq_parameter_set_id) as usize - ptr as usize }, - 22usize, + 18usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4508,19 +4893,9 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { stringify!(sps_seq_parameter_set_id) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, - 23usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSet), - "::", - stringify!(chroma_format_idc) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize }, - 24usize, + 19usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4530,7 +4905,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize }, - 25usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4542,7 +4917,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize }, - 26usize, + 21usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4555,7 +4930,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ::std::ptr::addr_of!((*ptr).log2_min_luma_coding_block_size_minus3) as usize - ptr as usize }, - 27usize, + 22usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4568,7 +4943,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_coding_block_size) as usize - ptr as usize }, - 28usize, + 23usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4581,7 +4956,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ::std::ptr::addr_of!((*ptr).log2_min_luma_transform_block_size_minus2) as usize - ptr as usize }, - 29usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4594,7 +4969,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_transform_block_size) as usize - ptr as usize }, - 30usize, + 25usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4606,7 +4981,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_inter) as usize - ptr as usize }, - 31usize, + 26usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4618,7 +4993,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_intra) as usize - ptr as usize }, - 32usize, + 27usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4628,7 +5003,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).num_short_term_ref_pic_sets) as usize - ptr as usize }, - 33usize, + 28usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4638,7 +5013,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_ref_pics_sps) as usize - ptr as usize }, - 34usize, + 29usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4650,7 +5025,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_luma_minus1) as usize - ptr as usize }, - 35usize, + 30usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4662,7 +5037,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_chroma_minus1) as usize - ptr as usize }, - 36usize, + 31usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4675,7 +5050,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ::std::ptr::addr_of!((*ptr).log2_min_pcm_luma_coding_block_size_minus3) as usize - ptr as usize }, - 37usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4688,7 +5063,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ::std::ptr::addr_of!((*ptr).log2_diff_max_min_pcm_luma_coding_block_size) as usize - ptr as usize }, - 38usize, + 33usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4696,6 +5071,74 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { stringify!(log2_diff_max_min_pcm_luma_coding_block_size) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).palette_max_size) as usize - ptr as usize }, + 36usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(palette_max_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).delta_palette_max_predictor_size) as usize - ptr as usize + }, + 37usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(delta_palette_max_predictor_size) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).motion_vector_resolution_control_idc) as usize + - ptr as usize + }, + 38usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(motion_vector_resolution_control_idc) + ) + ); + assert_eq!( + unsafe { + ::std::ptr::addr_of!((*ptr).sps_num_palette_predictor_initializers_minus1) as usize + - ptr as usize + }, + 39usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_num_palette_predictor_initializers_minus1) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).conf_win_left_offset) as usize - ptr as usize }, 40usize, @@ -4737,8 +5180,18 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pProfileTierLevel) as usize - ptr as usize }, 56usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pProfileTierLevel) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize }, + 64usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4748,7 +5201,7 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, - 64usize, + 72usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4756,9 +5209,29 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { stringify!(pScalingLists) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize }, + 80usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pShortTermRefPicSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPicsSps) as usize - ptr as usize }, + 88usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(pLongTermRefPicsSps) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize }, - 72usize, + 96usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -4766,57 +5239,9 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { stringify!(pSequenceParameterSetVui) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).palette_max_size) as usize - ptr as usize }, - 80usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSet), - "::", - stringify!(palette_max_size) - ) - ); - assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).delta_palette_max_predictor_size) as usize - ptr as usize - }, - 81usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSet), - "::", - stringify!(delta_palette_max_predictor_size) - ) - ); - assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).motion_vector_resolution_control_idc) as usize - - ptr as usize - }, - 82usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSet), - "::", - stringify!(motion_vector_resolution_control_idc) - ) - ); - assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).sps_num_palette_predictor_initializer_minus1) as usize - - ptr as usize - }, - 83usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265SequenceParameterSet), - "::", - stringify!(sps_num_palette_predictor_initializer_minus1) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize }, - 88usize, + 104usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), @@ -5155,11 +5580,11 @@ impl StdVideoH265PpsFlags { } } #[inline] - pub fn pps_palette_predictor_initializer_present_flag(&self) -> u32 { + pub fn pps_palette_predictor_initializers_present_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(28usize, 1u8) as u32) } } #[inline] - pub fn set_pps_palette_predictor_initializer_present_flag(&mut self, val: u32) { + pub fn set_pps_palette_predictor_initializers_present_flag(&mut self, val: u32) { unsafe { let val: u32 = ::std::mem::transmute(val); self._bitfield_1.set(28usize, 1u8, val as u64) @@ -5217,7 +5642,7 @@ impl StdVideoH265PpsFlags { pps_curr_pic_ref_enabled_flag: u32, residual_adaptive_colour_transform_enabled_flag: u32, pps_slice_act_qp_offsets_present_flag: u32, - pps_palette_predictor_initializer_present_flag: u32, + pps_palette_predictor_initializers_present_flag: u32, monochrome_palette_flag: u32, pps_range_extension_flag: u32, ) -> __BindgenBitfieldUnit<[u8; 4usize]> { @@ -5359,9 +5784,9 @@ impl StdVideoH265PpsFlags { pps_slice_act_qp_offsets_present_flag as u64 }); __bindgen_bitfield_unit.set(28usize, 1u8, { - let pps_palette_predictor_initializer_present_flag: u32 = - unsafe { ::std::mem::transmute(pps_palette_predictor_initializer_present_flag) }; - pps_palette_predictor_initializer_present_flag as u64 + let pps_palette_predictor_initializers_present_flag: u32 = + unsafe { ::std::mem::transmute(pps_palette_predictor_initializers_present_flag) }; + pps_palette_predictor_initializers_present_flag as u64 }); __bindgen_bitfield_unit.set(29usize, 1u8, { let monochrome_palette_flag: u32 = @@ -5382,6 +5807,7 @@ pub struct StdVideoH265PictureParameterSet { pub flags: StdVideoH265PpsFlags, pub pps_pic_parameter_set_id: u8, pub pps_seq_parameter_set_id: u8, + pub sps_video_parameter_set_id: u8, pub num_extra_slice_header_bits: u8, pub num_ref_idx_l0_default_active_minus1: u8, pub num_ref_idx_l1_default_active_minus1: u8, @@ -5389,14 +5815,9 @@ pub struct StdVideoH265PictureParameterSet { pub diff_cu_qp_delta_depth: u8, pub pps_cb_qp_offset: i8, pub pps_cr_qp_offset: i8, - pub num_tile_columns_minus1: u8, - pub num_tile_rows_minus1: u8, - pub column_width_minus1: [u16; 19usize], - pub row_height_minus1: [u16; 21usize], pub pps_beta_offset_div2: i8, pub pps_tc_offset_div2: i8, pub log2_parallel_merge_level_minus2: u8, - pub pScalingLists: *const StdVideoH265ScalingLists, pub log2_max_transform_skip_block_size_minus2: u8, pub diff_cu_chroma_qp_offset_depth: u8, pub chroma_qp_offset_list_len_minus1: u8, @@ -5406,10 +5827,18 @@ pub struct StdVideoH265PictureParameterSet { pub log2_sao_offset_scale_chroma: u8, pub pps_act_y_qp_offset_plus5: i8, pub pps_act_cb_qp_offset_plus5: i8, - pub pps_act_cr_qp_offset_plus5: i8, - pub pps_num_palette_predictor_initializer: u8, + pub pps_act_cr_qp_offset_plus3: i8, + pub pps_num_palette_predictor_initializers: u8, pub luma_bit_depth_entry_minus8: u8, pub chroma_bit_depth_entry_minus8: u8, + pub num_tile_columns_minus1: u8, + pub num_tile_rows_minus1: u8, + pub reserved1: u8, + pub reserved2: u8, + pub column_width_minus1: [u16; 19usize], + pub row_height_minus1: [u16; 21usize], + pub reserved3: u32, + pub pScalingLists: *const StdVideoH265ScalingLists, pub pPredictorPaletteEntries: *const StdVideoH265PredictorPaletteEntries, } #[test] @@ -5458,8 +5887,18 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_extra_slice_header_bits) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, 6usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(sps_video_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_extra_slice_header_bits) as usize - ptr as usize }, + 7usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5472,7 +5911,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_default_active_minus1) as usize - ptr as usize }, - 7usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5485,7 +5924,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_default_active_minus1) as usize - ptr as usize }, - 8usize, + 9usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5495,7 +5934,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).init_qp_minus26) as usize - ptr as usize }, - 9usize, + 10usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5505,7 +5944,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).diff_cu_qp_delta_depth) as usize - ptr as usize }, - 10usize, + 11usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5515,7 +5954,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pps_cb_qp_offset) as usize - ptr as usize }, - 11usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5525,7 +5964,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pps_cr_qp_offset) as usize - ptr as usize }, - 12usize, + 13usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5533,49 +5972,9 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { stringify!(pps_cr_qp_offset) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_tile_columns_minus1) as usize - ptr as usize }, - 13usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265PictureParameterSet), - "::", - stringify!(num_tile_columns_minus1) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_tile_rows_minus1) as usize - ptr as usize }, - 14usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265PictureParameterSet), - "::", - stringify!(num_tile_rows_minus1) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).column_width_minus1) as usize - ptr as usize }, - 16usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265PictureParameterSet), - "::", - stringify!(column_width_minus1) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).row_height_minus1) as usize - ptr as usize }, - 54usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265PictureParameterSet), - "::", - stringify!(row_height_minus1) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pps_beta_offset_div2) as usize - ptr as usize }, - 96usize, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5585,7 +5984,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pps_tc_offset_div2) as usize - ptr as usize }, - 97usize, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5597,7 +5996,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).log2_parallel_merge_level_minus2) as usize - ptr as usize }, - 98usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5605,22 +6004,12 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { stringify!(log2_parallel_merge_level_minus2) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, - 104usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265PictureParameterSet), - "::", - stringify!(pScalingLists) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).log2_max_transform_skip_block_size_minus2) as usize - ptr as usize }, - 112usize, + 17usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5632,7 +6021,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).diff_cu_chroma_qp_offset_depth) as usize - ptr as usize }, - 113usize, + 18usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5644,7 +6033,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).chroma_qp_offset_list_len_minus1) as usize - ptr as usize }, - 114usize, + 19usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5654,7 +6043,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).cb_qp_offset_list) as usize - ptr as usize }, - 115usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5664,7 +6053,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).cr_qp_offset_list) as usize - ptr as usize }, - 121usize, + 26usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5674,7 +6063,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_luma) as usize - ptr as usize }, - 127usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5686,7 +6075,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_chroma) as usize - ptr as usize }, - 128usize, + 33usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5696,7 +6085,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pps_act_y_qp_offset_plus5) as usize - ptr as usize }, - 129usize, + 34usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5706,7 +6095,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cb_qp_offset_plus5) as usize - ptr as usize }, - 130usize, + 35usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5715,31 +6104,31 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cr_qp_offset_plus5) as usize - ptr as usize }, - 131usize, + unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cr_qp_offset_plus3) as usize - ptr as usize }, + 36usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(pps_act_cr_qp_offset_plus5) + stringify!(pps_act_cr_qp_offset_plus3) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).pps_num_palette_predictor_initializer) as usize + ::std::ptr::addr_of!((*ptr).pps_num_palette_predictor_initializers) as usize - ptr as usize }, - 132usize, + 37usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(pps_num_palette_predictor_initializer) + stringify!(pps_num_palette_predictor_initializers) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).luma_bit_depth_entry_minus8) as usize - ptr as usize }, - 133usize, + 38usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5751,7 +6140,7 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { unsafe { ::std::ptr::addr_of!((*ptr).chroma_bit_depth_entry_minus8) as usize - ptr as usize }, - 134usize, + 39usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), @@ -5759,6 +6148,86 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { stringify!(chroma_bit_depth_entry_minus8) ) ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_tile_columns_minus1) as usize - ptr as usize }, + 40usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_tile_columns_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_tile_rows_minus1) as usize - ptr as usize }, + 41usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(num_tile_rows_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 42usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(reserved1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 43usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(reserved2) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).column_width_minus1) as usize - ptr as usize }, + 44usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(column_width_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).row_height_minus1) as usize - ptr as usize }, + 82usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(row_height_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 124usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(reserved3) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 128usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pScalingLists) + ) + ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).pPredictorPaletteEntries) as usize - ptr as usize }, 136usize, @@ -5874,10 +6343,10 @@ pub struct StdVideoDecodeH265PictureInfo { pub sps_video_parameter_set_id: u8, pub pps_seq_parameter_set_id: u8, pub pps_pic_parameter_set_id: u8, - pub num_short_term_ref_pic_sets: u8, + pub NumDeltaPocsOfRefRpsIdx: u8, pub PicOrderCntVal: i32, pub NumBitsForSTRefPicSetInSlice: u16, - pub NumDeltaPocsOfRefRpsIdx: u8, + pub reserved: u16, pub RefPicSetStCurrBefore: [u8; 8usize], pub RefPicSetStCurrAfter: [u8; 8usize], pub RefPicSetLtCurr: [u8; 8usize], @@ -5938,13 +6407,13 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_short_term_ref_pic_sets) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).NumDeltaPocsOfRefRpsIdx) as usize - ptr as usize }, 7usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), "::", - stringify!(num_short_term_ref_pic_sets) + stringify!(NumDeltaPocsOfRefRpsIdx) ) ); assert_eq!( @@ -5970,18 +6439,18 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).NumDeltaPocsOfRefRpsIdx) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).reserved) as usize - ptr as usize }, 14usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), "::", - stringify!(NumDeltaPocsOfRefRpsIdx) + stringify!(reserved) ) ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrBefore) as usize - ptr as usize }, - 15usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -5991,7 +6460,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetStCurrAfter) as usize - ptr as usize }, - 23usize, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6001,7 +6470,7 @@ fn bindgen_test_layout_StdVideoDecodeH265PictureInfo() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).RefPicSetLtCurr) as usize - ptr as usize }, - 31usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoDecodeH265PictureInfo), @@ -6061,21 +6530,9 @@ impl StdVideoDecodeH265ReferenceInfoFlags { } } #[inline] - pub fn is_non_existing(&self) -> u32 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) } - } - #[inline] - pub fn set_is_non_existing(&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( used_for_long_term_reference: u32, unused_for_reference: u32, - is_non_existing: u32, ) -> __BindgenBitfieldUnit<[u8; 1usize]> { let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default(); __bindgen_bitfield_unit.set(0usize, 1u8, { @@ -6087,10 +6544,6 @@ impl StdVideoDecodeH265ReferenceInfoFlags { let unused_for_reference: u32 = unsafe { ::std::mem::transmute(unused_for_reference) }; unused_for_reference as u64 }); - __bindgen_bitfield_unit.set(2usize, 1u8, { - let is_non_existing: u32 = unsafe { ::std::mem::transmute(is_non_existing) }; - is_non_existing as u64 - }); __bindgen_bitfield_unit } } @@ -7571,36 +8024,58 @@ impl StdVideoEncodeH265SliceSegmentHeaderFlags { } } #[inline] - pub fn slice_deblocking_filter_disable_flag(&self) -> u32 { + pub fn cu_chroma_qp_offset_enabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(11usize, 1u8) as u32) } } #[inline] - pub fn set_slice_deblocking_filter_disable_flag(&mut self, val: u32) { + pub fn set_cu_chroma_qp_offset_enabled_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 collocated_from_l0_flag(&self) -> u32 { + pub fn deblocking_filter_override_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(12usize, 1u8) as u32) } } #[inline] - pub fn set_collocated_from_l0_flag(&mut self, val: u32) { + pub fn set_deblocking_filter_override_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 slice_loop_filter_across_slices_enabled_flag(&self) -> u32 { + pub fn slice_deblocking_filter_disabled_flag(&self) -> u32 { unsafe { ::std::mem::transmute(self._bitfield_1.get(13usize, 1u8) as u32) } } #[inline] + pub fn set_slice_deblocking_filter_disabled_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 collocated_from_l0_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(14usize, 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(14usize, 1u8, val as u64) + } + } + #[inline] + pub fn slice_loop_filter_across_slices_enabled_flag(&self) -> u32 { + unsafe { ::std::mem::transmute(self._bitfield_1.get(15usize, 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(13usize, 1u8, val as u64) + self._bitfield_1.set(15usize, 1u8, val as u64) } } #[inline] @@ -7616,7 +8091,9 @@ impl StdVideoEncodeH265SliceSegmentHeaderFlags { num_ref_idx_active_override_flag: u32, mvd_l1_zero_flag: u32, cabac_init_flag: u32, - slice_deblocking_filter_disable_flag: u32, + cu_chroma_qp_offset_enabled_flag: u32, + deblocking_filter_override_flag: u32, + slice_deblocking_filter_disabled_flag: u32, collocated_from_l0_flag: u32, slice_loop_filter_across_slices_enabled_flag: u32, ) -> __BindgenBitfieldUnit<[u8; 2usize]> { @@ -7673,16 +8150,26 @@ impl StdVideoEncodeH265SliceSegmentHeaderFlags { cabac_init_flag as u64 }); __bindgen_bitfield_unit.set(11usize, 1u8, { - let slice_deblocking_filter_disable_flag: u32 = - unsafe { ::std::mem::transmute(slice_deblocking_filter_disable_flag) }; - slice_deblocking_filter_disable_flag as u64 + let cu_chroma_qp_offset_enabled_flag: u32 = + unsafe { ::std::mem::transmute(cu_chroma_qp_offset_enabled_flag) }; + cu_chroma_qp_offset_enabled_flag as u64 }); __bindgen_bitfield_unit.set(12usize, 1u8, { + let deblocking_filter_override_flag: u32 = + unsafe { ::std::mem::transmute(deblocking_filter_override_flag) }; + deblocking_filter_override_flag as u64 + }); + __bindgen_bitfield_unit.set(13usize, 1u8, { + let slice_deblocking_filter_disabled_flag: u32 = + unsafe { ::std::mem::transmute(slice_deblocking_filter_disabled_flag) }; + slice_deblocking_filter_disabled_flag as u64 + }); + __bindgen_bitfield_unit.set(14usize, 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(13usize, 1u8, { + __bindgen_bitfield_unit.set(15usize, 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 @@ -7692,14 +8179,114 @@ impl StdVideoEncodeH265SliceSegmentHeaderFlags { } #[repr(C)] #[derive(Debug, Copy, Clone)] +pub struct StdVideoEncodeH265SliceSegmentLongTermRefPics { + pub num_long_term_sps: u8, + pub num_long_term_pics: u8, + pub lt_idx_sps: [u8; 32usize], + pub poc_lsb_lt: [u8; 16usize], + pub used_by_curr_pic_lt_flag: u16, + pub delta_poc_msb_present_flag: [u8; 48usize], + pub delta_poc_msb_cycle_lt: [u8; 48usize], +} +#[test] +fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); + assert_eq!( + ::std::mem::size_of::(), + 148usize, + concat!( + "Size of: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + ) + ); + assert_eq!( + ::std::mem::align_of::(), + 2usize, + concat!( + "Alignment of ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize }, + 0usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(num_long_term_sps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize }, + 1usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(num_long_term_pics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).lt_idx_sps) as usize - ptr as usize }, + 2usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(lt_idx_sps) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).poc_lsb_lt) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(poc_lsb_lt) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).used_by_curr_pic_lt_flag) as usize - ptr as usize }, + 50usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(used_by_curr_pic_lt_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_present_flag) as usize - ptr as usize }, + 52usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(delta_poc_msb_present_flag) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).delta_poc_msb_cycle_lt) as usize - ptr as usize }, + 100usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + "::", + stringify!(delta_poc_msb_cycle_lt) + ) + ); +} +#[repr(C)] +#[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH265SliceSegmentHeader { pub flags: StdVideoEncodeH265SliceSegmentHeaderFlags, pub slice_type: StdVideoH265SliceType, - 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, @@ -7711,6 +8298,8 @@ pub struct StdVideoEncodeH265SliceSegmentHeader { pub slice_act_y_qp_offset: i8, pub slice_act_cb_qp_offset: i8, pub slice_act_cr_qp_offset: i8, + pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet, + pub pLongTermRefPics: *const StdVideoEncodeH265SliceSegmentLongTermRefPics, pub pWeightTable: *const StdVideoEncodeH265WeightTable, } #[test] @@ -7720,7 +8309,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { let ptr = UNINIT.as_ptr(); assert_eq!( ::std::mem::size_of::(), - 40usize, + 48usize, concat!( "Size of: ", stringify!(StdVideoEncodeH265SliceSegmentHeader) @@ -7754,19 +8343,9 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { stringify!(slice_type) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_short_term_ref_pic_sets) as usize - ptr as usize }, - 8usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(num_short_term_ref_pic_sets) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_segment_address) as usize - ptr as usize }, - 12usize, + 8usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7776,7 +8355,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).short_term_ref_pic_set_idx) as usize - ptr as usize }, - 16usize, + 12usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7784,29 +8363,9 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { stringify!(short_term_ref_pic_set_idx) ) ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_sps) as usize - ptr as usize }, - 17usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(num_long_term_sps) - ) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_pics) as usize - ptr as usize }, - 18usize, - concat!( - "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentHeader), - "::", - stringify!(num_long_term_pics) - ) - ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).collocated_ref_idx) as usize - ptr as usize }, - 19usize, + 13usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7818,7 +8377,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { unsafe { ::std::ptr::addr_of!((*ptr).num_ref_idx_l0_active_minus1) as usize - ptr as usize }, - 20usize, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7830,7 +8389,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { unsafe { ::std::ptr::addr_of!((*ptr).num_ref_idx_l1_active_minus1) as usize - ptr as usize }, - 21usize, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7840,7 +8399,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).MaxNumMergeCand) as usize - ptr as usize }, - 22usize, + 16usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7850,7 +8409,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_cb_qp_offset) as usize - ptr as usize }, - 23usize, + 17usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7860,7 +8419,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_cr_qp_offset) as usize - ptr as usize }, - 24usize, + 18usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7870,7 +8429,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_beta_offset_div2) as usize - ptr as usize }, - 25usize, + 19usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7880,7 +8439,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_tc_offset_div2) as usize - ptr as usize }, - 26usize, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7890,7 +8449,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_act_y_qp_offset) as usize - ptr as usize }, - 27usize, + 21usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7900,7 +8459,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cb_qp_offset) as usize - ptr as usize }, - 28usize, + 22usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7910,7 +8469,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ); assert_eq!( unsafe { ::std::ptr::addr_of!((*ptr).slice_act_cr_qp_offset) as usize - ptr as usize }, - 29usize, + 23usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -7919,8 +8478,28 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) as usize - ptr as usize }, + 24usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(pShortTermRefPicSet) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPics) as usize - ptr as usize }, 32usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(pLongTermRefPics) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pWeightTable) as usize - ptr as usize }, + 40usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 5177b11..b7a86d3 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 5177b119bbdf463b7b909855a83230253c2d8b68 +Subproject commit b7a86d3b2bf8fbe73fcd40df9ec62a5966e9db89