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 | 8238 +++++++++++++++++++++++++----------- ash/src/vk/enums.rs | 218 + ash/src/vk/extensions.rs | 2868 +++++++++++-- ash/src/vk/native.rs | 2327 ++++++---- generator/Vulkan-Headers | 2 +- 10 files changed, 10598 insertions(+), 3715 deletions(-) diff --git a/Changelog.md b/Changelog.md index b9c25e6b8..104b14763 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 3cf318fa3..12c0892ce 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 c29d72070..e398790bd 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 88b35b2d6..bc3ccdec2 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 ba87c3d64..141718ebc 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 b1625abb1..c8481a89b 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,639 +39686,1505 @@ impl<'a> CuLaunchInfoNVX<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceShaderIntegerDotProductFeatures<'a> { +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub shader_integer_dot_product: Bool32, + 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 PhysicalDeviceShaderIntegerDotProductFeatures<'_> { +impl ::std::default::Default for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - shader_integer_dot_product: Bool32::default(), + 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 PhysicalDeviceShaderIntegerDotProductFeatures<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures<'_> {} -impl<'a> PhysicalDeviceShaderIntegerDotProductFeatures<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorBufferFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceDescriptorBufferFeaturesEXT<'a> { #[inline] - pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self { - self.shader_integer_dot_product = shader_integer_dot_product.into(); + 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 PhysicalDeviceShaderIntegerDotProductProperties<'a> { +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub integer_dot_product8_bit_unsigned_accelerated: Bool32, - pub integer_dot_product8_bit_signed_accelerated: Bool32, - pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32, - pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32, - pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32, - pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32, - pub integer_dot_product16_bit_unsigned_accelerated: Bool32, - pub integer_dot_product16_bit_signed_accelerated: Bool32, - pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32, - pub integer_dot_product32_bit_unsigned_accelerated: Bool32, - pub integer_dot_product32_bit_signed_accelerated: Bool32, - pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32, - pub integer_dot_product64_bit_unsigned_accelerated: Bool32, - pub integer_dot_product64_bit_signed_accelerated: Bool32, - pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: - Bool32, - pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32, - pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32, + 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 PhysicalDeviceShaderIntegerDotProductProperties<'_> { +impl ::std::default::Default for PhysicalDeviceDescriptorBufferPropertiesEXT<'_> { #[inline] fn default() -> Self { - Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , _marker : PhantomData , } + 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 PhysicalDeviceShaderIntegerDotProductProperties<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceShaderIntegerDotProductProperties<'_> -{ + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; } -impl<'a> PhysicalDeviceShaderIntegerDotProductProperties<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDescriptorBufferPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceDescriptorBufferPropertiesEXT<'a> { #[inline] - pub fn integer_dot_product8_bit_unsigned_accelerated( + pub fn combined_image_sampler_descriptor_single_array( mut self, - integer_dot_product8_bit_unsigned_accelerated: bool, + combined_image_sampler_descriptor_single_array: bool, ) -> Self { - self.integer_dot_product8_bit_unsigned_accelerated = - integer_dot_product8_bit_unsigned_accelerated.into(); + self.combined_image_sampler_descriptor_single_array = + combined_image_sampler_descriptor_single_array.into(); self } #[inline] - pub fn integer_dot_product8_bit_signed_accelerated( - mut self, - integer_dot_product8_bit_signed_accelerated: bool, - ) -> Self { - self.integer_dot_product8_bit_signed_accelerated = - integer_dot_product8_bit_signed_accelerated.into(); + pub fn bufferless_push_descriptors(mut self, bufferless_push_descriptors: bool) -> Self { + self.bufferless_push_descriptors = bufferless_push_descriptors.into(); self } #[inline] - pub fn integer_dot_product8_bit_mixed_signedness_accelerated( + pub fn allow_sampler_image_view_post_submit_creation( mut self, - integer_dot_product8_bit_mixed_signedness_accelerated: bool, + allow_sampler_image_view_post_submit_creation: bool, ) -> Self { - self.integer_dot_product8_bit_mixed_signedness_accelerated = - integer_dot_product8_bit_mixed_signedness_accelerated.into(); + self.allow_sampler_image_view_post_submit_creation = + allow_sampler_image_view_post_submit_creation.into(); self } #[inline] - pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( + pub fn descriptor_buffer_offset_alignment( mut self, - integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, + descriptor_buffer_offset_alignment: DeviceSize, ) -> Self { - self.integer_dot_product4x8_bit_packed_unsigned_accelerated = - integer_dot_product4x8_bit_packed_unsigned_accelerated.into(); + self.descriptor_buffer_offset_alignment = descriptor_buffer_offset_alignment; self } #[inline] - pub fn integer_dot_product4x8_bit_packed_signed_accelerated( - mut self, - integer_dot_product4x8_bit_packed_signed_accelerated: bool, - ) -> Self { - self.integer_dot_product4x8_bit_packed_signed_accelerated = - integer_dot_product4x8_bit_packed_signed_accelerated.into(); + 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 integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( + pub fn max_resource_descriptor_buffer_bindings( mut self, - integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, + max_resource_descriptor_buffer_bindings: u32, ) -> Self { - self.integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = - integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into(); + self.max_resource_descriptor_buffer_bindings = max_resource_descriptor_buffer_bindings; self } #[inline] - pub fn integer_dot_product16_bit_unsigned_accelerated( + pub fn max_sampler_descriptor_buffer_bindings( mut self, - integer_dot_product16_bit_unsigned_accelerated: bool, + max_sampler_descriptor_buffer_bindings: u32, ) -> Self { - self.integer_dot_product16_bit_unsigned_accelerated = - integer_dot_product16_bit_unsigned_accelerated.into(); + self.max_sampler_descriptor_buffer_bindings = max_sampler_descriptor_buffer_bindings; self } #[inline] - pub fn integer_dot_product16_bit_signed_accelerated( + pub fn max_embedded_immutable_sampler_bindings( mut self, - integer_dot_product16_bit_signed_accelerated: bool, + max_embedded_immutable_sampler_bindings: u32, ) -> Self { - self.integer_dot_product16_bit_signed_accelerated = - integer_dot_product16_bit_signed_accelerated.into(); + self.max_embedded_immutable_sampler_bindings = max_embedded_immutable_sampler_bindings; self } #[inline] - pub fn integer_dot_product16_bit_mixed_signedness_accelerated( - mut self, - integer_dot_product16_bit_mixed_signedness_accelerated: bool, - ) -> Self { - self.integer_dot_product16_bit_mixed_signedness_accelerated = - integer_dot_product16_bit_mixed_signedness_accelerated.into(); + 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 integer_dot_product32_bit_unsigned_accelerated( + pub fn buffer_capture_replay_descriptor_data_size( mut self, - integer_dot_product32_bit_unsigned_accelerated: bool, + buffer_capture_replay_descriptor_data_size: usize, ) -> Self { - self.integer_dot_product32_bit_unsigned_accelerated = - integer_dot_product32_bit_unsigned_accelerated.into(); + self.buffer_capture_replay_descriptor_data_size = + buffer_capture_replay_descriptor_data_size; self } #[inline] - pub fn integer_dot_product32_bit_signed_accelerated( + pub fn image_capture_replay_descriptor_data_size( mut self, - integer_dot_product32_bit_signed_accelerated: bool, + image_capture_replay_descriptor_data_size: usize, ) -> Self { - self.integer_dot_product32_bit_signed_accelerated = - integer_dot_product32_bit_signed_accelerated.into(); + self.image_capture_replay_descriptor_data_size = image_capture_replay_descriptor_data_size; self } #[inline] - pub fn integer_dot_product32_bit_mixed_signedness_accelerated( + pub fn image_view_capture_replay_descriptor_data_size( mut self, - integer_dot_product32_bit_mixed_signedness_accelerated: bool, + image_view_capture_replay_descriptor_data_size: usize, ) -> Self { - self.integer_dot_product32_bit_mixed_signedness_accelerated = - integer_dot_product32_bit_mixed_signedness_accelerated.into(); + self.image_view_capture_replay_descriptor_data_size = + image_view_capture_replay_descriptor_data_size; self } #[inline] - pub fn integer_dot_product64_bit_unsigned_accelerated( + pub fn sampler_capture_replay_descriptor_data_size( mut self, - integer_dot_product64_bit_unsigned_accelerated: bool, + sampler_capture_replay_descriptor_data_size: usize, ) -> Self { - self.integer_dot_product64_bit_unsigned_accelerated = - integer_dot_product64_bit_unsigned_accelerated.into(); + self.sampler_capture_replay_descriptor_data_size = + sampler_capture_replay_descriptor_data_size; self } #[inline] - pub fn integer_dot_product64_bit_signed_accelerated( + pub fn acceleration_structure_capture_replay_descriptor_data_size( mut self, - integer_dot_product64_bit_signed_accelerated: bool, + acceleration_structure_capture_replay_descriptor_data_size: usize, ) -> Self { - self.integer_dot_product64_bit_signed_accelerated = - integer_dot_product64_bit_signed_accelerated.into(); + self.acceleration_structure_capture_replay_descriptor_data_size = + acceleration_structure_capture_replay_descriptor_data_size; self } #[inline] - pub fn integer_dot_product64_bit_mixed_signedness_accelerated( - mut self, - integer_dot_product64_bit_mixed_signedness_accelerated: bool, - ) -> Self { - self.integer_dot_product64_bit_mixed_signedness_accelerated = - integer_dot_product64_bit_mixed_signedness_accelerated.into(); + pub fn sampler_descriptor_size(mut self, sampler_descriptor_size: usize) -> Self { + self.sampler_descriptor_size = sampler_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( + pub fn combined_image_sampler_descriptor_size( mut self, - integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, + combined_image_sampler_descriptor_size: usize, ) -> Self { - self.integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = - integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into(); + self.combined_image_sampler_descriptor_size = combined_image_sampler_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( - mut self, - integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, - ) -> Self { - self.integer_dot_product_accumulating_saturating8_bit_signed_accelerated = - integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into(); + 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 integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( + 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, - integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, + uniform_texel_buffer_descriptor_size: usize, ) -> Self { - self.integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = - integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into(); + self.uniform_texel_buffer_descriptor_size = uniform_texel_buffer_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( + pub fn robust_uniform_texel_buffer_descriptor_size( mut self, - integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, + robust_uniform_texel_buffer_descriptor_size: usize, ) -> Self { - self.integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = - integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into(); + self.robust_uniform_texel_buffer_descriptor_size = + robust_uniform_texel_buffer_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( + pub fn storage_texel_buffer_descriptor_size( mut self, - integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, + storage_texel_buffer_descriptor_size: usize, ) -> Self { - self.integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = - integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into(); + self.storage_texel_buffer_descriptor_size = storage_texel_buffer_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( + pub fn robust_storage_texel_buffer_descriptor_size( mut self, - integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, + robust_storage_texel_buffer_descriptor_size: usize, ) -> Self { - self . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; + self.robust_storage_texel_buffer_descriptor_size = + robust_storage_texel_buffer_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( + 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, - integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, + robust_uniform_buffer_descriptor_size: usize, ) -> Self { - self.integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = - integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into(); + self.robust_uniform_buffer_descriptor_size = robust_uniform_buffer_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( + 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, - integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, + robust_storage_buffer_descriptor_size: usize, ) -> Self { - self.integer_dot_product_accumulating_saturating16_bit_signed_accelerated = - integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into(); + self.robust_storage_buffer_descriptor_size = robust_storage_buffer_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( + pub fn input_attachment_descriptor_size( mut self, - integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, + input_attachment_descriptor_size: usize, ) -> Self { - self.integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = - integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into(); + self.input_attachment_descriptor_size = input_attachment_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( + pub fn acceleration_structure_descriptor_size( mut self, - integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, + acceleration_structure_descriptor_size: usize, ) -> Self { - self.integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = - integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into(); + self.acceleration_structure_descriptor_size = acceleration_structure_descriptor_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( + pub fn max_sampler_descriptor_buffer_range( mut self, - integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, + max_sampler_descriptor_buffer_range: DeviceSize, ) -> Self { - self.integer_dot_product_accumulating_saturating32_bit_signed_accelerated = - integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into(); + self.max_sampler_descriptor_buffer_range = max_sampler_descriptor_buffer_range; self } #[inline] - pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( + pub fn max_resource_descriptor_buffer_range( mut self, - integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, + max_resource_descriptor_buffer_range: DeviceSize, ) -> Self { - self.integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = - integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into(); + self.max_resource_descriptor_buffer_range = max_resource_descriptor_buffer_range; self } #[inline] - pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( + pub fn sampler_descriptor_buffer_address_space_size( mut self, - integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, + sampler_descriptor_buffer_address_space_size: DeviceSize, ) -> Self { - self.integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = - integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into(); + self.sampler_descriptor_buffer_address_space_size = + sampler_descriptor_buffer_address_space_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( + pub fn resource_descriptor_buffer_address_space_size( mut self, - integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, + resource_descriptor_buffer_address_space_size: DeviceSize, ) -> Self { - self.integer_dot_product_accumulating_saturating64_bit_signed_accelerated = - integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into(); + self.resource_descriptor_buffer_address_space_size = + resource_descriptor_buffer_address_space_size; self } #[inline] - pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( + pub fn descriptor_buffer_address_space_size( mut self, - integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, + descriptor_buffer_address_space_size: DeviceSize, ) -> Self { - self.integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = - integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into(); + 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 PhysicalDeviceDrmPropertiesEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub has_primary: Bool32, - pub has_render: Bool32, - pub primary_major: i64, - pub primary_minor: i64, - pub render_major: i64, - pub render_minor: i64, + pub combined_image_sampler_density_map_descriptor_size: usize, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT<'_> { +impl ::std::default::Default for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - has_primary: Bool32::default(), - has_render: Bool32::default(), - primary_major: i64::default(), - primary_minor: i64::default(), - render_major: i64::default(), - render_minor: i64::default(), + combined_image_sampler_density_map_descriptor_size: usize::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceDrmPropertiesEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT<'_> {} -impl<'a> PhysicalDeviceDrmPropertiesEXT<'a> { - #[inline] - pub fn has_primary(mut self, has_primary: bool) -> Self { - self.has_primary = has_primary.into(); - self - } +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'_> +{ +} +impl<'a> PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT<'a> { #[inline] - pub fn has_render(mut self, has_render: bool) -> Self { - self.has_render = has_render.into(); + 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] - pub fn primary_major(mut self, primary_major: i64) -> Self { - self.primary_major = primary_major; - self + 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 primary_minor(mut self, primary_minor: i64) -> Self { - self.primary_minor = primary_minor; + pub fn address(mut self, address: DeviceAddress) -> Self { + self.address = address; self } #[inline] - pub fn render_major(mut self, render_major: i64) -> Self { - self.render_major = render_major; + pub fn range(mut self, range: DeviceSize) -> Self { + self.range = range; self } #[inline] - pub fn render_minor(mut self, render_minor: i64) -> Self { - self.render_minor = render_minor; + 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 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { +#[doc = ""] +pub struct DescriptorBufferBindingInfoEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub fragment_shader_barycentric: Bool32, + pub address: DeviceAddress, + pub usage: BufferUsageFlags, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'_> { +impl ::std::default::Default for DescriptorBufferBindingInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - fragment_shader_barycentric: Bool32::default(), + address: DeviceAddress::default(), + usage: BufferUsageFlags::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'_> -{ +unsafe impl<'a> TaggedStructure for DescriptorBufferBindingInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_BUFFER_BINDING_INFO_EXT; } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'_> {} -impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { +pub unsafe trait ExtendsDescriptorBufferBindingInfoEXT {} +impl<'a> DescriptorBufferBindingInfoEXT<'a> { #[inline] - pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self { - self.fragment_shader_barycentric = fragment_shader_barycentric.into(); + 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 PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { +#[doc = ""] +pub struct DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub tri_strip_vertex_order_independent_of_provoking_vertex: Bool32, + pub buffer: Buffer, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'_> { +impl ::std::default::Default for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - tri_strip_vertex_order_independent_of_provoking_vertex: Bool32::default(), + buffer: Buffer::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { +unsafe impl<'a> TaggedStructure for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; + StructureType::DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT; } -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'_> +unsafe impl ExtendsDescriptorBufferBindingInfoEXT + for DescriptorBufferBindingPushDescriptorBufferHandleEXT<'_> { } -impl<'a> PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { +impl<'a> DescriptorBufferBindingPushDescriptorBufferHandleEXT<'a> { #[inline] - pub fn tri_strip_vertex_order_independent_of_provoking_vertex( - mut self, - tri_strip_vertex_order_independent_of_provoking_vertex: bool, - ) -> Self { - self.tri_strip_vertex_order_independent_of_provoking_vertex = - tri_strip_vertex_order_independent_of_provoking_vertex.into(); + 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 PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { +#[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: *mut c_void, - pub ray_tracing_motion_blur: Bool32, - pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32, + pub p_next: *const c_void, + pub ty: DescriptorType, + pub data: DescriptorDataEXT<'a>, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> { +#[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_mut(), - ray_tracing_motion_blur: Bool32::default(), - ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(), + p_next: ::std::ptr::null(), + ty: DescriptorType::default(), + data: DescriptorDataEXT::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; +unsafe impl<'a> TaggedStructure for DescriptorGetInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_GET_INFO_EXT; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {} -impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { +impl<'a> DescriptorGetInfoEXT<'a> { #[inline] - pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self { - self.ray_tracing_motion_blur = ray_tracing_motion_blur.into(); + pub fn ty(mut self, ty: DescriptorType) -> Self { + self.ty = ty; self } #[inline] - pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect( - mut self, - ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool, - ) -> Self { - self.ray_tracing_motion_blur_pipeline_trace_rays_indirect = - ray_tracing_motion_blur_pipeline_trace_rays_indirect.into(); + 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 AccelerationStructureGeometryMotionTrianglesDataNV<'a> { +#[doc = ""] +pub struct BufferCaptureDescriptorDataInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub vertex_data: DeviceOrHostAddressConstKHR, + pub buffer: Buffer, pub _marker: PhantomData<&'a ()>, } -#[cfg(feature = "debug")] -impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV<'_> { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("AccelerationStructureGeometryMotionTrianglesDataNV") - .field("s_type", &self.s_type) - .field("p_next", &self.p_next) - .field("vertex_data", &"union") - .finish() - } -} -impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV<'_> { +impl ::std::default::Default for BufferCaptureDescriptorDataInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - vertex_data: DeviceOrHostAddressConstKHR::default(), + buffer: Buffer::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for AccelerationStructureGeometryMotionTrianglesDataNV<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; -} -unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR - for AccelerationStructureGeometryMotionTrianglesDataNV<'_> -{ +unsafe impl<'a> TaggedStructure for BufferCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; } -impl<'a> AccelerationStructureGeometryMotionTrianglesDataNV<'a> { +impl<'a> BufferCaptureDescriptorDataInfoEXT<'a> { #[inline] - pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self { - self.vertex_data = vertex_data; + 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 AccelerationStructureMotionInfoNV<'a> { +#[doc = ""] +pub struct ImageCaptureDescriptorDataInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub max_instances: u32, - pub flags: AccelerationStructureMotionInfoFlagsNV, + pub image: Image, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureMotionInfoNV<'_> { +impl ::std::default::Default for ImageCaptureDescriptorDataInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - max_instances: u32::default(), - flags: AccelerationStructureMotionInfoFlagsNV::default(), + image: Image::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for AccelerationStructureMotionInfoNV<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV; +unsafe impl<'a> TaggedStructure for ImageCaptureDescriptorDataInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT; } -unsafe impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV<'_> {} -impl<'a> AccelerationStructureMotionInfoNV<'a> { - #[inline] - pub fn max_instances(mut self, max_instances: u32) -> Self { - self.max_instances = max_instances; - self - } +impl<'a> ImageCaptureDescriptorDataInfoEXT<'a> { #[inline] - pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self { - self.flags = flags; + pub fn image(mut self, image: Image) -> Self { + self.image = image; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone, Default)] -#[doc = ""] +#[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, + pub p_next: *mut c_void, + pub shader_integer_dot_product: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductFeatures<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_integer_dot_product: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderIntegerDotProductFeatures<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderIntegerDotProductFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderIntegerDotProductFeatures<'_> {} +impl<'a> PhysicalDeviceShaderIntegerDotProductFeatures<'a> { + #[inline] + pub fn shader_integer_dot_product(mut self, shader_integer_dot_product: bool) -> Self { + self.shader_integer_dot_product = shader_integer_dot_product.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceShaderIntegerDotProductProperties<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub integer_dot_product8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product8_bit_signed_accelerated: Bool32, + pub integer_dot_product8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: Bool32, + pub integer_dot_product16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product16_bit_signed_accelerated: Bool32, + pub integer_dot_product16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product32_bit_signed_accelerated: Bool32, + pub integer_dot_product32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product64_bit_signed_accelerated: Bool32, + pub integer_dot_product64_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated: + Bool32, + pub integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_signed_accelerated: Bool32, + pub integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceShaderIntegerDotProductProperties<'_> { + #[inline] + fn default() -> Self { + Self { s_type : Self :: STRUCTURE_TYPE , p_next : :: std :: ptr :: null_mut () , integer_dot_product8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product64_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_signed_accelerated : Bool32 :: default () , integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated : Bool32 :: default () , _marker : PhantomData , } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderIntegerDotProductProperties<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderIntegerDotProductProperties<'_> +{ +} +impl<'a> PhysicalDeviceShaderIntegerDotProductProperties<'a> { + #[inline] + pub fn integer_dot_product8_bit_unsigned_accelerated( + mut self, + integer_dot_product8_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product8_bit_unsigned_accelerated = + integer_dot_product8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_signed_accelerated( + mut self, + integer_dot_product8_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product8_bit_signed_accelerated = + integer_dot_product8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product8_bit_mixed_signedness_accelerated = + integer_dot_product8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product4x8_bit_packed_unsigned_accelerated = + integer_dot_product4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product4x8_bit_packed_signed_accelerated = + integer_dot_product4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product4x8_bit_packed_mixed_signedness_accelerated = + integer_dot_product4x8_bit_packed_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_unsigned_accelerated( + mut self, + integer_dot_product16_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product16_bit_unsigned_accelerated = + integer_dot_product16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_signed_accelerated( + mut self, + integer_dot_product16_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product16_bit_signed_accelerated = + integer_dot_product16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product16_bit_mixed_signedness_accelerated = + integer_dot_product16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_unsigned_accelerated( + mut self, + integer_dot_product32_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product32_bit_unsigned_accelerated = + integer_dot_product32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_signed_accelerated( + mut self, + integer_dot_product32_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product32_bit_signed_accelerated = + integer_dot_product32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product32_bit_mixed_signedness_accelerated = + integer_dot_product32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_unsigned_accelerated( + mut self, + integer_dot_product64_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product64_bit_unsigned_accelerated = + integer_dot_product64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_signed_accelerated( + mut self, + integer_dot_product64_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product64_bit_signed_accelerated = + integer_dot_product64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product64_bit_mixed_signedness_accelerated = + integer_dot_product64_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating8_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating8_bit_signed_accelerated = + integer_dot_product_accumulating_saturating8_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating8_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated = + integer_dot_product_accumulating_saturating4x8_bit_packed_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated : bool, + ) -> Self { + self . integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated = integer_dot_product_accumulating_saturating4x8_bit_packed_mixed_signedness_accelerated . into () ; + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating16_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating16_bit_signed_accelerated = + integer_dot_product_accumulating_saturating16_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating16_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating32_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating32_bit_signed_accelerated = + integer_dot_product_accumulating_saturating32_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating32_bit_mixed_signedness_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated = + integer_dot_product_accumulating_saturating64_bit_unsigned_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_signed_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_signed_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating64_bit_signed_accelerated = + integer_dot_product_accumulating_saturating64_bit_signed_accelerated.into(); + self + } + #[inline] + pub fn integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated( + mut self, + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated: bool, + ) -> Self { + self.integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated = + integer_dot_product_accumulating_saturating64_bit_mixed_signedness_accelerated.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDrmPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub has_primary: Bool32, + pub has_render: Bool32, + pub primary_major: i64, + pub primary_minor: i64, + pub render_major: i64, + pub render_minor: i64, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDrmPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + has_primary: Bool32::default(), + has_render: Bool32::default(), + primary_major: i64::default(), + primary_minor: i64::default(), + render_major: i64::default(), + render_minor: i64::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDrmPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceDrmPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceDrmPropertiesEXT<'a> { + #[inline] + pub fn has_primary(mut self, has_primary: bool) -> Self { + self.has_primary = has_primary.into(); + self + } + #[inline] + pub fn has_render(mut self, has_render: bool) -> Self { + self.has_render = has_render.into(); + self + } + #[inline] + pub fn primary_major(mut self, primary_major: i64) -> Self { + self.primary_major = primary_major; + self + } + #[inline] + pub fn primary_minor(mut self, primary_minor: i64) -> Self { + self.primary_minor = primary_minor; + self + } + #[inline] + pub fn render_major(mut self, render_major: i64) -> Self { + self.render_major = render_major; + self + } + #[inline] + pub fn render_minor(mut self, render_minor: i64) -> Self { + self.render_minor = render_minor; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub fragment_shader_barycentric: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + fragment_shader_barycentric: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'_> {} +impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesKHR<'a> { + #[inline] + pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self { + self.fragment_shader_barycentric = fragment_shader_barycentric.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub tri_strip_vertex_order_independent_of_provoking_vertex: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + tri_strip_vertex_order_independent_of_provoking_vertex: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'_> +{ +} +impl<'a> PhysicalDeviceFragmentShaderBarycentricPropertiesKHR<'a> { + #[inline] + pub fn tri_strip_vertex_order_independent_of_provoking_vertex( + mut self, + tri_strip_vertex_order_independent_of_provoking_vertex: bool, + ) -> Self { + self.tri_strip_vertex_order_independent_of_provoking_vertex = + tri_strip_vertex_order_independent_of_provoking_vertex.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ray_tracing_motion_blur: Bool32, + pub ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ray_tracing_motion_blur: Bool32::default(), + ray_tracing_motion_blur_pipeline_trace_rays_indirect: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingMotionBlurFeaturesNV<'_> {} +impl<'a> PhysicalDeviceRayTracingMotionBlurFeaturesNV<'a> { + #[inline] + pub fn ray_tracing_motion_blur(mut self, ray_tracing_motion_blur: bool) -> Self { + self.ray_tracing_motion_blur = ray_tracing_motion_blur.into(); + self + } + #[inline] + pub fn ray_tracing_motion_blur_pipeline_trace_rays_indirect( + mut self, + ray_tracing_motion_blur_pipeline_trace_rays_indirect: bool, + ) -> Self { + self.ray_tracing_motion_blur_pipeline_trace_rays_indirect = + ray_tracing_motion_blur_pipeline_trace_rays_indirect.into(); + self + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureGeometryMotionTrianglesDataNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub vertex_data: DeviceOrHostAddressConstKHR, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureGeometryMotionTrianglesDataNV<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureGeometryMotionTrianglesDataNV") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("vertex_data", &"union") + .finish() + } +} +impl ::std::default::Default for AccelerationStructureGeometryMotionTrianglesDataNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + vertex_data: DeviceOrHostAddressConstKHR::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for AccelerationStructureGeometryMotionTrianglesDataNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV; +} +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureGeometryMotionTrianglesDataNV<'_> +{ +} +impl<'a> AccelerationStructureGeometryMotionTrianglesDataNV<'a> { + #[inline] + pub fn vertex_data(mut self, vertex_data: DeviceOrHostAddressConstKHR) -> Self { + self.vertex_data = vertex_data; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureMotionInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub max_instances: u32, + pub flags: AccelerationStructureMotionInfoFlagsNV, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for AccelerationStructureMotionInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + max_instances: u32::default(), + flags: AccelerationStructureMotionInfoFlagsNV::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for AccelerationStructureMotionInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::ACCELERATION_STRUCTURE_MOTION_INFO_NV; +} +unsafe impl ExtendsAccelerationStructureCreateInfoKHR for AccelerationStructureMotionInfoNV<'_> {} +impl<'a> AccelerationStructureMotionInfoNV<'a> { + #[inline] + pub fn max_instances(mut self, max_instances: u32) -> Self { + self.max_instances = max_instances; + self + } + #[inline] + pub fn flags(mut self, flags: AccelerationStructureMotionInfoFlagsNV) -> Self { + self.flags = flags; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] pub struct SRTDataNV { pub sx: f32, pub a: f32, @@ -39519,3640 +41203,5290 @@ pub struct SRTDataNV { pub ty: f32, pub tz: f32, } -impl SRTDataNV { +impl SRTDataNV { + #[inline] + pub fn sx(mut self, sx: f32) -> Self { + self.sx = sx; + self + } + #[inline] + pub fn a(mut self, a: f32) -> Self { + self.a = a; + self + } + #[inline] + pub fn b(mut self, b: f32) -> Self { + self.b = b; + self + } + #[inline] + pub fn pvx(mut self, pvx: f32) -> Self { + self.pvx = pvx; + self + } + #[inline] + pub fn sy(mut self, sy: f32) -> Self { + self.sy = sy; + self + } + #[inline] + pub fn c(mut self, c: f32) -> Self { + self.c = c; + self + } + #[inline] + pub fn pvy(mut self, pvy: f32) -> Self { + self.pvy = pvy; + self + } + #[inline] + pub fn sz(mut self, sz: f32) -> Self { + self.sz = sz; + self + } + #[inline] + pub fn pvz(mut self, pvz: f32) -> Self { + self.pvz = pvz; + self + } + #[inline] + pub fn qx(mut self, qx: f32) -> Self { + self.qx = qx; + self + } + #[inline] + pub fn qy(mut self, qy: f32) -> Self { + self.qy = qy; + self + } + #[inline] + pub fn qz(mut self, qz: f32) -> Self { + self.qz = qz; + self + } + #[inline] + pub fn qw(mut self, qw: f32) -> Self { + self.qw = qw; + self + } + #[inline] + pub fn tx(mut self, tx: f32) -> Self { + self.tx = tx; + self + } + #[inline] + pub fn ty(mut self, ty: f32) -> Self { + self.ty = ty; + self + } + #[inline] + pub fn tz(mut self, tz: f32) -> Self { + self.tz = tz; + self + } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureSRTMotionInstanceNV { + pub transform_t0: SRTDataNV, + pub transform_t1: SRTDataNV, + #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] + pub instance_custom_index_and_mask: Packed24_8, + #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] + pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AccelerationStructureMatrixMotionInstanceNV { + pub transform_t0: TransformMatrixKHR, + pub transform_t1: TransformMatrixKHR, + #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] + pub instance_custom_index_and_mask: Packed24_8, + #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] + pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, + pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub union AccelerationStructureMotionInstanceDataNV { + pub static_instance: AccelerationStructureInstanceKHR, + pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV, + pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV, +} +impl ::std::default::Default for AccelerationStructureMotionInstanceDataNV { + #[inline] + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } +} +#[repr(C)] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct AccelerationStructureMotionInstanceNV { + pub ty: AccelerationStructureMotionInstanceTypeNV, + pub flags: AccelerationStructureMotionInstanceFlagsNV, + pub data: AccelerationStructureMotionInstanceDataNV, +} +#[cfg(feature = "debug")] +impl fmt::Debug for AccelerationStructureMotionInstanceNV { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("AccelerationStructureMotionInstanceNV") + .field("ty", &self.ty) + .field("flags", &self.flags) + .field("data", &"union") + .finish() + } +} +impl AccelerationStructureMotionInstanceNV { + #[inline] + pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self { + self.ty = ty; + self + } + #[inline] + pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self { + self.data = data; + self + } +} +#[doc = ""] +pub type RemoteAddressNV = c_void; +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MemoryGetRemoteAddressInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub handle_type: ExternalMemoryHandleTypeFlags, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for MemoryGetRemoteAddressInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + handle_type: ExternalMemoryHandleTypeFlags::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for MemoryGetRemoteAddressInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV; +} +impl<'a> MemoryGetRemoteAddressInfoNV<'a> { + #[inline] + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.memory = memory; + self + } + #[inline] + pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { + self.handle_type = handle_type; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImportMemoryBufferCollectionFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImportMemoryBufferCollectionFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; +} +unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA<'_> {} +impl<'a> ImportMemoryBufferCollectionFUCHSIA<'a> { + #[inline] + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.collection = collection; + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionImageCreateInfoFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BufferCollectionImageCreateInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; +} +unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA<'_> {} +impl<'a> BufferCollectionImageCreateInfoFUCHSIA<'a> { + #[inline] + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.collection = collection; + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionBufferCreateInfoFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection: BufferCollectionFUCHSIA, + pub index: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection: BufferCollectionFUCHSIA::default(), + index: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BufferCollectionBufferCreateInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; +} +unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA<'_> {} +impl<'a> BufferCollectionBufferCreateInfoFUCHSIA<'a> { + #[inline] + pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { + self.collection = collection; + self + } + #[inline] + pub fn index(mut self, index: u32) -> Self { + self.index = index; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionCreateInfoFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub collection_token: zx_handle_t, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + collection_token: zx_handle_t::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BufferCollectionCreateInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; +} +impl<'a> BufferCollectionCreateInfoFUCHSIA<'a> { + #[inline] + pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self { + self.collection_token = collection_token; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionPropertiesFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub memory_type_bits: u32, + pub buffer_count: u32, + pub create_info_index: u32, + pub sysmem_pixel_format: u64, + pub format_features: FormatFeatureFlags, + pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA<'a>, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + memory_type_bits: u32::default(), + buffer_count: u32::default(), + create_info_index: u32::default(), + sysmem_pixel_format: u64::default(), + format_features: FormatFeatureFlags::default(), + sysmem_color_space_index: SysmemColorSpaceFUCHSIA::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BufferCollectionPropertiesFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA; +} +impl<'a> BufferCollectionPropertiesFUCHSIA<'a> { + #[inline] + pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { + self.memory_type_bits = memory_type_bits; + self + } + #[inline] + pub fn buffer_count(mut self, buffer_count: u32) -> Self { + self.buffer_count = buffer_count; + self + } + #[inline] + pub fn create_info_index(mut self, create_info_index: u32) -> Self { + self.create_info_index = create_info_index; + self + } + #[inline] + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.sysmem_pixel_format = sysmem_pixel_format; + self + } + #[inline] + pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { + self.format_features = format_features; + self + } + #[inline] + pub fn sysmem_color_space_index( + mut self, + sysmem_color_space_index: SysmemColorSpaceFUCHSIA<'a>, + ) -> Self { + self.sysmem_color_space_index = sysmem_color_space_index; + self + } + #[inline] + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + #[inline] + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + #[inline] + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + #[inline] + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + #[inline] + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + self.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferConstraintsInfoFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub create_info: BufferCreateInfo<'a>, + pub required_format_features: FormatFeatureFlags, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BufferConstraintsInfoFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + create_info: BufferCreateInfo::default(), + required_format_features: FormatFeatureFlags::default(), + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BufferConstraintsInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA; +} +impl<'a> BufferConstraintsInfoFUCHSIA<'a> { + #[inline] + pub fn create_info(mut self, create_info: BufferCreateInfo<'a>) -> Self { + self.create_info = create_info; + self + } + #[inline] + pub fn required_format_features( + mut self, + required_format_features: FormatFeatureFlags, + ) -> Self { + self.required_format_features = required_format_features; + self + } + #[inline] + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, + ) -> Self { + self.buffer_collection_constraints = buffer_collection_constraints; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SysmemColorSpaceFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub color_space: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SysmemColorSpaceFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + color_space: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SysmemColorSpaceFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SYSMEM_COLOR_SPACE_FUCHSIA; +} +impl<'a> SysmemColorSpaceFUCHSIA<'a> { + #[inline] + pub fn color_space(mut self, color_space: u32) -> Self { + self.color_space = color_space; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageFormatConstraintsInfoFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_create_info: ImageCreateInfo<'a>, + pub required_format_features: FormatFeatureFlags, + pub flags: ImageFormatConstraintsFlagsFUCHSIA, + pub sysmem_pixel_format: u64, + pub color_space_count: u32, + pub p_color_spaces: *const SysmemColorSpaceFUCHSIA<'a>, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_create_info: ImageCreateInfo::default(), + required_format_features: FormatFeatureFlags::default(), + flags: ImageFormatConstraintsFlagsFUCHSIA::default(), + sysmem_pixel_format: u64::default(), + color_space_count: u32::default(), + p_color_spaces: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImageFormatConstraintsInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; +} +impl<'a> ImageFormatConstraintsInfoFUCHSIA<'a> { + #[inline] + pub fn image_create_info(mut self, image_create_info: ImageCreateInfo<'a>) -> Self { + self.image_create_info = image_create_info; + self + } + #[inline] + pub fn required_format_features( + mut self, + required_format_features: FormatFeatureFlags, + ) -> Self { + self.required_format_features = required_format_features; + self + } + #[inline] + pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { + self.sysmem_pixel_format = sysmem_pixel_format; + self + } + #[inline] + pub fn color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self { + self.color_space_count = color_spaces.len() as _; + self.p_color_spaces = color_spaces.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct ImageConstraintsInfoFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub format_constraints_count: u32, + pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA<'a>, + pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, + pub flags: ImageConstraintsInfoFlagsFUCHSIA, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImageConstraintsInfoFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + format_constraints_count: u32::default(), + p_format_constraints: ::std::ptr::null(), + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + flags: ImageConstraintsInfoFlagsFUCHSIA::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImageConstraintsInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA; +} +impl<'a> ImageConstraintsInfoFUCHSIA<'a> { + #[inline] + pub fn format_constraints( + mut self, + format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA], + ) -> Self { + self.format_constraints_count = format_constraints.len() as _; + self.p_format_constraints = format_constraints.as_ptr(); + self + } + #[inline] + pub fn buffer_collection_constraints( + mut self, + buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, + ) -> Self { + self.buffer_collection_constraints = buffer_collection_constraints; + self + } + #[inline] + pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self { + self.flags = flags; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BufferCollectionConstraintsInfoFUCHSIA<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_buffer_count: u32, + pub max_buffer_count: u32, + pub min_buffer_count_for_camping: u32, + pub min_buffer_count_for_dedicated_slack: u32, + pub min_buffer_count_for_shared_slack: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + min_buffer_count: u32::default(), + max_buffer_count: u32::default(), + min_buffer_count_for_camping: u32::default(), + min_buffer_count_for_dedicated_slack: u32::default(), + min_buffer_count_for_shared_slack: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BufferCollectionConstraintsInfoFUCHSIA<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; +} +impl<'a> BufferCollectionConstraintsInfoFUCHSIA<'a> { + #[inline] + pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self { + self.min_buffer_count = min_buffer_count; + self + } + #[inline] + pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self { + self.max_buffer_count = max_buffer_count; + self + } + #[inline] + pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self { + self.min_buffer_count_for_camping = min_buffer_count_for_camping; + self + } + #[inline] + pub fn min_buffer_count_for_dedicated_slack( + mut self, + min_buffer_count_for_dedicated_slack: u32, + ) -> Self { + self.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack; + self + } + #[inline] + pub fn min_buffer_count_for_shared_slack( + mut self, + min_buffer_count_for_shared_slack: u32, + ) -> Self { + self.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format_rgba10x6_without_y_cb_cr_sampler: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { + #[inline] + pub fn format_rgba10x6_without_y_cb_cr_sampler( + mut self, + format_rgba10x6_without_y_cb_cr_sampler: bool, + ) -> Self { + self.format_rgba10x6_without_y_cb_cr_sampler = + format_rgba10x6_without_y_cb_cr_sampler.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct FormatProperties3<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub linear_tiling_features: FormatFeatureFlags2, + pub optimal_tiling_features: FormatFeatureFlags2, + pub buffer_features: FormatFeatureFlags2, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for FormatProperties3<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + linear_tiling_features: FormatFeatureFlags2::default(), + optimal_tiling_features: FormatFeatureFlags2::default(), + buffer_features: FormatFeatureFlags2::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for FormatProperties3<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_3; +} +unsafe impl ExtendsFormatProperties2 for FormatProperties3<'_> {} +impl<'a> FormatProperties3<'a> { #[inline] - pub fn sx(mut self, sx: f32) -> Self { - self.sx = sx; + pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self { + self.linear_tiling_features = linear_tiling_features; + self + } + #[inline] + pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self { + self.optimal_tiling_features = optimal_tiling_features; + self + } + #[inline] + pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self { + self.buffer_features = buffer_features; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DrmFormatModifierPropertiesList2EXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub drm_format_modifier_count: u32, + pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + drm_format_modifier_count: u32::default(), + p_drm_format_modifier_properties: ::std::ptr::null_mut(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DrmFormatModifierPropertiesList2EXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT; +} +unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT<'_> {} +impl<'a> DrmFormatModifierPropertiesList2EXT<'a> { + #[inline] + pub fn drm_format_modifier_properties( + mut self, + drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT], + ) -> Self { + self.drm_format_modifier_count = drm_format_modifier_properties.len() as _; + self.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone, Default)] +#[doc = ""] +pub struct DrmFormatModifierProperties2EXT { + pub drm_format_modifier: u64, + pub drm_format_modifier_plane_count: u32, + pub drm_format_modifier_tiling_features: FormatFeatureFlags2, +} +impl DrmFormatModifierProperties2EXT { + #[inline] + pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { + self.drm_format_modifier = drm_format_modifier; + self + } + #[inline] + pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self { + self.drm_format_modifier_plane_count = drm_format_modifier_plane_count; + self + } + #[inline] + pub fn drm_format_modifier_tiling_features( + mut self, + drm_format_modifier_tiling_features: FormatFeatureFlags2, + ) -> Self { + self.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferFormatProperties2ANDROID<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub format: Format, + pub external_format: u64, + pub format_features: FormatFeatureFlags2, + pub sampler_ycbcr_conversion_components: ComponentMapping, + pub suggested_ycbcr_model: SamplerYcbcrModelConversion, + pub suggested_ycbcr_range: SamplerYcbcrRange, + pub suggested_x_chroma_offset: ChromaLocation, + pub suggested_y_chroma_offset: ChromaLocation, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + format: Format::default(), + external_format: u64::default(), + format_features: FormatFeatureFlags2::default(), + sampler_ycbcr_conversion_components: ComponentMapping::default(), + suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), + suggested_ycbcr_range: SamplerYcbcrRange::default(), + suggested_x_chroma_offset: ChromaLocation::default(), + suggested_y_chroma_offset: ChromaLocation::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for AndroidHardwareBufferFormatProperties2ANDROID<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatProperties2ANDROID<'_> +{ +} +impl<'a> AndroidHardwareBufferFormatProperties2ANDROID<'a> { + #[inline] + pub fn format(mut self, format: Format) -> Self { + self.format = format; + self + } + #[inline] + pub fn external_format(mut self, external_format: u64) -> Self { + self.external_format = external_format; + self + } + #[inline] + pub fn format_features(mut self, format_features: FormatFeatureFlags2) -> Self { + self.format_features = format_features; + self + } + #[inline] + pub fn sampler_ycbcr_conversion_components( + mut self, + sampler_ycbcr_conversion_components: ComponentMapping, + ) -> Self { + self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self + } + #[inline] + pub fn suggested_ycbcr_model( + mut self, + suggested_ycbcr_model: SamplerYcbcrModelConversion, + ) -> Self { + self.suggested_ycbcr_model = suggested_ycbcr_model; + self + } + #[inline] + pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { + self.suggested_ycbcr_range = suggested_ycbcr_range; + self + } + #[inline] + pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { + self.suggested_x_chroma_offset = suggested_x_chroma_offset; + self + } + #[inline] + pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { + self.suggested_y_chroma_offset = suggested_y_chroma_offset; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PipelineRenderingCreateInfo<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachment_formats: *const Format, + pub depth_attachment_format: Format, + pub stencil_attachment_format: Format, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PipelineRenderingCreateInfo<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachment_formats: ::std::ptr::null(), + depth_attachment_format: Format::default(), + stencil_attachment_format: Format::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PipelineRenderingCreateInfo<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RENDERING_CREATE_INFO; +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo<'_> {} +impl<'a> PipelineRenderingCreateInfo<'a> { + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.view_mask = view_mask; + self + } + #[inline] + pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { + self.color_attachment_count = color_attachment_formats.len() as _; + self.p_color_attachment_formats = color_attachment_formats.as_ptr(); + self + } + #[inline] + pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { + self.depth_attachment_format = depth_attachment_format; + self + } + #[inline] + pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { + self.stencil_attachment_format = stencil_attachment_format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingInfo<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderingFlags, + pub render_area: Rect2D, + pub layer_count: u32, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachments: *const RenderingAttachmentInfo<'a>, + pub p_depth_attachment: *const RenderingAttachmentInfo<'a>, + pub p_stencil_attachment: *const RenderingAttachmentInfo<'a>, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for RenderingInfo<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderingFlags::default(), + render_area: Rect2D::default(), + layer_count: u32::default(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachments: ::std::ptr::null(), + p_depth_attachment: ::std::ptr::null(), + p_stencil_attachment: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for RenderingInfo<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_INFO; +} +pub unsafe trait ExtendsRenderingInfo {} +impl<'a> RenderingInfo<'a> { + #[inline] + pub fn flags(mut self, flags: RenderingFlags) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn render_area(mut self, render_area: Rect2D) -> Self { + self.render_area = render_area; + self + } + #[inline] + pub fn layer_count(mut self, layer_count: u32) -> Self { + self.layer_count = layer_count; + self + } + #[inline] + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.view_mask = view_mask; + self + } + #[inline] + pub fn color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self { + self.color_attachment_count = color_attachments.len() as _; + self.p_color_attachments = color_attachments.as_ptr(); + self + } + #[inline] + pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo<'a>) -> Self { + self.p_depth_attachment = depth_attachment; + self + } + #[inline] + pub fn stencil_attachment( + mut self, + stencil_attachment: &'a RenderingAttachmentInfo<'a>, + ) -> Self { + self.p_stencil_attachment = stencil_attachment; + self + } + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `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)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingAttachmentInfo<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, + pub resolve_mode: ResolveModeFlags, + pub resolve_image_view: ImageView, + pub resolve_image_layout: ImageLayout, + pub load_op: AttachmentLoadOp, + pub store_op: AttachmentStoreOp, + pub clear_value: ClearValue, + pub _marker: PhantomData<&'a ()>, +} +#[cfg(feature = "debug")] +impl fmt::Debug for RenderingAttachmentInfo<'_> { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderingAttachmentInfo") + .field("s_type", &self.s_type) + .field("p_next", &self.p_next) + .field("image_view", &self.image_view) + .field("image_layout", &self.image_layout) + .field("resolve_mode", &self.resolve_mode) + .field("resolve_image_view", &self.resolve_image_view) + .field("resolve_image_layout", &self.resolve_image_layout) + .field("load_op", &self.load_op) + .field("store_op", &self.store_op) + .field("clear_value", &"union") + .finish() + } +} +impl ::std::default::Default for RenderingAttachmentInfo<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + resolve_mode: ResolveModeFlags::default(), + resolve_image_view: ImageView::default(), + resolve_image_layout: ImageLayout::default(), + load_op: AttachmentLoadOp::default(), + store_op: AttachmentStoreOp::default(), + clear_value: ClearValue::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for RenderingAttachmentInfo<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_ATTACHMENT_INFO; +} +impl<'a> RenderingAttachmentInfo<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.image_layout = image_layout; + self + } + #[inline] + pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self { + self.resolve_mode = resolve_mode; + self + } + #[inline] + pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self { + self.resolve_image_view = resolve_image_view; + self + } + #[inline] + pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self { + self.resolve_image_layout = resolve_image_layout; + self + } + #[inline] + pub fn load_op(mut self, load_op: AttachmentLoadOp) -> Self { + self.load_op = load_op; + self + } + #[inline] + pub fn store_op(mut self, store_op: AttachmentStoreOp) -> Self { + self.store_op = store_op; + self + } + #[inline] + pub fn clear_value(mut self, clear_value: ClearValue) -> Self { + self.clear_value = clear_value; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingFragmentShadingRateAttachmentInfoKHR<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, + pub shading_rate_attachment_texel_size: Extent2D, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for RenderingFragmentShadingRateAttachmentInfoKHR<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + shading_rate_attachment_texel_size: Extent2D::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for RenderingFragmentShadingRateAttachmentInfoKHR<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; +} +unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR<'_> {} +impl<'a> RenderingFragmentShadingRateAttachmentInfoKHR<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.image_view = image_view; + self + } + #[inline] + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.image_layout = image_layout; + self + } + #[inline] + pub fn shading_rate_attachment_texel_size( + mut self, + shading_rate_attachment_texel_size: Extent2D, + ) -> Self { + self.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderingFragmentDensityMapAttachmentInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub image_view: ImageView, + pub image_layout: ImageLayout, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + image_view: ImageView::default(), + image_layout: ImageLayout::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for RenderingFragmentDensityMapAttachmentInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; +} +unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT<'_> {} +impl<'a> RenderingFragmentDensityMapAttachmentInfoEXT<'a> { + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.image_view = image_view; self } #[inline] - pub fn a(mut self, a: f32) -> Self { - self.a = a; + pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { + self.image_layout = image_layout; self } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDynamicRenderingFeatures<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub dynamic_rendering: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures<'_> { #[inline] - pub fn b(mut self, b: f32) -> Self { - self.b = b; - self + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + dynamic_rendering: Bool32::default(), + _marker: PhantomData, + } } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDynamicRenderingFeatures<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures<'_> {} +impl<'a> PhysicalDeviceDynamicRenderingFeatures<'a> { #[inline] - pub fn pvx(mut self, pvx: f32) -> Self { - self.pvx = pvx; + pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { + self.dynamic_rendering = dynamic_rendering.into(); self } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CommandBufferInheritanceRenderingInfo<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: RenderingFlags, + pub view_mask: u32, + pub color_attachment_count: u32, + pub p_color_attachment_formats: *const Format, + pub depth_attachment_format: Format, + pub stencil_attachment_format: Format, + pub rasterization_samples: SampleCountFlags, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for CommandBufferInheritanceRenderingInfo<'_> { #[inline] - pub fn sy(mut self, sy: f32) -> Self { - self.sy = sy; - self + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: RenderingFlags::default(), + view_mask: u32::default(), + color_attachment_count: u32::default(), + p_color_attachment_formats: ::std::ptr::null(), + depth_attachment_format: Format::default(), + stencil_attachment_format: Format::default(), + rasterization_samples: SampleCountFlags::default(), + _marker: PhantomData, + } } +} +unsafe impl<'a> TaggedStructure for CommandBufferInheritanceRenderingInfo<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; +} +unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo<'_> {} +impl<'a> CommandBufferInheritanceRenderingInfo<'a> { #[inline] - pub fn c(mut self, c: f32) -> Self { - self.c = c; + pub fn flags(mut self, flags: RenderingFlags) -> Self { + self.flags = flags; self } #[inline] - pub fn pvy(mut self, pvy: f32) -> Self { - self.pvy = pvy; + pub fn view_mask(mut self, view_mask: u32) -> Self { + self.view_mask = view_mask; self } #[inline] - pub fn sz(mut self, sz: f32) -> Self { - self.sz = sz; + pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { + self.color_attachment_count = color_attachment_formats.len() as _; + self.p_color_attachment_formats = color_attachment_formats.as_ptr(); self } #[inline] - pub fn pvz(mut self, pvz: f32) -> Self { - self.pvz = pvz; + pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { + self.depth_attachment_format = depth_attachment_format; self } #[inline] - pub fn qx(mut self, qx: f32) -> Self { - self.qx = qx; + pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { + self.stencil_attachment_format = stencil_attachment_format; self } #[inline] - pub fn qy(mut self, qy: f32) -> Self { - self.qy = qy; + pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { + self.rasterization_samples = rasterization_samples; self } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AttachmentSampleCountInfoAMD<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub color_attachment_count: u32, + pub p_color_attachment_samples: *const SampleCountFlags, + pub depth_stencil_attachment_samples: SampleCountFlags, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for AttachmentSampleCountInfoAMD<'_> { #[inline] - pub fn qz(mut self, qz: f32) -> Self { - self.qz = qz; - self + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + color_attachment_count: u32::default(), + p_color_attachment_samples: ::std::ptr::null(), + depth_stencil_attachment_samples: SampleCountFlags::default(), + _marker: PhantomData, + } } +} +unsafe impl<'a> TaggedStructure for AttachmentSampleCountInfoAMD<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD; +} +unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD<'_> {} +impl<'a> AttachmentSampleCountInfoAMD<'a> { #[inline] - pub fn qw(mut self, qw: f32) -> Self { - self.qw = qw; + pub fn color_attachment_samples( + mut self, + color_attachment_samples: &'a [SampleCountFlags], + ) -> Self { + self.color_attachment_count = color_attachment_samples.len() as _; + self.p_color_attachment_samples = color_attachment_samples.as_ptr(); self } #[inline] - pub fn tx(mut self, tx: f32) -> Self { - self.tx = tx; + pub fn depth_stencil_attachment_samples( + mut self, + depth_stencil_attachment_samples: SampleCountFlags, + ) -> Self { + self.depth_stencil_attachment_samples = depth_stencil_attachment_samples; self } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct MultiviewPerViewAttributesInfoNVX<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub per_view_attributes: Bool32, + pub per_view_attributes_position_x_only: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + per_view_attributes: Bool32::default(), + per_view_attributes_position_x_only: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for MultiviewPerViewAttributesInfoNVX<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; +} +unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX<'_> {} +unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX<'_> {} +impl<'a> MultiviewPerViewAttributesInfoNVX<'a> { #[inline] - pub fn ty(mut self, ty: f32) -> Self { - self.ty = ty; + pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self { + self.per_view_attributes = per_view_attributes.into(); self } #[inline] - pub fn tz(mut self, tz: f32) -> Self { - self.tz = tz; + pub fn per_view_attributes_position_x_only( + mut self, + per_view_attributes_position_x_only: bool, + ) -> Self { + self.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into(); self } } #[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct AccelerationStructureSRTMotionInstanceNV { - pub transform_t0: SRTDataNV, - pub transform_t1: SRTDataNV, - #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] - pub instance_custom_index_and_mask: Packed24_8, - #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] - pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, - pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +#[doc = ""] +pub struct PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub min_lod: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + min_lod: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { + #[inline] + pub fn min_lod(mut self, min_lod: bool) -> Self { + self.min_lod = min_lod.into(); + self + } } #[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct AccelerationStructureMatrixMotionInstanceNV { - pub transform_t0: TransformMatrixKHR, - pub transform_t1: TransformMatrixKHR, - #[doc = r" Use [`Packed24_8::new(instance_custom_index, mask)`][Packed24_8::new()] to construct this field"] - pub instance_custom_index_and_mask: Packed24_8, - #[doc = r" Use [`Packed24_8::new(instance_shader_binding_table_record_offset, flags)`][Packed24_8::new()] to construct this field"] - pub instance_shader_binding_table_record_offset_and_flags: Packed24_8, - pub acceleration_structure_reference: AccelerationStructureReferenceKHR, +#[doc = ""] +pub struct ImageViewMinLodCreateInfoEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub min_lod: f32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for ImageViewMinLodCreateInfoEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + min_lod: f32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for ImageViewMinLodCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; +} +unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT<'_> {} +impl<'a> ImageViewMinLodCreateInfoEXT<'a> { + #[inline] + pub fn min_lod(mut self, min_lod: f32) -> Self { + self.min_lod = min_lod; + self + } } #[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub union AccelerationStructureMotionInstanceDataNV { - pub static_instance: AccelerationStructureInstanceKHR, - pub matrix_motion_instance: AccelerationStructureMatrixMotionInstanceNV, - pub srt_motion_instance: AccelerationStructureSRTMotionInstanceNV, +#[doc = ""] +pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub rasterization_order_color_attachment_access: Bool32, + pub rasterization_order_depth_attachment_access: Bool32, + pub rasterization_order_stencil_attachment_access: Bool32, + pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AccelerationStructureMotionInstanceDataNV { +impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'_> { #[inline] fn default() -> Self { - unsafe { ::std::mem::zeroed() } + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + rasterization_order_color_attachment_access: Bool32::default(), + rasterization_order_depth_attachment_access: Bool32::default(), + rasterization_order_stencil_attachment_access: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> +{ + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'_> +{ +} +impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> { + #[inline] + pub fn rasterization_order_color_attachment_access( + mut self, + rasterization_order_color_attachment_access: bool, + ) -> Self { + self.rasterization_order_color_attachment_access = + rasterization_order_color_attachment_access.into(); + self + } + #[inline] + pub fn rasterization_order_depth_attachment_access( + mut self, + rasterization_order_depth_attachment_access: bool, + ) -> Self { + self.rasterization_order_depth_attachment_access = + rasterization_order_depth_attachment_access.into(); + self + } + #[inline] + pub fn rasterization_order_stencil_attachment_access( + mut self, + rasterization_order_stencil_attachment_access: bool, + ) -> Self { + self.rasterization_order_stencil_attachment_access = + rasterization_order_stencil_attachment_access.into(); + self } } #[repr(C)] -#[derive(Copy, Clone, Default)] -#[doc = ""] -pub struct AccelerationStructureMotionInstanceNV { - pub ty: AccelerationStructureMotionInstanceTypeNV, - pub flags: AccelerationStructureMotionInstanceFlagsNV, - pub data: AccelerationStructureMotionInstanceDataNV, +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub linear_color_attachment: Bool32, + pub _marker: PhantomData<&'a ()>, } -#[cfg(feature = "debug")] -impl fmt::Debug for AccelerationStructureMotionInstanceNV { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("AccelerationStructureMotionInstanceNV") - .field("ty", &self.ty) - .field("flags", &self.flags) - .field("data", &"union") - .finish() +impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + linear_color_attachment: Bool32::default(), + _marker: PhantomData, + } } } -impl AccelerationStructureMotionInstanceNV { +unsafe impl<'a> TaggedStructure for PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> {} +impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { #[inline] - pub fn ty(mut self, ty: AccelerationStructureMotionInstanceTypeNV) -> Self { - self.ty = ty; + pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self { + self.linear_color_attachment = linear_color_attachment.into(); self } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub graphics_pipeline_library: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'_> { #[inline] - pub fn flags(mut self, flags: AccelerationStructureMotionInstanceFlagsNV) -> Self { - self.flags = flags; - self + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + graphics_pipeline_library: Bool32::default(), + _marker: PhantomData, + } } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { #[inline] - pub fn data(mut self, data: AccelerationStructureMotionInstanceDataNV) -> Self { - self.data = data; + pub fn graphics_pipeline_library(mut self, graphics_pipeline_library: bool) -> Self { + self.graphics_pipeline_library = graphics_pipeline_library.into(); self } } -#[doc = ""] -pub type RemoteAddressNV = c_void; #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct MemoryGetRemoteAddressInfoNV<'a> { +#[doc = ""] +pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub memory: DeviceMemory, - pub handle_type: ExternalMemoryHandleTypeFlags, + pub p_next: *mut c_void, + pub graphics_pipeline_library_fast_linking: Bool32, + pub graphics_pipeline_library_independent_interpolation_decoration: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MemoryGetRemoteAddressInfoNV<'_> { +impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - memory: DeviceMemory::default(), - handle_type: ExternalMemoryHandleTypeFlags::default(), + p_next: ::std::ptr::null_mut(), + graphics_pipeline_library_fast_linking: Bool32::default(), + graphics_pipeline_library_independent_interpolation_decoration: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for MemoryGetRemoteAddressInfoNV<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::MEMORY_GET_REMOTE_ADDRESS_INFO_NV; +unsafe impl<'a> TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; } -impl<'a> MemoryGetRemoteAddressInfoNV<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'_> +{ +} +impl<'a> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { #[inline] - pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.memory = memory; + pub fn graphics_pipeline_library_fast_linking( + mut self, + graphics_pipeline_library_fast_linking: bool, + ) -> Self { + self.graphics_pipeline_library_fast_linking = graphics_pipeline_library_fast_linking.into(); self } #[inline] - pub fn handle_type(mut self, handle_type: ExternalMemoryHandleTypeFlags) -> Self { - self.handle_type = handle_type; + pub fn graphics_pipeline_library_independent_interpolation_decoration( + mut self, + graphics_pipeline_library_independent_interpolation_decoration: bool, + ) -> Self { + self.graphics_pipeline_library_independent_interpolation_decoration = + graphics_pipeline_library_independent_interpolation_decoration.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ImportMemoryBufferCollectionFUCHSIA<'a> { +#[doc = ""] +pub struct GraphicsPipelineLibraryCreateInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub collection: BufferCollectionFUCHSIA, - pub index: u32, + pub p_next: *mut c_void, + pub flags: GraphicsPipelineLibraryFlagsEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMemoryBufferCollectionFUCHSIA<'_> { +impl ::std::default::Default for GraphicsPipelineLibraryCreateInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - collection: BufferCollectionFUCHSIA::default(), - index: u32::default(), + p_next: ::std::ptr::null_mut(), + flags: GraphicsPipelineLibraryFlagsEXT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for GraphicsPipelineLibraryCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; +} +unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXT<'_> {} +impl<'a> GraphicsPipelineLibraryCreateInfoEXT<'a> { + #[inline] + pub fn flags(mut self, flags: GraphicsPipelineLibraryFlagsEXT) -> Self { + self.flags = flags; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_set_host_mapping: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_set_host_mapping: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ImportMemoryBufferCollectionFUCHSIA<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA; +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; } -unsafe impl ExtendsMemoryAllocateInfo for ImportMemoryBufferCollectionFUCHSIA<'_> {} -impl<'a> ImportMemoryBufferCollectionFUCHSIA<'a> { - #[inline] - pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { - self.collection = collection; - self - } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> {} +impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { #[inline] - pub fn index(mut self, index: u32) -> Self { - self.index = index; + pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self { + self.descriptor_set_host_mapping = descriptor_set_host_mapping.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct BufferCollectionImageCreateInfoFUCHSIA<'a> { +#[doc = ""] +pub struct DescriptorSetBindingReferenceVALVE<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub collection: BufferCollectionFUCHSIA, - pub index: u32, + pub descriptor_set_layout: DescriptorSetLayout, + pub binding: u32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionImageCreateInfoFUCHSIA<'_> { +impl ::std::default::Default for DescriptorSetBindingReferenceVALVE<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - collection: BufferCollectionFUCHSIA::default(), - index: u32::default(), + descriptor_set_layout: DescriptorSetLayout::default(), + binding: u32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for BufferCollectionImageCreateInfoFUCHSIA<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA; +unsafe impl<'a> TaggedStructure for DescriptorSetBindingReferenceVALVE<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; } -unsafe impl ExtendsImageCreateInfo for BufferCollectionImageCreateInfoFUCHSIA<'_> {} -impl<'a> BufferCollectionImageCreateInfoFUCHSIA<'a> { +impl<'a> DescriptorSetBindingReferenceVALVE<'a> { #[inline] - pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { - self.collection = collection; + pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self { + self.descriptor_set_layout = descriptor_set_layout; self } #[inline] - pub fn index(mut self, index: u32) -> Self { - self.index = index; + pub fn binding(mut self, binding: u32) -> Self { + self.binding = binding; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct BufferCollectionBufferCreateInfoFUCHSIA<'a> { +#[doc = ""] +pub struct DescriptorSetLayoutHostMappingInfoVALVE<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub collection: BufferCollectionFUCHSIA, - pub index: u32, + pub p_next: *mut c_void, + pub descriptor_offset: usize, + pub descriptor_size: u32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionBufferCreateInfoFUCHSIA<'_> { +impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - collection: BufferCollectionFUCHSIA::default(), - index: u32::default(), + p_next: ::std::ptr::null_mut(), + descriptor_offset: usize::default(), + descriptor_size: u32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for BufferCollectionBufferCreateInfoFUCHSIA<'a> { +unsafe impl<'a> TaggedStructure for DescriptorSetLayoutHostMappingInfoVALVE<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA; + StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; } -unsafe impl ExtendsBufferCreateInfo for BufferCollectionBufferCreateInfoFUCHSIA<'_> {} -impl<'a> BufferCollectionBufferCreateInfoFUCHSIA<'a> { +impl<'a> DescriptorSetLayoutHostMappingInfoVALVE<'a> { #[inline] - pub fn collection(mut self, collection: BufferCollectionFUCHSIA) -> Self { - self.collection = collection; + pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self { + self.descriptor_offset = descriptor_offset; self } #[inline] - pub fn index(mut self, index: u32) -> Self { - self.index = index; + pub fn descriptor_size(mut self, descriptor_size: u32) -> Self { + self.descriptor_size = descriptor_size; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct BufferCollectionCreateInfoFUCHSIA<'a> { +#[doc = ""] +pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub collection_token: zx_handle_t, + pub p_next: *mut c_void, + pub shader_module_identifier: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionCreateInfoFUCHSIA<'_> { +impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - collection_token: zx_handle_t::default(), + p_next: ::std::ptr::null_mut(), + shader_module_identifier: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for BufferCollectionCreateInfoFUCHSIA<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CREATE_INFO_FUCHSIA; +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; } -impl<'a> BufferCollectionCreateInfoFUCHSIA<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { #[inline] - pub fn collection_token(mut self, collection_token: zx_handle_t) -> Self { - self.collection_token = collection_token; + pub fn shader_module_identifier(mut self, shader_module_identifier: bool) -> Self { + self.shader_module_identifier = shader_module_identifier.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct BufferCollectionPropertiesFUCHSIA<'a> { +#[doc = ""] +pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub memory_type_bits: u32, - pub buffer_count: u32, - pub create_info_index: u32, - pub sysmem_pixel_format: u64, - pub format_features: FormatFeatureFlags, - pub sysmem_color_space_index: SysmemColorSpaceFUCHSIA<'a>, - pub sampler_ycbcr_conversion_components: ComponentMapping, - pub suggested_ycbcr_model: SamplerYcbcrModelConversion, - pub suggested_ycbcr_range: SamplerYcbcrRange, - pub suggested_x_chroma_offset: ChromaLocation, - pub suggested_y_chroma_offset: ChromaLocation, + pub shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionPropertiesFUCHSIA<'_> { +impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - memory_type_bits: u32::default(), - buffer_count: u32::default(), - create_info_index: u32::default(), - sysmem_pixel_format: u64::default(), - format_features: FormatFeatureFlags::default(), - sysmem_color_space_index: SysmemColorSpaceFUCHSIA::default(), - sampler_ycbcr_conversion_components: ComponentMapping::default(), - suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), - suggested_ycbcr_range: SamplerYcbcrRange::default(), - suggested_x_chroma_offset: ChromaLocation::default(), - suggested_y_chroma_offset: ChromaLocation::default(), + shader_module_identifier_algorithm_uuid: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for BufferCollectionPropertiesFUCHSIA<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_PROPERTIES_FUCHSIA; +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; } -impl<'a> BufferCollectionPropertiesFUCHSIA<'a> { - #[inline] - pub fn memory_type_bits(mut self, memory_type_bits: u32) -> Self { - self.memory_type_bits = memory_type_bits; - self - } - #[inline] - pub fn buffer_count(mut self, buffer_count: u32) -> Self { - self.buffer_count = buffer_count; - self - } - #[inline] - pub fn create_info_index(mut self, create_info_index: u32) -> Self { - self.create_info_index = create_info_index; - self - } - #[inline] - pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { - self.sysmem_pixel_format = sysmem_pixel_format; - self - } - #[inline] - pub fn format_features(mut self, format_features: FormatFeatureFlags) -> Self { - self.format_features = format_features; - self - } - #[inline] - pub fn sysmem_color_space_index( - mut self, - sysmem_color_space_index: SysmemColorSpaceFUCHSIA<'a>, - ) -> Self { - self.sysmem_color_space_index = sysmem_color_space_index; - self - } - #[inline] - pub fn sampler_ycbcr_conversion_components( - mut self, - sampler_ycbcr_conversion_components: ComponentMapping, - ) -> Self { - self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; - self - } +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_> +{ +} +impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { #[inline] - pub fn suggested_ycbcr_model( + pub fn shader_module_identifier_algorithm_uuid( mut self, - suggested_ycbcr_model: SamplerYcbcrModelConversion, + shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], ) -> Self { - self.suggested_ycbcr_model = suggested_ycbcr_model; - self - } - #[inline] - pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { - self.suggested_ycbcr_range = suggested_ycbcr_range; - self - } - #[inline] - pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { - self.suggested_x_chroma_offset = suggested_x_chroma_offset; - self - } - #[inline] - pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { - self.suggested_y_chroma_offset = suggested_y_chroma_offset; + self.shader_module_identifier_algorithm_uuid = shader_module_identifier_algorithm_uuid; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct BufferConstraintsInfoFUCHSIA<'a> { +#[doc = ""] +pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub create_info: BufferCreateInfo<'a>, - pub required_format_features: FormatFeatureFlags, - pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, + pub identifier_size: u32, + pub p_identifier: *const u8, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferConstraintsInfoFUCHSIA<'_> { +impl ::std::default::Default for PipelineShaderStageModuleIdentifierCreateInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - create_info: BufferCreateInfo::default(), - required_format_features: FormatFeatureFlags::default(), - buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), + identifier_size: u32::default(), + p_identifier: ::std::ptr::null(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for BufferConstraintsInfoFUCHSIA<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_CONSTRAINTS_INFO_FUCHSIA; +unsafe impl<'a> TaggedStructure for PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; } -impl<'a> BufferConstraintsInfoFUCHSIA<'a> { - #[inline] - pub fn create_info(mut self, create_info: BufferCreateInfo<'a>) -> Self { - self.create_info = create_info; - self - } - #[inline] - pub fn required_format_features( - mut self, - required_format_features: FormatFeatureFlags, - ) -> Self { - self.required_format_features = required_format_features; - self - } +unsafe impl ExtendsPipelineShaderStageCreateInfo + for PipelineShaderStageModuleIdentifierCreateInfoEXT<'_> +{ +} +impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { #[inline] - pub fn buffer_collection_constraints( - mut self, - buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, - ) -> Self { - self.buffer_collection_constraints = buffer_collection_constraints; + pub fn identifier(mut self, identifier: &'a [u8]) -> Self { + self.identifier_size = identifier.len() as _; + self.p_identifier = identifier.as_ptr(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct SysmemColorSpaceFUCHSIA<'a> { +#[doc = ""] +pub struct ShaderModuleIdentifierEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub color_space: u32, + pub p_next: *mut c_void, + pub identifier_size: u32, + pub identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT], pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SysmemColorSpaceFUCHSIA<'_> { +impl ::std::default::Default for ShaderModuleIdentifierEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - color_space: u32::default(), + p_next: ::std::ptr::null_mut(), + identifier_size: u32::default(), + identifier: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for SysmemColorSpaceFUCHSIA<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::SYSMEM_COLOR_SPACE_FUCHSIA; +unsafe impl<'a> TaggedStructure for ShaderModuleIdentifierEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_IDENTIFIER_EXT; } -impl<'a> SysmemColorSpaceFUCHSIA<'a> { +impl<'a> ShaderModuleIdentifierEXT<'a> { #[inline] - pub fn color_space(mut self, color_space: u32) -> Self { - self.color_space = color_space; + pub fn identifier_size(mut self, identifier_size: u32) -> Self { + self.identifier_size = identifier_size; + self + } + #[inline] + pub fn identifier(mut self, identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]) -> Self { + self.identifier = identifier; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ImageFormatConstraintsInfoFUCHSIA<'a> { +#[doc = ""] +pub struct ImageCompressionControlEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub image_create_info: ImageCreateInfo<'a>, - pub required_format_features: FormatFeatureFlags, - pub flags: ImageFormatConstraintsFlagsFUCHSIA, - pub sysmem_pixel_format: u64, - pub color_space_count: u32, - pub p_color_spaces: *const SysmemColorSpaceFUCHSIA<'a>, + pub flags: ImageCompressionFlagsEXT, + pub compression_control_plane_count: u32, + pub p_fixed_rate_flags: *mut ImageCompressionFixedRateFlagsEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageFormatConstraintsInfoFUCHSIA<'_> { +impl ::std::default::Default for ImageCompressionControlEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - image_create_info: ImageCreateInfo::default(), - required_format_features: FormatFeatureFlags::default(), - flags: ImageFormatConstraintsFlagsFUCHSIA::default(), - sysmem_pixel_format: u64::default(), - color_space_count: u32::default(), - p_color_spaces: ::std::ptr::null(), + flags: ImageCompressionFlagsEXT::default(), + compression_control_plane_count: u32::default(), + p_fixed_rate_flags: ::std::ptr::null_mut(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ImageFormatConstraintsInfoFUCHSIA<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA; +unsafe impl<'a> TaggedStructure for ImageCompressionControlEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_CONTROL_EXT; } -impl<'a> ImageFormatConstraintsInfoFUCHSIA<'a> { +unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXT<'_> {} +unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXT<'_> {} +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXT<'_> {} +impl<'a> ImageCompressionControlEXT<'a> { #[inline] - pub fn image_create_info(mut self, image_create_info: ImageCreateInfo<'a>) -> Self { - self.image_create_info = image_create_info; + pub fn flags(mut self, flags: ImageCompressionFlagsEXT) -> Self { + self.flags = flags; self } #[inline] - pub fn required_format_features( + pub fn fixed_rate_flags( mut self, - required_format_features: FormatFeatureFlags, + fixed_rate_flags: &'a mut [ImageCompressionFixedRateFlagsEXT], ) -> Self { - self.required_format_features = required_format_features; - self - } - #[inline] - pub fn flags(mut self, flags: ImageFormatConstraintsFlagsFUCHSIA) -> Self { - self.flags = flags; + self.compression_control_plane_count = fixed_rate_flags.len() as _; + self.p_fixed_rate_flags = fixed_rate_flags.as_mut_ptr(); self } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub image_compression_control: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceImageCompressionControlFeaturesEXT<'_> { #[inline] - pub fn sysmem_pixel_format(mut self, sysmem_pixel_format: u64) -> Self { - self.sysmem_pixel_format = sysmem_pixel_format; - self + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + image_compression_control: Bool32::default(), + _marker: PhantomData, + } } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlFeaturesEXT<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { #[inline] - pub fn color_spaces(mut self, color_spaces: &'a [SysmemColorSpaceFUCHSIA]) -> Self { - self.color_space_count = color_spaces.len() as _; - self.p_color_spaces = color_spaces.as_ptr(); + pub fn image_compression_control(mut self, image_compression_control: bool) -> Self { + self.image_compression_control = image_compression_control.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ImageConstraintsInfoFUCHSIA<'a> { +#[doc = ""] +pub struct ImageCompressionPropertiesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub format_constraints_count: u32, - pub p_format_constraints: *const ImageFormatConstraintsInfoFUCHSIA<'a>, - pub buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, - pub flags: ImageConstraintsInfoFlagsFUCHSIA, + pub p_next: *mut c_void, + pub image_compression_flags: ImageCompressionFlagsEXT, + pub image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageConstraintsInfoFUCHSIA<'_> { +impl ::std::default::Default for ImageCompressionPropertiesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - format_constraints_count: u32::default(), - p_format_constraints: ::std::ptr::null(), - buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA::default(), - flags: ImageConstraintsInfoFlagsFUCHSIA::default(), + p_next: ::std::ptr::null_mut(), + image_compression_flags: ImageCompressionFlagsEXT::default(), + image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ImageConstraintsInfoFUCHSIA<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_CONSTRAINTS_INFO_FUCHSIA; +unsafe impl<'a> TaggedStructure for ImageCompressionPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT; } -impl<'a> ImageConstraintsInfoFUCHSIA<'a> { +unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXT<'_> {} +unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXT<'_> {} +unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXT<'_> {} +impl<'a> ImageCompressionPropertiesEXT<'a> { #[inline] - pub fn format_constraints( + pub fn image_compression_flags( mut self, - format_constraints: &'a [ImageFormatConstraintsInfoFUCHSIA], + image_compression_flags: ImageCompressionFlagsEXT, ) -> Self { - self.format_constraints_count = format_constraints.len() as _; - self.p_format_constraints = format_constraints.as_ptr(); + self.image_compression_flags = image_compression_flags; self } #[inline] - pub fn buffer_collection_constraints( + pub fn image_compression_fixed_rate_flags( mut self, - buffer_collection_constraints: BufferCollectionConstraintsInfoFUCHSIA<'a>, + image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, ) -> Self { - self.buffer_collection_constraints = buffer_collection_constraints; - self - } - #[inline] - pub fn flags(mut self, flags: ImageConstraintsInfoFlagsFUCHSIA) -> Self { - self.flags = flags; + self.image_compression_fixed_rate_flags = image_compression_fixed_rate_flags; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct BufferCollectionConstraintsInfoFUCHSIA<'a> { +#[doc = ""] +pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub min_buffer_count: u32, - pub max_buffer_count: u32, - pub min_buffer_count_for_camping: u32, - pub min_buffer_count_for_dedicated_slack: u32, - pub min_buffer_count_for_shared_slack: u32, + pub p_next: *mut c_void, + pub image_compression_control_swapchain: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for BufferCollectionConstraintsInfoFUCHSIA<'_> { +impl ::std::default::Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - min_buffer_count: u32::default(), - max_buffer_count: u32::default(), - min_buffer_count_for_camping: u32::default(), - min_buffer_count_for_dedicated_slack: u32::default(), - min_buffer_count_for_shared_slack: u32::default(), + p_next: ::std::ptr::null_mut(), + image_compression_control_swapchain: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for BufferCollectionConstraintsInfoFUCHSIA<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA; +unsafe impl<'a> TaggedStructure for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; } -impl<'a> BufferCollectionConstraintsInfoFUCHSIA<'a> { - #[inline] - pub fn min_buffer_count(mut self, min_buffer_count: u32) -> Self { - self.min_buffer_count = min_buffer_count; - self - } - #[inline] - pub fn max_buffer_count(mut self, max_buffer_count: u32) -> Self { - self.max_buffer_count = max_buffer_count; - self - } - #[inline] - pub fn min_buffer_count_for_camping(mut self, min_buffer_count_for_camping: u32) -> Self { - self.min_buffer_count_for_camping = min_buffer_count_for_camping; - self - } - #[inline] - pub fn min_buffer_count_for_dedicated_slack( - mut self, - min_buffer_count_for_dedicated_slack: u32, - ) -> Self { - self.min_buffer_count_for_dedicated_slack = min_buffer_count_for_dedicated_slack; - self - } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'_> +{ +} +impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { #[inline] - pub fn min_buffer_count_for_shared_slack( + pub fn image_compression_control_swapchain( mut self, - min_buffer_count_for_shared_slack: u32, + image_compression_control_swapchain: bool, ) -> Self { - self.min_buffer_count_for_shared_slack = min_buffer_count_for_shared_slack; + self.image_compression_control_swapchain = image_compression_control_swapchain.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { +#[doc = ""] +pub struct ImageSubresource2EXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub format_rgba10x6_without_y_cb_cr_sampler: Bool32, + pub image_subresource: ImageSubresource, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> { +impl ::std::default::Default for ImageSubresource2EXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - format_rgba10x6_without_y_cb_cr_sampler: Bool32::default(), + image_subresource: ImageSubresource::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'_> {} -impl<'a> PhysicalDeviceRGBA10X6FormatsFeaturesEXT<'a> { +unsafe impl<'a> TaggedStructure for ImageSubresource2EXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SUBRESOURCE_2_EXT; +} +impl<'a> ImageSubresource2EXT<'a> { #[inline] - pub fn format_rgba10x6_without_y_cb_cr_sampler( - mut self, - format_rgba10x6_without_y_cb_cr_sampler: bool, - ) -> Self { - self.format_rgba10x6_without_y_cb_cr_sampler = - format_rgba10x6_without_y_cb_cr_sampler.into(); + pub fn image_subresource(mut self, image_subresource: ImageSubresource) -> Self { + self.image_subresource = image_subresource; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct FormatProperties3<'a> { +#[doc = ""] +pub struct SubresourceLayout2EXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub linear_tiling_features: FormatFeatureFlags2, - pub optimal_tiling_features: FormatFeatureFlags2, - pub buffer_features: FormatFeatureFlags2, + pub subresource_layout: SubresourceLayout, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for FormatProperties3<'_> { +impl ::std::default::Default for SubresourceLayout2EXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - linear_tiling_features: FormatFeatureFlags2::default(), - optimal_tiling_features: FormatFeatureFlags2::default(), - buffer_features: FormatFeatureFlags2::default(), + subresource_layout: SubresourceLayout::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for FormatProperties3<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::FORMAT_PROPERTIES_3; +unsafe impl<'a> TaggedStructure for SubresourceLayout2EXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SUBRESOURCE_LAYOUT_2_EXT; } -unsafe impl ExtendsFormatProperties2 for FormatProperties3<'_> {} -impl<'a> FormatProperties3<'a> { - #[inline] - pub fn linear_tiling_features(mut self, linear_tiling_features: FormatFeatureFlags2) -> Self { - self.linear_tiling_features = linear_tiling_features; - self - } +pub unsafe trait ExtendsSubresourceLayout2EXT {} +impl<'a> SubresourceLayout2EXT<'a> { #[inline] - pub fn optimal_tiling_features(mut self, optimal_tiling_features: FormatFeatureFlags2) -> Self { - self.optimal_tiling_features = optimal_tiling_features; + pub fn subresource_layout(mut self, subresource_layout: SubresourceLayout) -> Self { + self.subresource_layout = subresource_layout; self } - #[inline] - pub fn buffer_features(mut self, buffer_features: FormatFeatureFlags2) -> Self { - self.buffer_features = buffer_features; + #[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 DrmFormatModifierPropertiesList2EXT<'a> { +#[doc = ""] +pub struct RenderPassCreationControlEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub drm_format_modifier_count: u32, - pub p_drm_format_modifier_properties: *mut DrmFormatModifierProperties2EXT, + pub p_next: *const c_void, + pub disallow_merging: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DrmFormatModifierPropertiesList2EXT<'_> { +impl ::std::default::Default for RenderPassCreationControlEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - drm_format_modifier_count: u32::default(), - p_drm_format_modifier_properties: ::std::ptr::null_mut(), + p_next: ::std::ptr::null(), + disallow_merging: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for DrmFormatModifierPropertiesList2EXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT; +unsafe impl<'a> TaggedStructure for RenderPassCreationControlEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATION_CONTROL_EXT; } -unsafe impl ExtendsFormatProperties2 for DrmFormatModifierPropertiesList2EXT<'_> {} -impl<'a> DrmFormatModifierPropertiesList2EXT<'a> { +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXT<'_> {} +unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXT<'_> {} +impl<'a> RenderPassCreationControlEXT<'a> { #[inline] - pub fn drm_format_modifier_properties( - mut self, - drm_format_modifier_properties: &'a mut [DrmFormatModifierProperties2EXT], - ) -> Self { - self.drm_format_modifier_count = drm_format_modifier_properties.len() as _; - self.p_drm_format_modifier_properties = drm_format_modifier_properties.as_mut_ptr(); + pub fn disallow_merging(mut self, disallow_merging: bool) -> Self { + self.disallow_merging = disallow_merging.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone, Default)] -#[doc = ""] -pub struct DrmFormatModifierProperties2EXT { - pub drm_format_modifier: u64, - pub drm_format_modifier_plane_count: u32, - pub drm_format_modifier_tiling_features: FormatFeatureFlags2, +#[doc = ""] +pub struct RenderPassCreationFeedbackInfoEXT { + pub post_merge_subpass_count: u32, } -impl DrmFormatModifierProperties2EXT { - #[inline] - pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self { - self.drm_format_modifier = drm_format_modifier; - self - } - #[inline] - pub fn drm_format_modifier_plane_count(mut self, drm_format_modifier_plane_count: u32) -> Self { - self.drm_format_modifier_plane_count = drm_format_modifier_plane_count; - self - } +impl RenderPassCreationFeedbackInfoEXT { #[inline] - pub fn drm_format_modifier_tiling_features( - mut self, - drm_format_modifier_tiling_features: FormatFeatureFlags2, - ) -> Self { - self.drm_format_modifier_tiling_features = drm_format_modifier_tiling_features; + pub fn post_merge_subpass_count(mut self, post_merge_subpass_count: u32) -> Self { + self.post_merge_subpass_count = post_merge_subpass_count; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct AndroidHardwareBufferFormatProperties2ANDROID<'a> { +#[doc = ""] +pub struct RenderPassCreationFeedbackCreateInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub format: Format, - pub external_format: u64, - pub format_features: FormatFeatureFlags2, - pub sampler_ycbcr_conversion_components: ComponentMapping, - pub suggested_ycbcr_model: SamplerYcbcrModelConversion, - pub suggested_ycbcr_range: SamplerYcbcrRange, - pub suggested_x_chroma_offset: ChromaLocation, - pub suggested_y_chroma_offset: ChromaLocation, + pub p_next: *const c_void, + pub p_render_pass_feedback: *mut RenderPassCreationFeedbackInfoEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AndroidHardwareBufferFormatProperties2ANDROID<'_> { +impl ::std::default::Default for RenderPassCreationFeedbackCreateInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - format: Format::default(), - external_format: u64::default(), - format_features: FormatFeatureFlags2::default(), - sampler_ycbcr_conversion_components: ComponentMapping::default(), - suggested_ycbcr_model: SamplerYcbcrModelConversion::default(), - suggested_ycbcr_range: SamplerYcbcrRange::default(), - suggested_x_chroma_offset: ChromaLocation::default(), - suggested_y_chroma_offset: ChromaLocation::default(), + p_next: ::std::ptr::null(), + p_render_pass_feedback: ::std::ptr::null_mut(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for AndroidHardwareBufferFormatProperties2ANDROID<'a> { +unsafe impl<'a> TaggedStructure for RenderPassCreationFeedbackCreateInfoEXT<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID; -} -unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID - for AndroidHardwareBufferFormatProperties2ANDROID<'_> -{ + StructureType::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT; } -impl<'a> AndroidHardwareBufferFormatProperties2ANDROID<'a> { - #[inline] - pub fn format(mut self, format: Format) -> Self { - self.format = format; - self - } - #[inline] - pub fn external_format(mut self, external_format: u64) -> Self { - self.external_format = external_format; - self - } - #[inline] - pub fn format_features(mut self, format_features: FormatFeatureFlags2) -> Self { - self.format_features = format_features; - self - } +unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXT<'_> {} +impl<'a> RenderPassCreationFeedbackCreateInfoEXT<'a> { #[inline] - pub fn sampler_ycbcr_conversion_components( + pub fn render_pass_feedback( mut self, - sampler_ycbcr_conversion_components: ComponentMapping, + render_pass_feedback: &'a mut RenderPassCreationFeedbackInfoEXT, ) -> Self { - self.sampler_ycbcr_conversion_components = sampler_ycbcr_conversion_components; + self.p_render_pass_feedback = render_pass_feedback; self } +} +#[repr(C)] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct RenderPassSubpassFeedbackInfoEXT { + pub subpass_merge_status: SubpassMergeStatusEXT, + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub post_merge_index: u32, +} +#[cfg(feature = "debug")] +impl fmt::Debug for RenderPassSubpassFeedbackInfoEXT { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.debug_struct("RenderPassSubpassFeedbackInfoEXT") + .field("subpass_merge_status", &self.subpass_merge_status) + .field("description", &unsafe { + ::std::ffi::CStr::from_ptr(self.description.as_ptr()) + }) + .field("post_merge_index", &self.post_merge_index) + .finish() + } +} +impl ::std::default::Default for RenderPassSubpassFeedbackInfoEXT { #[inline] - pub fn suggested_ycbcr_model( - mut self, - suggested_ycbcr_model: SamplerYcbcrModelConversion, - ) -> Self { - self.suggested_ycbcr_model = suggested_ycbcr_model; - self + fn default() -> Self { + Self { + subpass_merge_status: SubpassMergeStatusEXT::default(), + description: unsafe { ::std::mem::zeroed() }, + post_merge_index: u32::default(), + } } +} +impl RenderPassSubpassFeedbackInfoEXT { #[inline] - pub fn suggested_ycbcr_range(mut self, suggested_ycbcr_range: SamplerYcbcrRange) -> Self { - self.suggested_ycbcr_range = suggested_ycbcr_range; + pub fn subpass_merge_status(mut self, subpass_merge_status: SubpassMergeStatusEXT) -> Self { + self.subpass_merge_status = subpass_merge_status; self } #[inline] - pub fn suggested_x_chroma_offset(mut self, suggested_x_chroma_offset: ChromaLocation) -> Self { - self.suggested_x_chroma_offset = suggested_x_chroma_offset; + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.description = description; self } #[inline] - pub fn suggested_y_chroma_offset(mut self, suggested_y_chroma_offset: ChromaLocation) -> Self { - self.suggested_y_chroma_offset = suggested_y_chroma_offset; + pub fn post_merge_index(mut self, post_merge_index: u32) -> Self { + self.post_merge_index = post_merge_index; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PipelineRenderingCreateInfo<'a> { +#[doc = ""] +pub struct RenderPassSubpassFeedbackCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub view_mask: u32, - pub color_attachment_count: u32, - pub p_color_attachment_formats: *const Format, - pub depth_attachment_format: Format, - pub stencil_attachment_format: Format, + pub p_subpass_feedback: *mut RenderPassSubpassFeedbackInfoEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineRenderingCreateInfo<'_> { +impl ::std::default::Default for RenderPassSubpassFeedbackCreateInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - view_mask: u32::default(), - color_attachment_count: u32::default(), - p_color_attachment_formats: ::std::ptr::null(), - depth_attachment_format: Format::default(), - stencil_attachment_format: Format::default(), + p_subpass_feedback: ::std::ptr::null_mut(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PipelineRenderingCreateInfo<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_RENDERING_CREATE_INFO; +unsafe impl<'a> TaggedStructure for RenderPassSubpassFeedbackCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; } -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRenderingCreateInfo<'_> {} -impl<'a> PipelineRenderingCreateInfo<'a> { - #[inline] - pub fn view_mask(mut self, view_mask: u32) -> Self { - self.view_mask = view_mask; - self - } - #[inline] - pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { - self.color_attachment_count = color_attachment_formats.len() as _; - self.p_color_attachment_formats = color_attachment_formats.as_ptr(); - self - } - #[inline] - pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { - self.depth_attachment_format = depth_attachment_format; - self - } +unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXT<'_> {} +impl<'a> RenderPassSubpassFeedbackCreateInfoEXT<'a> { #[inline] - pub fn stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { - self.stencil_attachment_format = stencil_attachment_format; + pub fn subpass_feedback( + mut self, + subpass_feedback: &'a mut RenderPassSubpassFeedbackInfoEXT, + ) -> Self { + self.p_subpass_feedback = subpass_feedback; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct RenderingInfo<'a> { +#[doc = ""] +pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub flags: RenderingFlags, - pub render_area: Rect2D, - pub layer_count: u32, - pub view_mask: u32, - pub color_attachment_count: u32, - pub p_color_attachments: *const RenderingAttachmentInfo<'a>, - pub p_depth_attachment: *const RenderingAttachmentInfo<'a>, - pub p_stencil_attachment: *const RenderingAttachmentInfo<'a>, + pub p_next: *mut c_void, + pub subpass_merge_feedback: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderingInfo<'_> { +impl ::std::default::Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - flags: RenderingFlags::default(), - render_area: Rect2D::default(), - layer_count: u32::default(), - view_mask: u32::default(), - color_attachment_count: u32::default(), - p_color_attachments: ::std::ptr::null(), - p_depth_attachment: ::std::ptr::null(), - p_stencil_attachment: ::std::ptr::null(), + p_next: ::std::ptr::null_mut(), + subpass_merge_feedback: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for RenderingInfo<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_INFO; +unsafe impl<'a> TaggedStructure for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; } -pub unsafe trait ExtendsRenderingInfo {} -impl<'a> RenderingInfo<'a> { - #[inline] - pub fn flags(mut self, flags: RenderingFlags) -> Self { - self.flags = flags; - self - } - #[inline] - pub fn render_area(mut self, render_area: Rect2D) -> Self { - self.render_area = render_area; - self - } - #[inline] - pub fn layer_count(mut self, layer_count: u32) -> Self { - self.layer_count = layer_count; - self - } - #[inline] - pub fn view_mask(mut self, view_mask: u32) -> Self { - self.view_mask = view_mask; - self - } - #[inline] - pub fn color_attachments(mut self, color_attachments: &'a [RenderingAttachmentInfo]) -> Self { - self.color_attachment_count = color_attachments.len() as _; - self.p_color_attachments = color_attachments.as_ptr(); - self - } - #[inline] - pub fn depth_attachment(mut self, depth_attachment: &'a RenderingAttachmentInfo<'a>) -> Self { - self.p_depth_attachment = depth_attachment; - self - } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { #[inline] - pub fn stencil_attachment( - mut self, - stencil_attachment: &'a RenderingAttachmentInfo<'a>, - ) -> Self { - self.p_stencil_attachment = stencil_attachment; - self - } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `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 subpass_merge_feedback(mut self, subpass_merge_feedback: bool) -> Self { + self.subpass_merge_feedback = subpass_merge_feedback.into(); self } } #[repr(C)] #[derive(Copy, Clone)] -#[doc = ""] -pub struct RenderingAttachmentInfo<'a> { +#[doc = ""] +pub struct MicromapBuildInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub image_view: ImageView, - pub image_layout: ImageLayout, - pub resolve_mode: ResolveModeFlags, - pub resolve_image_view: ImageView, - pub resolve_image_layout: ImageLayout, - pub load_op: AttachmentLoadOp, - pub store_op: AttachmentStoreOp, - pub clear_value: ClearValue, + 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 RenderingAttachmentInfo<'_> { +impl fmt::Debug for MicromapBuildInfoEXT<'_> { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("RenderingAttachmentInfo") + fmt.debug_struct("MicromapBuildInfoEXT") .field("s_type", &self.s_type) .field("p_next", &self.p_next) - .field("image_view", &self.image_view) - .field("image_layout", &self.image_layout) - .field("resolve_mode", &self.resolve_mode) - .field("resolve_image_view", &self.resolve_image_view) - .field("resolve_image_layout", &self.resolve_image_layout) - .field("load_op", &self.load_op) - .field("store_op", &self.store_op) - .field("clear_value", &"union") + .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 RenderingAttachmentInfo<'_> { +impl ::std::default::Default for MicromapBuildInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - image_view: ImageView::default(), - image_layout: ImageLayout::default(), - resolve_mode: ResolveModeFlags::default(), - resolve_image_view: ImageView::default(), - resolve_image_layout: ImageLayout::default(), - load_op: AttachmentLoadOp::default(), - store_op: AttachmentStoreOp::default(), - clear_value: ClearValue::default(), + 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 RenderingAttachmentInfo<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::RENDERING_ATTACHMENT_INFO; +unsafe impl<'a> TaggedStructure for MicromapBuildInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_INFO_EXT; } -impl<'a> RenderingAttachmentInfo<'a> { +impl<'a> MicromapBuildInfoEXT<'a> { #[inline] - pub fn image_view(mut self, image_view: ImageView) -> Self { - self.image_view = image_view; + pub fn ty(mut self, ty: MicromapTypeEXT) -> Self { + self.ty = ty; self } #[inline] - pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { - self.image_layout = image_layout; + pub fn flags(mut self, flags: BuildMicromapFlagsEXT) -> Self { + self.flags = flags; self } #[inline] - pub fn resolve_mode(mut self, resolve_mode: ResolveModeFlags) -> Self { - self.resolve_mode = resolve_mode; + pub fn mode(mut self, mode: BuildMicromapModeEXT) -> Self { + self.mode = mode; self } #[inline] - pub fn resolve_image_view(mut self, resolve_image_view: ImageView) -> Self { - self.resolve_image_view = resolve_image_view; + pub fn dst_micromap(mut self, dst_micromap: MicromapEXT) -> Self { + self.dst_micromap = dst_micromap; self } #[inline] - pub fn resolve_image_layout(mut self, resolve_image_layout: ImageLayout) -> Self { - self.resolve_image_layout = resolve_image_layout; + 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 load_op(mut self, load_op: AttachmentLoadOp) -> Self { - self.load_op = load_op; + 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 store_op(mut self, store_op: AttachmentStoreOp) -> Self { - self.store_op = store_op; + pub fn data(mut self, data: DeviceOrHostAddressConstKHR) -> Self { + self.data = data; self } #[inline] - pub fn clear_value(mut self, clear_value: ClearValue) -> Self { - self.clear_value = clear_value; + 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 RenderingFragmentShadingRateAttachmentInfoKHR<'a> { +#[doc = ""] +pub struct MicromapCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub image_view: ImageView, - pub image_layout: ImageLayout, - pub shading_rate_attachment_texel_size: Extent2D, + 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 RenderingFragmentShadingRateAttachmentInfoKHR<'_> { +impl ::std::default::Default for MicromapCreateInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - image_view: ImageView::default(), - image_layout: ImageLayout::default(), - shading_rate_attachment_texel_size: Extent2D::default(), + 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 RenderingFragmentShadingRateAttachmentInfoKHR<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; +unsafe impl<'a> TaggedStructure for MicromapCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_CREATE_INFO_EXT; } -unsafe impl ExtendsRenderingInfo for RenderingFragmentShadingRateAttachmentInfoKHR<'_> {} -impl<'a> RenderingFragmentShadingRateAttachmentInfoKHR<'a> { +impl<'a> MicromapCreateInfoEXT<'a> { #[inline] - pub fn image_view(mut self, image_view: ImageView) -> Self { - self.image_view = image_view; + pub fn create_flags(mut self, create_flags: MicromapCreateFlagsEXT) -> Self { + self.create_flags = create_flags; self } #[inline] - pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { - self.image_layout = image_layout; + pub fn buffer(mut self, buffer: Buffer) -> Self { + self.buffer = buffer; self } #[inline] - pub fn shading_rate_attachment_texel_size( - mut self, - shading_rate_attachment_texel_size: Extent2D, - ) -> Self { - self.shading_rate_attachment_texel_size = shading_rate_attachment_texel_size; + pub fn offset(mut self, offset: DeviceSize) -> Self { + self.offset = offset; self } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] -#[doc = ""] -pub struct RenderingFragmentDensityMapAttachmentInfoEXT<'a> { - pub s_type: StructureType, - pub p_next: *const c_void, - pub image_view: ImageView, - pub image_layout: ImageLayout, - pub _marker: PhantomData<&'a ()>, -} -impl ::std::default::Default for RenderingFragmentDensityMapAttachmentInfoEXT<'_> { #[inline] - fn default() -> Self { - Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - image_view: ImageView::default(), - image_layout: ImageLayout::default(), - _marker: PhantomData, - } + pub fn size(mut self, size: DeviceSize) -> Self { + self.size = size; + self } -} -unsafe impl<'a> TaggedStructure for RenderingFragmentDensityMapAttachmentInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; -} -unsafe impl ExtendsRenderingInfo for RenderingFragmentDensityMapAttachmentInfoEXT<'_> {} -impl<'a> RenderingFragmentDensityMapAttachmentInfoEXT<'a> { #[inline] - pub fn image_view(mut self, image_view: ImageView) -> Self { - self.image_view = image_view; + pub fn ty(mut self, ty: MicromapTypeEXT) -> Self { + self.ty = ty; self } - #[inline] - pub fn image_layout(mut self, image_layout: ImageLayout) -> Self { - self.image_layout = image_layout; + #[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 PhysicalDeviceDynamicRenderingFeatures<'a> { +#[doc = ""] +pub struct MicromapVersionInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub dynamic_rendering: Bool32, + pub p_next: *const c_void, + pub p_version_data: *const [u8; 2 * UUID_SIZE], pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDynamicRenderingFeatures<'_> { +impl ::std::default::Default for MicromapVersionInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - dynamic_rendering: Bool32::default(), + p_next: ::std::ptr::null(), + p_version_data: ::std::ptr::null(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceDynamicRenderingFeatures<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; +unsafe impl<'a> TaggedStructure for MicromapVersionInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_VERSION_INFO_EXT; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDynamicRenderingFeatures<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDynamicRenderingFeatures<'_> {} -impl<'a> PhysicalDeviceDynamicRenderingFeatures<'a> { +impl<'a> MicromapVersionInfoEXT<'a> { #[inline] - pub fn dynamic_rendering(mut self, dynamic_rendering: bool) -> Self { - self.dynamic_rendering = dynamic_rendering.into(); + 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 CommandBufferInheritanceRenderingInfo<'a> { +#[doc = ""] +pub struct CopyMicromapInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub flags: RenderingFlags, - pub view_mask: u32, - pub color_attachment_count: u32, - pub p_color_attachment_formats: *const Format, - pub depth_attachment_format: Format, - pub stencil_attachment_format: Format, - pub rasterization_samples: SampleCountFlags, + pub src: MicromapEXT, + pub dst: MicromapEXT, + pub mode: CopyMicromapModeEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for CommandBufferInheritanceRenderingInfo<'_> { +impl ::std::default::Default for CopyMicromapInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - flags: RenderingFlags::default(), - view_mask: u32::default(), - color_attachment_count: u32::default(), - p_color_attachment_formats: ::std::ptr::null(), - depth_attachment_format: Format::default(), - stencil_attachment_format: Format::default(), - rasterization_samples: SampleCountFlags::default(), + src: MicromapEXT::default(), + dst: MicromapEXT::default(), + mode: CopyMicromapModeEXT::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for CommandBufferInheritanceRenderingInfo<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO; +unsafe impl<'a> TaggedStructure for CopyMicromapInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MICROMAP_INFO_EXT; } -unsafe impl ExtendsCommandBufferInheritanceInfo for CommandBufferInheritanceRenderingInfo<'_> {} -impl<'a> CommandBufferInheritanceRenderingInfo<'a> { +impl<'a> CopyMicromapInfoEXT<'a> { #[inline] - pub fn flags(mut self, flags: RenderingFlags) -> Self { - self.flags = flags; + pub fn src(mut self, src: MicromapEXT) -> Self { + self.src = src; self } #[inline] - pub fn view_mask(mut self, view_mask: u32) -> Self { - self.view_mask = view_mask; + pub fn dst(mut self, dst: MicromapEXT) -> Self { + self.dst = dst; self } #[inline] - pub fn color_attachment_formats(mut self, color_attachment_formats: &'a [Format]) -> Self { - self.color_attachment_count = color_attachment_formats.len() as _; - self.p_color_attachment_formats = color_attachment_formats.as_ptr(); + 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] - pub fn depth_attachment_format(mut self, depth_attachment_format: Format) -> Self { - self.depth_attachment_format = depth_attachment_format; + 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 stencil_attachment_format(mut self, stencil_attachment_format: Format) -> Self { - self.stencil_attachment_format = stencil_attachment_format; + pub fn dst(mut self, dst: DeviceOrHostAddressKHR) -> Self { + self.dst = dst; self } #[inline] - pub fn rasterization_samples(mut self, rasterization_samples: SampleCountFlags) -> Self { - self.rasterization_samples = rasterization_samples; + 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 AttachmentSampleCountInfoAMD<'a> { +#[doc = ""] +pub struct CopyMemoryToMicromapInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub color_attachment_count: u32, - pub p_color_attachment_samples: *const SampleCountFlags, - pub depth_stencil_attachment_samples: SampleCountFlags, + pub src: DeviceOrHostAddressConstKHR, + pub dst: MicromapEXT, + pub mode: CopyMicromapModeEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AttachmentSampleCountInfoAMD<'_> { +#[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(), - color_attachment_count: u32::default(), - p_color_attachment_samples: ::std::ptr::null(), - depth_stencil_attachment_samples: SampleCountFlags::default(), + src: DeviceOrHostAddressConstKHR::default(), + dst: MicromapEXT::default(), + mode: CopyMicromapModeEXT::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for AttachmentSampleCountInfoAMD<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::ATTACHMENT_SAMPLE_COUNT_INFO_AMD; +unsafe impl<'a> TaggedStructure for CopyMemoryToMicromapInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::COPY_MEMORY_TO_MICROMAP_INFO_EXT; } -unsafe impl ExtendsCommandBufferInheritanceInfo for AttachmentSampleCountInfoAMD<'_> {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for AttachmentSampleCountInfoAMD<'_> {} -impl<'a> AttachmentSampleCountInfoAMD<'a> { +impl<'a> CopyMemoryToMicromapInfoEXT<'a> { #[inline] - pub fn color_attachment_samples( - mut self, - color_attachment_samples: &'a [SampleCountFlags], - ) -> Self { - self.color_attachment_count = color_attachment_samples.len() as _; - self.p_color_attachment_samples = color_attachment_samples.as_ptr(); + pub fn src(mut self, src: DeviceOrHostAddressConstKHR) -> Self { + self.src = src; self } #[inline] - pub fn depth_stencil_attachment_samples( - mut self, - depth_stencil_attachment_samples: SampleCountFlags, - ) -> Self { - self.depth_stencil_attachment_samples = depth_stencil_attachment_samples; + 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 MultiviewPerViewAttributesInfoNVX<'a> { +#[doc = ""] +pub struct MicromapBuildSizesInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub per_view_attributes: Bool32, - pub per_view_attributes_position_x_only: Bool32, + pub micromap_size: DeviceSize, + pub build_scratch_size: DeviceSize, + pub discardable: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for MultiviewPerViewAttributesInfoNVX<'_> { +impl ::std::default::Default for MicromapBuildSizesInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - per_view_attributes: Bool32::default(), - per_view_attributes_position_x_only: Bool32::default(), + micromap_size: DeviceSize::default(), + build_scratch_size: DeviceSize::default(), + discardable: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for MultiviewPerViewAttributesInfoNVX<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX; +unsafe impl<'a> TaggedStructure for MicromapBuildSizesInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::MICROMAP_BUILD_SIZES_INFO_EXT; } -unsafe impl ExtendsCommandBufferInheritanceInfo for MultiviewPerViewAttributesInfoNVX<'_> {} -unsafe impl ExtendsGraphicsPipelineCreateInfo for MultiviewPerViewAttributesInfoNVX<'_> {} -unsafe impl ExtendsRenderingInfo for MultiviewPerViewAttributesInfoNVX<'_> {} -impl<'a> MultiviewPerViewAttributesInfoNVX<'a> { +impl<'a> MicromapBuildSizesInfoEXT<'a> { #[inline] - pub fn per_view_attributes(mut self, per_view_attributes: bool) -> Self { - self.per_view_attributes = per_view_attributes.into(); + pub fn micromap_size(mut self, micromap_size: DeviceSize) -> Self { + self.micromap_size = micromap_size; self } #[inline] - pub fn per_view_attributes_position_x_only( - mut self, - per_view_attributes_position_x_only: bool, - ) -> Self { - self.per_view_attributes_position_x_only = per_view_attributes_position_x_only.into(); + 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 PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub min_lod: Bool32, + pub micromap: Bool32, + pub micromap_capture_replay: Bool32, + pub micromap_host_commands: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> { +impl ::std::default::Default for PhysicalDeviceOpacityMicromapFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - min_lod: Bool32::default(), + micromap: Bool32::default(), + micromap_capture_replay: Bool32::default(), + micromap_host_commands: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageViewMinLodFeaturesEXT<'_> {} -impl<'a> PhysicalDeviceImageViewMinLodFeaturesEXT<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpacityMicromapFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpacityMicromapFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceOpacityMicromapFeaturesEXT<'a> { #[inline] - pub fn min_lod(mut self, min_lod: bool) -> Self { - self.min_lod = min_lod.into(); + 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 ImageViewMinLodCreateInfoEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub min_lod: f32, + 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 ImageViewMinLodCreateInfoEXT<'_> { +impl ::std::default::Default for PhysicalDeviceOpacityMicromapPropertiesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - min_lod: f32::default(), + 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 ImageViewMinLodCreateInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; } -unsafe impl ExtendsImageViewCreateInfo for ImageViewMinLodCreateInfoEXT<'_> {} -impl<'a> ImageViewMinLodCreateInfoEXT<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpacityMicromapPropertiesEXT<'_> {} +impl<'a> PhysicalDeviceOpacityMicromapPropertiesEXT<'a> { #[inline] - pub fn min_lod(mut self, min_lod: f32) -> Self { - self.min_lod = min_lod; + 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)] -#[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> { +#[doc = ""] +pub struct AccelerationStructureTrianglesOpacityMicromapEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub rasterization_order_color_attachment_access: Bool32, - pub rasterization_order_depth_attachment_access: Bool32, - pub rasterization_order_stencil_attachment_access: Bool32, + 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 ()>, } -impl ::std::default::Default for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'_> { +#[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(), - rasterization_order_color_attachment_access: Bool32::default(), - rasterization_order_depth_attachment_access: Bool32::default(), - rasterization_order_stencil_attachment_access: Bool32::default(), + 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 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> -{ +unsafe impl<'a> TaggedStructure for AccelerationStructureTrianglesOpacityMicromapEXT<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'_> -{ + StructureType::ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; } -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'_> +unsafe impl ExtendsAccelerationStructureGeometryTrianglesDataKHR + for AccelerationStructureTrianglesOpacityMicromapEXT<'_> { } -impl<'a> PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT<'a> { +impl<'a> AccelerationStructureTrianglesOpacityMicromapEXT<'a> { #[inline] - pub fn rasterization_order_color_attachment_access( - mut self, - rasterization_order_color_attachment_access: bool, - ) -> Self { - self.rasterization_order_color_attachment_access = - rasterization_order_color_attachment_access.into(); + pub fn index_type(mut self, index_type: IndexType) -> Self { + self.index_type = index_type; self } #[inline] - pub fn rasterization_order_depth_attachment_access( - mut self, - rasterization_order_depth_attachment_access: bool, - ) -> Self { - self.rasterization_order_depth_attachment_access = - rasterization_order_depth_attachment_access.into(); + pub fn index_buffer(mut self, index_buffer: DeviceOrHostAddressConstKHR) -> Self { + self.index_buffer = index_buffer; self } #[inline] - pub fn rasterization_order_stencil_attachment_access( - mut self, - rasterization_order_stencil_attachment_access: bool, - ) -> Self { - self.rasterization_order_stencil_attachment_access = - rasterization_order_stencil_attachment_access.into(); + 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 = ""] -pub struct PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { +#[doc = ""] +pub struct PipelinePropertiesIdentifierEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub linear_color_attachment: Bool32, + pub pipeline_identifier: [u8; UUID_SIZE], pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> { +impl ::std::default::Default for PipelinePropertiesIdentifierEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - linear_color_attachment: Bool32::default(), + pipeline_identifier: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; +unsafe impl<'a> TaggedStructure for PipelinePropertiesIdentifierEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_PROPERTIES_IDENTIFIER_EXT; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceLinearColorAttachmentFeaturesNV<'_> {} -impl<'a> PhysicalDeviceLinearColorAttachmentFeaturesNV<'a> { +impl<'a> PipelinePropertiesIdentifierEXT<'a> { #[inline] - pub fn linear_color_attachment(mut self, linear_color_attachment: bool) -> Self { - self.linear_color_attachment = linear_color_attachment.into(); + pub fn pipeline_identifier(mut self, pipeline_identifier: [u8; UUID_SIZE]) -> Self { + self.pipeline_identifier = pipeline_identifier; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { +#[doc = ""] +pub struct PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub graphics_pipeline_library: Bool32, + pub pipeline_properties_identifier: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'_> { +impl ::std::default::Default for PhysicalDevicePipelinePropertiesFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - graphics_pipeline_library: Bool32::default(), + pipeline_properties_identifier: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'_> -{ + StructureType::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'_> {} -impl<'a> PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelinePropertiesFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXT<'_> {} +impl<'a> PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { #[inline] - pub fn graphics_pipeline_library(mut self, graphics_pipeline_library: bool) -> Self { - self.graphics_pipeline_library = graphics_pipeline_library.into(); + pub fn pipeline_properties_identifier(mut self, pipeline_properties_identifier: bool) -> Self { + self.pipeline_properties_identifier = pipeline_properties_identifier.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub graphics_pipeline_library_fast_linking: Bool32, - pub graphics_pipeline_library_independent_interpolation_decoration: Bool32, + pub shader_early_and_late_fragment_tests: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'_> { +impl ::std::default::Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - graphics_pipeline_library_fast_linking: Bool32::default(), - graphics_pipeline_library_independent_interpolation_decoration: Bool32::default(), + shader_early_and_late_fragment_tests: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; + StructureType::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; } -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'_> +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'_> { } -impl<'a> PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT<'a> { - #[inline] - pub fn graphics_pipeline_library_fast_linking( - mut self, - graphics_pipeline_library_fast_linking: bool, - ) -> Self { - self.graphics_pipeline_library_fast_linking = graphics_pipeline_library_fast_linking.into(); - self - } +unsafe impl ExtendsDeviceCreateInfo + for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'_> +{ +} +impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { #[inline] - pub fn graphics_pipeline_library_independent_interpolation_decoration( + pub fn shader_early_and_late_fragment_tests( mut self, - graphics_pipeline_library_independent_interpolation_decoration: bool, + shader_early_and_late_fragment_tests: bool, ) -> Self { - self.graphics_pipeline_library_independent_interpolation_decoration = - graphics_pipeline_library_independent_interpolation_decoration.into(); + self.shader_early_and_late_fragment_tests = shader_early_and_late_fragment_tests.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct GraphicsPipelineLibraryCreateInfoEXT<'a> { +#[doc = ""] +pub struct ExportMetalObjectCreateInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub flags: GraphicsPipelineLibraryFlagsEXT, + pub p_next: *const c_void, + pub export_object_type: ExportMetalObjectTypeFlagsEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for GraphicsPipelineLibraryCreateInfoEXT<'_> { +impl ::std::default::Default for ExportMetalObjectCreateInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - flags: GraphicsPipelineLibraryFlagsEXT::default(), + p_next: ::std::ptr::null(), + export_object_type: ExportMetalObjectTypeFlagsEXT::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for GraphicsPipelineLibraryCreateInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; +unsafe impl<'a> TaggedStructure for ExportMetalObjectCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECT_CREATE_INFO_EXT; } -unsafe impl ExtendsGraphicsPipelineCreateInfo for GraphicsPipelineLibraryCreateInfoEXT<'_> {} -impl<'a> GraphicsPipelineLibraryCreateInfoEXT<'a> { +unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} +unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXT<'_> {} +unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} +unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} +unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} +unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} +unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} +impl<'a> ExportMetalObjectCreateInfoEXT<'a> { #[inline] - pub fn flags(mut self, flags: GraphicsPipelineLibraryFlagsEXT) -> Self { - self.flags = flags; + pub fn export_object_type(mut self, export_object_type: ExportMetalObjectTypeFlagsEXT) -> Self { + self.export_object_type = export_object_type; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { +#[doc = ""] +pub struct ExportMetalObjectsInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub descriptor_set_host_mapping: Bool32, + pub p_next: *const c_void, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> { +impl ::std::default::Default for ExportMetalObjectsInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - descriptor_set_host_mapping: Bool32::default(), + p_next: ::std::ptr::null(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> -{ +unsafe impl<'a> TaggedStructure for ExportMetalObjectsInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECTS_INFO_EXT; } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'_> {} -impl<'a> PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE<'a> { - #[inline] - pub fn descriptor_set_host_mapping(mut self, descriptor_set_host_mapping: bool) -> Self { - self.descriptor_set_host_mapping = descriptor_set_host_mapping.into(); +pub unsafe trait ExtendsExportMetalObjectsInfoEXT {} +impl<'a> ExportMetalObjectsInfoEXT<'a> { + #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] + #[doc = r" method only exists on structs that can be passed to a function directly. Only"] + #[doc = r" valid extension structs can be pushed into the chain."] + #[doc = r" If the chain looks like `A -> B -> C`, and you call `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))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct DescriptorSetBindingReferenceVALVE<'a> { +#[doc = ""] +pub struct ExportMetalDeviceInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub descriptor_set_layout: DescriptorSetLayout, - pub binding: u32, + pub mtl_device: MTLDevice_id, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetBindingReferenceVALVE<'_> { +impl ::std::default::Default for ExportMetalDeviceInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - descriptor_set_layout: DescriptorSetLayout::default(), - binding: u32::default(), + mtl_device: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for DescriptorSetBindingReferenceVALVE<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::DESCRIPTOR_SET_BINDING_REFERENCE_VALVE; +unsafe impl<'a> TaggedStructure for ExportMetalDeviceInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_DEVICE_INFO_EXT; } -impl<'a> DescriptorSetBindingReferenceVALVE<'a> { - #[inline] - pub fn descriptor_set_layout(mut self, descriptor_set_layout: DescriptorSetLayout) -> Self { - self.descriptor_set_layout = descriptor_set_layout; - self - } +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXT<'_> {} +impl<'a> ExportMetalDeviceInfoEXT<'a> { #[inline] - pub fn binding(mut self, binding: u32) -> Self { - self.binding = binding; + pub fn mtl_device(mut self, mtl_device: MTLDevice_id) -> Self { + self.mtl_device = mtl_device; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct DescriptorSetLayoutHostMappingInfoVALVE<'a> { +#[doc = ""] +pub struct ExportMetalCommandQueueInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub descriptor_offset: usize, - pub descriptor_size: u32, + pub p_next: *const c_void, + pub queue: Queue, + pub mtl_command_queue: MTLCommandQueue_id, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for DescriptorSetLayoutHostMappingInfoVALVE<'_> { +impl ::std::default::Default for ExportMetalCommandQueueInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - descriptor_offset: usize::default(), - descriptor_size: u32::default(), + p_next: ::std::ptr::null(), + queue: Queue::default(), + mtl_command_queue: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for DescriptorSetLayoutHostMappingInfoVALVE<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE; +unsafe impl<'a> TaggedStructure for ExportMetalCommandQueueInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; } -impl<'a> DescriptorSetLayoutHostMappingInfoVALVE<'a> { +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXT<'_> {} +impl<'a> ExportMetalCommandQueueInfoEXT<'a> { #[inline] - pub fn descriptor_offset(mut self, descriptor_offset: usize) -> Self { - self.descriptor_offset = descriptor_offset; + pub fn queue(mut self, queue: Queue) -> Self { + self.queue = queue; self } #[inline] - pub fn descriptor_size(mut self, descriptor_size: u32) -> Self { - self.descriptor_size = descriptor_size; + pub fn mtl_command_queue(mut self, mtl_command_queue: MTLCommandQueue_id) -> Self { + self.mtl_command_queue = mtl_command_queue; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { +#[doc = ""] +pub struct ExportMetalBufferInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub shader_module_identifier: Bool32, + pub p_next: *const c_void, + pub memory: DeviceMemory, + pub mtl_buffer: MTLBuffer_id, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> { +impl ::std::default::Default for ExportMetalBufferInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - shader_module_identifier: Bool32::default(), + p_next: ::std::ptr::null(), + memory: DeviceMemory::default(), + mtl_buffer: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; +unsafe impl<'a> TaggedStructure for ExportMetalBufferInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_BUFFER_INFO_EXT; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'_> {} -impl<'a> PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXT<'_> {} +impl<'a> ExportMetalBufferInfoEXT<'a> { #[inline] - pub fn shader_module_identifier(mut self, shader_module_identifier: bool) -> Self { - self.shader_module_identifier = shader_module_identifier.into(); + pub fn memory(mut self, memory: DeviceMemory) -> Self { + self.memory = memory; + self + } + #[inline] + pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { + self.mtl_buffer = mtl_buffer; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { +#[doc = ""] +pub struct ImportMetalBufferInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], + pub p_next: *const c_void, + pub mtl_buffer: MTLBuffer_id, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_> { +impl ::std::default::Default for ImportMetalBufferInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - shader_module_identifier_algorithm_uuid: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + mtl_buffer: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; -} -unsafe impl ExtendsPhysicalDeviceProperties2 - for PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'_> -{ +unsafe impl<'a> TaggedStructure for ImportMetalBufferInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_BUFFER_INFO_EXT; } -impl<'a> PhysicalDeviceShaderModuleIdentifierPropertiesEXT<'a> { +unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXT<'_> {} +impl<'a> ImportMetalBufferInfoEXT<'a> { #[inline] - pub fn shader_module_identifier_algorithm_uuid( - mut self, - shader_module_identifier_algorithm_uuid: [u8; UUID_SIZE], - ) -> Self { - self.shader_module_identifier_algorithm_uuid = shader_module_identifier_algorithm_uuid; + pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { + self.mtl_buffer = mtl_buffer; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { +#[doc = ""] +pub struct ExportMetalTextureInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub identifier_size: u32, - pub p_identifier: *const u8, + pub image: Image, + pub image_view: ImageView, + pub buffer_view: BufferView, + pub plane: ImageAspectFlags, + pub mtl_texture: MTLTexture_id, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelineShaderStageModuleIdentifierCreateInfoEXT<'_> { +impl ::std::default::Default for ExportMetalTextureInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - identifier_size: u32::default(), - p_identifier: ::std::ptr::null(), + image: Image::default(), + image_view: ImageView::default(), + buffer_view: BufferView::default(), + plane: ImageAspectFlags::default(), + mtl_texture: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; -} -unsafe impl ExtendsPipelineShaderStageCreateInfo - for PipelineShaderStageModuleIdentifierCreateInfoEXT<'_> -{ +unsafe impl<'a> TaggedStructure for ExportMetalTextureInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_TEXTURE_INFO_EXT; } -impl<'a> PipelineShaderStageModuleIdentifierCreateInfoEXT<'a> { +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXT<'_> {} +impl<'a> ExportMetalTextureInfoEXT<'a> { #[inline] - pub fn identifier(mut self, identifier: &'a [u8]) -> Self { - self.identifier_size = identifier.len() as _; - self.p_identifier = identifier.as_ptr(); + pub fn image(mut self, image: Image) -> Self { + self.image = image; + self + } + #[inline] + pub fn image_view(mut self, image_view: ImageView) -> Self { + self.image_view = image_view; + self + } + #[inline] + pub fn buffer_view(mut self, buffer_view: BufferView) -> Self { + self.buffer_view = buffer_view; + self + } + #[inline] + pub fn plane(mut self, plane: ImageAspectFlags) -> Self { + self.plane = plane; + self + } + #[inline] + pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { + self.mtl_texture = mtl_texture; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ShaderModuleIdentifierEXT<'a> { +#[doc = ""] +pub struct ImportMetalTextureInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub identifier_size: u32, - pub identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT], + pub p_next: *const c_void, + pub plane: ImageAspectFlags, + pub mtl_texture: MTLTexture_id, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ShaderModuleIdentifierEXT<'_> { +impl ::std::default::Default for ImportMetalTextureInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - identifier_size: u32::default(), - identifier: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null(), + plane: ImageAspectFlags::default(), + mtl_texture: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ShaderModuleIdentifierEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::SHADER_MODULE_IDENTIFIER_EXT; +unsafe impl<'a> TaggedStructure for ImportMetalTextureInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_TEXTURE_INFO_EXT; } -impl<'a> ShaderModuleIdentifierEXT<'a> { +unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXT<'_> {} +impl<'a> ImportMetalTextureInfoEXT<'a> { #[inline] - pub fn identifier_size(mut self, identifier_size: u32) -> Self { - self.identifier_size = identifier_size; + pub fn plane(mut self, plane: ImageAspectFlags) -> Self { + self.plane = plane; self } #[inline] - pub fn identifier(mut self, identifier: [u8; MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]) -> Self { - self.identifier = identifier; + pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { + self.mtl_texture = mtl_texture; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ImageCompressionControlEXT<'a> { +#[doc = ""] +pub struct ExportMetalIOSurfaceInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub flags: ImageCompressionFlagsEXT, - pub compression_control_plane_count: u32, - pub p_fixed_rate_flags: *mut ImageCompressionFixedRateFlagsEXT, + pub image: Image, + pub io_surface: IOSurfaceRef, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageCompressionControlEXT<'_> { +impl ::std::default::Default for ExportMetalIOSurfaceInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - flags: ImageCompressionFlagsEXT::default(), - compression_control_plane_count: u32::default(), - p_fixed_rate_flags: ::std::ptr::null_mut(), + image: Image::default(), + io_surface: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ImageCompressionControlEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_CONTROL_EXT; +unsafe impl<'a> TaggedStructure for ExportMetalIOSurfaceInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_IO_SURFACE_INFO_EXT; } -unsafe impl ExtendsImageCreateInfo for ImageCompressionControlEXT<'_> {} -unsafe impl ExtendsSwapchainCreateInfoKHR for ImageCompressionControlEXT<'_> {} -unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for ImageCompressionControlEXT<'_> {} -impl<'a> ImageCompressionControlEXT<'a> { +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXT<'_> {} +impl<'a> ExportMetalIOSurfaceInfoEXT<'a> { #[inline] - pub fn flags(mut self, flags: ImageCompressionFlagsEXT) -> Self { - self.flags = flags; + pub fn image(mut self, image: Image) -> Self { + self.image = image; self } #[inline] - pub fn fixed_rate_flags( - mut self, - fixed_rate_flags: &'a mut [ImageCompressionFixedRateFlagsEXT], - ) -> Self { - self.compression_control_plane_count = fixed_rate_flags.len() as _; - self.p_fixed_rate_flags = fixed_rate_flags.as_mut_ptr(); + pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self { + self.io_surface = io_surface; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { +#[doc = ""] +pub struct ImportMetalIOSurfaceInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub image_compression_control: Bool32, + pub p_next: *const c_void, + pub io_surface: IOSurfaceRef, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImageCompressionControlFeaturesEXT<'_> { +impl ::std::default::Default for ImportMetalIOSurfaceInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - image_compression_control: Bool32::default(), + p_next: ::std::ptr::null(), + io_surface: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceImageCompressionControlFeaturesEXT<'_> -{ +unsafe impl<'a> TaggedStructure for ImportMetalIOSurfaceInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_IO_SURFACE_INFO_EXT; } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageCompressionControlFeaturesEXT<'_> {} -impl<'a> PhysicalDeviceImageCompressionControlFeaturesEXT<'a> { +unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXT<'_> {} +impl<'a> ImportMetalIOSurfaceInfoEXT<'a> { #[inline] - pub fn image_compression_control(mut self, image_compression_control: bool) -> Self { - self.image_compression_control = image_compression_control.into(); + pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self { + self.io_surface = io_surface; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ImageCompressionPropertiesEXT<'a> { +#[doc = ""] +pub struct ExportMetalSharedEventInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub image_compression_flags: ImageCompressionFlagsEXT, - pub image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, + pub p_next: *const c_void, + pub semaphore: Semaphore, + pub event: Event, + pub mtl_shared_event: MTLSharedEvent_id, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageCompressionPropertiesEXT<'_> { +impl ::std::default::Default for ExportMetalSharedEventInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - image_compression_flags: ImageCompressionFlagsEXT::default(), - image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT::default(), + p_next: ::std::ptr::null(), + semaphore: Semaphore::default(), + event: Event::default(), + mtl_shared_event: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ImageCompressionPropertiesEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_COMPRESSION_PROPERTIES_EXT; +unsafe impl<'a> TaggedStructure for ExportMetalSharedEventInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_SHARED_EVENT_INFO_EXT; } -unsafe impl ExtendsImageFormatProperties2 for ImageCompressionPropertiesEXT<'_> {} -unsafe impl ExtendsSurfaceFormat2KHR for ImageCompressionPropertiesEXT<'_> {} -unsafe impl ExtendsSubresourceLayout2EXT for ImageCompressionPropertiesEXT<'_> {} -impl<'a> ImageCompressionPropertiesEXT<'a> { +unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXT<'_> {} +impl<'a> ExportMetalSharedEventInfoEXT<'a> { #[inline] - pub fn image_compression_flags( - mut self, - image_compression_flags: ImageCompressionFlagsEXT, - ) -> Self { - self.image_compression_flags = image_compression_flags; + pub fn semaphore(mut self, semaphore: Semaphore) -> Self { + self.semaphore = semaphore; self } #[inline] - pub fn image_compression_fixed_rate_flags( - mut self, - image_compression_fixed_rate_flags: ImageCompressionFixedRateFlagsEXT, - ) -> Self { - self.image_compression_fixed_rate_flags = image_compression_fixed_rate_flags; + pub fn event(mut self, event: Event) -> Self { + self.event = event; + self + } + #[inline] + pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { + self.mtl_shared_event = mtl_shared_event; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { +#[doc = ""] +pub struct ImportMetalSharedEventInfoEXT<'a> { pub s_type: StructureType, - pub p_next: *mut c_void, - pub image_compression_control_swapchain: Bool32, + pub p_next: *const c_void, + pub mtl_shared_event: MTLSharedEvent_id, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'_> { +impl ::std::default::Default for ImportMetalSharedEventInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - image_compression_control_swapchain: Bool32::default(), + p_next: ::std::ptr::null(), + mtl_shared_event: unsafe { ::std::mem::zeroed() }, _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'_> -{ +unsafe impl<'a> TaggedStructure for ImportMetalSharedEventInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_SHARED_EVENT_INFO_EXT; } -impl<'a> PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT<'a> { +unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXT<'_> {} +unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXT<'_> {} +impl<'a> ImportMetalSharedEventInfoEXT<'a> { #[inline] - pub fn image_compression_control_swapchain( - mut self, - image_compression_control_swapchain: bool, - ) -> Self { - self.image_compression_control_swapchain = image_compression_control_swapchain.into(); + pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { + self.mtl_shared_event = mtl_shared_event; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ImageSubresource2EXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub image_subresource: ImageSubresource, + pub non_seamless_cube_map: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImageSubresource2EXT<'_> { +impl ::std::default::Default for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - image_subresource: ImageSubresource::default(), + non_seamless_cube_map: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ImageSubresource2EXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_SUBRESOURCE_2_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; } -impl<'a> ImageSubresource2EXT<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { #[inline] - pub fn image_subresource(mut self, image_subresource: ImageSubresource) -> Self { - self.image_subresource = image_subresource; + pub fn non_seamless_cube_map(mut self, non_seamless_cube_map: bool) -> Self { + self.non_seamless_cube_map = non_seamless_cube_map.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct SubresourceLayout2EXT<'a> { +#[doc = ""] +pub struct PhysicalDevicePipelineRobustnessFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub subresource_layout: SubresourceLayout, + pub pipeline_robustness: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for SubresourceLayout2EXT<'_> { +impl ::std::default::Default for PhysicalDevicePipelineRobustnessFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - subresource_layout: SubresourceLayout::default(), + pipeline_robustness: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for SubresourceLayout2EXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::SUBRESOURCE_LAYOUT_2_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDevicePipelineRobustnessFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT; } -pub unsafe trait ExtendsSubresourceLayout2EXT {} -impl<'a> SubresourceLayout2EXT<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineRobustnessFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXT<'_> {} +impl<'a> PhysicalDevicePipelineRobustnessFeaturesEXT<'a> { #[inline] - pub fn subresource_layout(mut self, subresource_layout: SubresourceLayout) -> Self { - self.subresource_layout = subresource_layout; - self - } - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `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; - } + pub fn pipeline_robustness(mut self, pipeline_robustness: bool) -> Self { + self.pipeline_robustness = pipeline_robustness.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct RenderPassCreationControlEXT<'a> { +#[doc = ""] +pub struct PipelineRobustnessCreateInfoEXT<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub disallow_merging: Bool32, + pub storage_buffers: PipelineRobustnessBufferBehaviorEXT, + pub uniform_buffers: PipelineRobustnessBufferBehaviorEXT, + pub vertex_inputs: PipelineRobustnessBufferBehaviorEXT, + pub images: PipelineRobustnessImageBehaviorEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassCreationControlEXT<'_> { +impl ::std::default::Default for PipelineRobustnessCreateInfoEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - disallow_merging: Bool32::default(), + storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(), + images: PipelineRobustnessImageBehaviorEXT::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for RenderPassCreationControlEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::RENDER_PASS_CREATION_CONTROL_EXT; +unsafe impl<'a> TaggedStructure for PipelineRobustnessCreateInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT; } -unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationControlEXT<'_> {} -unsafe impl ExtendsSubpassDescription2 for RenderPassCreationControlEXT<'_> {} -impl<'a> RenderPassCreationControlEXT<'a> { +unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXT<'_> {} +unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXT<'_> {} +unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXT<'_> {} +unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXT<'_> {} +impl<'a> PipelineRobustnessCreateInfoEXT<'a> { #[inline] - pub fn disallow_merging(mut self, disallow_merging: bool) -> Self { - self.disallow_merging = disallow_merging.into(); + pub fn storage_buffers(mut self, storage_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self { + self.storage_buffers = storage_buffers; self } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone, Default)] -#[doc = ""] -pub struct RenderPassCreationFeedbackInfoEXT { - pub post_merge_subpass_count: u32, -} -impl RenderPassCreationFeedbackInfoEXT { #[inline] - pub fn post_merge_subpass_count(mut self, post_merge_subpass_count: u32) -> Self { - self.post_merge_subpass_count = post_merge_subpass_count; + pub fn uniform_buffers(mut self, uniform_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self { + self.uniform_buffers = uniform_buffers; + self + } + #[inline] + pub fn vertex_inputs(mut self, vertex_inputs: PipelineRobustnessBufferBehaviorEXT) -> Self { + self.vertex_inputs = vertex_inputs; + self + } + #[inline] + pub fn images(mut self, images: PipelineRobustnessImageBehaviorEXT) -> Self { + self.images = images; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct RenderPassCreationFeedbackCreateInfoEXT<'a> { +#[doc = ""] +pub struct PhysicalDevicePipelineRobustnessPropertiesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub p_render_pass_feedback: *mut RenderPassCreationFeedbackInfoEXT, + pub p_next: *mut c_void, + pub default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT, + pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT, + pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT, + pub default_robustness_images: PipelineRobustnessImageBehaviorEXT, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassCreationFeedbackCreateInfoEXT<'_> { +impl ::std::default::Default for PhysicalDevicePipelineRobustnessPropertiesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - p_render_pass_feedback: ::std::ptr::null_mut(), + p_next: ::std::ptr::null_mut(), + default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(), + default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(), + default_robustness_images: PipelineRobustnessImageBehaviorEXT::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for RenderPassCreationFeedbackCreateInfoEXT<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDevicePipelineRobustnessPropertiesEXT<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT; + StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT; } -unsafe impl ExtendsRenderPassCreateInfo2 for RenderPassCreationFeedbackCreateInfoEXT<'_> {} -impl<'a> RenderPassCreationFeedbackCreateInfoEXT<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePipelineRobustnessPropertiesEXT<'_> {} +impl<'a> PhysicalDevicePipelineRobustnessPropertiesEXT<'a> { #[inline] - pub fn render_pass_feedback( + pub fn default_robustness_storage_buffers( mut self, - render_pass_feedback: &'a mut RenderPassCreationFeedbackInfoEXT, + default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT, ) -> Self { - self.p_render_pass_feedback = render_pass_feedback; + self.default_robustness_storage_buffers = default_robustness_storage_buffers; self } -} -#[repr(C)] -#[derive(Copy, Clone)] -#[doc = ""] -pub struct RenderPassSubpassFeedbackInfoEXT { - pub subpass_merge_status: SubpassMergeStatusEXT, - pub description: [c_char; MAX_DESCRIPTION_SIZE], - pub post_merge_index: u32, -} -#[cfg(feature = "debug")] -impl fmt::Debug for RenderPassSubpassFeedbackInfoEXT { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("RenderPassSubpassFeedbackInfoEXT") - .field("subpass_merge_status", &self.subpass_merge_status) - .field("description", &unsafe { - ::std::ffi::CStr::from_ptr(self.description.as_ptr()) - }) - .field("post_merge_index", &self.post_merge_index) - .finish() - } -} -impl ::std::default::Default for RenderPassSubpassFeedbackInfoEXT { - #[inline] - fn default() -> Self { - Self { - subpass_merge_status: SubpassMergeStatusEXT::default(), - description: unsafe { ::std::mem::zeroed() }, - post_merge_index: u32::default(), - } - } -} -impl RenderPassSubpassFeedbackInfoEXT { - #[inline] - pub fn subpass_merge_status(mut self, subpass_merge_status: SubpassMergeStatusEXT) -> Self { - self.subpass_merge_status = subpass_merge_status; + #[inline] + pub fn default_robustness_uniform_buffers( + mut self, + default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT, + ) -> Self { + self.default_robustness_uniform_buffers = default_robustness_uniform_buffers; self } #[inline] - pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { - self.description = description; + pub fn default_robustness_vertex_inputs( + mut self, + default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT, + ) -> Self { + self.default_robustness_vertex_inputs = default_robustness_vertex_inputs; self } #[inline] - pub fn post_merge_index(mut self, post_merge_index: u32) -> Self { - self.post_merge_index = post_merge_index; + pub fn default_robustness_images( + mut self, + default_robustness_images: PipelineRobustnessImageBehaviorEXT, + ) -> Self { + self.default_robustness_images = default_robustness_images; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct RenderPassSubpassFeedbackCreateInfoEXT<'a> { +#[doc = ""] +pub struct ImageViewSampleWeightCreateInfoQCOM<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub p_subpass_feedback: *mut RenderPassSubpassFeedbackInfoEXT, + pub filter_center: Offset2D, + pub filter_size: Extent2D, + pub num_phases: u32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for RenderPassSubpassFeedbackCreateInfoEXT<'_> { +impl ::std::default::Default for ImageViewSampleWeightCreateInfoQCOM<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - p_subpass_feedback: ::std::ptr::null_mut(), + filter_center: Offset2D::default(), + filter_size: Extent2D::default(), + num_phases: u32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for RenderPassSubpassFeedbackCreateInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT; +unsafe impl<'a> TaggedStructure for ImageViewSampleWeightCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; } -unsafe impl ExtendsSubpassDescription2 for RenderPassSubpassFeedbackCreateInfoEXT<'_> {} -impl<'a> RenderPassSubpassFeedbackCreateInfoEXT<'a> { +unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOM<'_> {} +impl<'a> ImageViewSampleWeightCreateInfoQCOM<'a> { #[inline] - pub fn subpass_feedback( - mut self, - subpass_feedback: &'a mut RenderPassSubpassFeedbackInfoEXT, - ) -> Self { - self.p_subpass_feedback = subpass_feedback; + pub fn filter_center(mut self, filter_center: Offset2D) -> Self { + self.filter_center = filter_center; + self + } + #[inline] + pub fn filter_size(mut self, filter_size: Extent2D) -> Self { + self.filter_size = filter_size; + self + } + #[inline] + pub fn num_phases(mut self, num_phases: u32) -> Self { + self.num_phases = num_phases; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceImageProcessingFeaturesQCOM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub subpass_merge_feedback: Bool32, + pub texture_sample_weighted: Bool32, + pub texture_box_filter: Bool32, + pub texture_block_match: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'_> { +impl ::std::default::Default for PhysicalDeviceImageProcessingFeaturesQCOM<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - subpass_merge_feedback: Bool32::default(), + texture_sample_weighted: Bool32::default(), + texture_box_filter: Bool32::default(), + texture_block_match: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDeviceImageProcessingFeaturesQCOM<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; + StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'_> {} -impl<'a> PhysicalDeviceSubpassMergeFeedbackFeaturesEXT<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageProcessingFeaturesQCOM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceImageProcessingFeaturesQCOM<'a> { #[inline] - pub fn subpass_merge_feedback(mut self, subpass_merge_feedback: bool) -> Self { - self.subpass_merge_feedback = subpass_merge_feedback.into(); + pub fn texture_sample_weighted(mut self, texture_sample_weighted: bool) -> Self { + self.texture_sample_weighted = texture_sample_weighted.into(); + self + } + #[inline] + pub fn texture_box_filter(mut self, texture_box_filter: bool) -> Self { + self.texture_box_filter = texture_box_filter.into(); + self + } + #[inline] + pub fn texture_block_match(mut self, texture_block_match: bool) -> Self { + self.texture_block_match = texture_block_match.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PipelinePropertiesIdentifierEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceImageProcessingPropertiesQCOM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub pipeline_identifier: [u8; UUID_SIZE], + pub max_weight_filter_phases: u32, + pub max_weight_filter_dimension: Extent2D, + pub max_block_match_region: Extent2D, + pub max_box_filter_block_size: Extent2D, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PipelinePropertiesIdentifierEXT<'_> { +impl ::std::default::Default for PhysicalDeviceImageProcessingPropertiesQCOM<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - pipeline_identifier: unsafe { ::std::mem::zeroed() }, + max_weight_filter_phases: u32::default(), + max_weight_filter_dimension: Extent2D::default(), + max_block_match_region: Extent2D::default(), + max_box_filter_block_size: Extent2D::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PipelinePropertiesIdentifierEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_PROPERTIES_IDENTIFIER_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceImageProcessingPropertiesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; } -impl<'a> PipelinePropertiesIdentifierEXT<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageProcessingPropertiesQCOM<'_> {} +impl<'a> PhysicalDeviceImageProcessingPropertiesQCOM<'a> { #[inline] - pub fn pipeline_identifier(mut self, pipeline_identifier: [u8; UUID_SIZE]) -> Self { - self.pipeline_identifier = pipeline_identifier; + pub fn max_weight_filter_phases(mut self, max_weight_filter_phases: u32) -> Self { + self.max_weight_filter_phases = max_weight_filter_phases; + self + } + #[inline] + pub fn max_weight_filter_dimension(mut self, max_weight_filter_dimension: Extent2D) -> Self { + self.max_weight_filter_dimension = max_weight_filter_dimension; + self + } + #[inline] + pub fn max_block_match_region(mut self, max_block_match_region: Extent2D) -> Self { + self.max_block_match_region = max_block_match_region; + self + } + #[inline] + pub fn max_box_filter_block_size(mut self, max_box_filter_block_size: Extent2D) -> Self { + self.max_box_filter_block_size = max_box_filter_block_size; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceTilePropertiesFeaturesQCOM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub pipeline_properties_identifier: Bool32, + pub tile_properties: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePipelinePropertiesFeaturesEXT<'_> { +impl ::std::default::Default for PhysicalDeviceTilePropertiesFeaturesQCOM<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - pipeline_properties_identifier: Bool32::default(), + tile_properties: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDeviceTilePropertiesFeaturesQCOM<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; + StructureType::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelinePropertiesFeaturesEXT<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelinePropertiesFeaturesEXT<'_> {} -impl<'a> PhysicalDevicePipelinePropertiesFeaturesEXT<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceTilePropertiesFeaturesQCOM<'a> { #[inline] - pub fn pipeline_properties_identifier(mut self, pipeline_properties_identifier: bool) -> Self { - self.pipeline_properties_identifier = pipeline_properties_identifier.into(); + pub fn tile_properties(mut self, tile_properties: bool) -> Self { + self.tile_properties = tile_properties.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { +#[doc = ""] +pub struct TilePropertiesQCOM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub shader_early_and_late_fragment_tests: Bool32, + pub tile_size: Extent3D, + pub apron_size: Extent2D, + pub origin: Offset2D, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'_> { +impl ::std::default::Default for TilePropertiesQCOM<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - shader_early_and_late_fragment_tests: Bool32::default(), + tile_size: Extent3D::default(), + apron_size: Extent2D::default(), + origin: Offset2D::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; -} -unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'_> -{ -} -unsafe impl ExtendsDeviceCreateInfo - for PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'_> -{ +unsafe impl<'a> TaggedStructure for TilePropertiesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::TILE_PROPERTIES_QCOM; } -impl<'a> PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD<'a> { +impl<'a> TilePropertiesQCOM<'a> { #[inline] - pub fn shader_early_and_late_fragment_tests( - mut self, - shader_early_and_late_fragment_tests: bool, - ) -> Self { - self.shader_early_and_late_fragment_tests = shader_early_and_late_fragment_tests.into(); + pub fn tile_size(mut self, tile_size: Extent3D) -> Self { + self.tile_size = tile_size; self } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] -#[doc = ""] -pub struct ExportMetalObjectCreateInfoEXT<'a> { - pub s_type: StructureType, - pub p_next: *const c_void, - pub export_object_type: ExportMetalObjectTypeFlagsEXT, - pub _marker: PhantomData<&'a ()>, -} -impl ::std::default::Default for ExportMetalObjectCreateInfoEXT<'_> { #[inline] - fn default() -> Self { - Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - export_object_type: ExportMetalObjectTypeFlagsEXT::default(), - _marker: PhantomData, - } + pub fn apron_size(mut self, apron_size: Extent2D) -> Self { + self.apron_size = apron_size; + self } -} -unsafe impl<'a> TaggedStructure for ExportMetalObjectCreateInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECT_CREATE_INFO_EXT; -} -unsafe impl ExtendsInstanceCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} -unsafe impl ExtendsMemoryAllocateInfo for ExportMetalObjectCreateInfoEXT<'_> {} -unsafe impl ExtendsImageCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} -unsafe impl ExtendsImageViewCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} -unsafe impl ExtendsBufferViewCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} -unsafe impl ExtendsSemaphoreCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} -unsafe impl ExtendsEventCreateInfo for ExportMetalObjectCreateInfoEXT<'_> {} -impl<'a> ExportMetalObjectCreateInfoEXT<'a> { #[inline] - pub fn export_object_type(mut self, export_object_type: ExportMetalObjectTypeFlagsEXT) -> Self { - self.export_object_type = export_object_type; + pub fn origin(mut self, origin: Offset2D) -> Self { + self.origin = origin; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ExportMetalObjectsInfoEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { pub s_type: StructureType, - pub p_next: *const c_void, + pub p_next: *mut c_void, + pub amigo_profiling: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportMetalObjectsInfoEXT<'_> { +impl ::std::default::Default for PhysicalDeviceAmigoProfilingFeaturesSEC<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), + p_next: ::std::ptr::null_mut(), + amigo_profiling: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ExportMetalObjectsInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_OBJECTS_INFO_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC; } -pub unsafe trait ExtendsExportMetalObjectsInfoEXT {} -impl<'a> ExportMetalObjectsInfoEXT<'a> { - #[doc = r" Prepends the given extension struct between the root and the first pointer. This"] - #[doc = r" method only exists on structs that can be passed to a function directly. Only"] - #[doc = r" valid extension structs can be pushed into the chain."] - #[doc = r" If the chain looks like `A -> B -> C`, and you call `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; - } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSEC<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSEC<'_> {} +impl<'a> PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { + #[inline] + pub fn amigo_profiling(mut self, amigo_profiling: bool) -> Self { + self.amigo_profiling = amigo_profiling.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ExportMetalDeviceInfoEXT<'a> { +#[doc = ""] +pub struct AmigoProfilingSubmitInfoSEC<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub mtl_device: MTLDevice_id, + pub first_draw_timestamp: u64, + pub swap_buffer_timestamp: u64, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportMetalDeviceInfoEXT<'_> { +impl ::std::default::Default for AmigoProfilingSubmitInfoSEC<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - mtl_device: unsafe { ::std::mem::zeroed() }, + first_draw_timestamp: u64::default(), + swap_buffer_timestamp: u64::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ExportMetalDeviceInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_DEVICE_INFO_EXT; +unsafe impl<'a> TaggedStructure for AmigoProfilingSubmitInfoSEC<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::AMIGO_PROFILING_SUBMIT_INFO_SEC; } -unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalDeviceInfoEXT<'_> {} -impl<'a> ExportMetalDeviceInfoEXT<'a> { +unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSEC<'_> {} +impl<'a> AmigoProfilingSubmitInfoSEC<'a> { #[inline] - pub fn mtl_device(mut self, mtl_device: MTLDevice_id) -> Self { - self.mtl_device = mtl_device; + pub fn first_draw_timestamp(mut self, first_draw_timestamp: u64) -> Self { + self.first_draw_timestamp = first_draw_timestamp; + self + } + #[inline] + pub fn swap_buffer_timestamp(mut self, swap_buffer_timestamp: u64) -> Self { + self.swap_buffer_timestamp = swap_buffer_timestamp; self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ExportMetalCommandQueueInfoEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub queue: Queue, - pub mtl_command_queue: MTLCommandQueue_id, + pub p_next: *mut c_void, + pub attachment_feedback_loop_layout: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportMetalCommandQueueInfoEXT<'_> { +impl ::std::default::Default for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - queue: Queue::default(), - mtl_command_queue: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), + attachment_feedback_loop_layout: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ExportMetalCommandQueueInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_COMMAND_QUEUE_INFO_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; } -unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalCommandQueueInfoEXT<'_> {} -impl<'a> ExportMetalCommandQueueInfoEXT<'a> { - #[inline] - pub fn queue(mut self, queue: Queue) -> Self { - self.queue = queue; - self - } +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { #[inline] - pub fn mtl_command_queue(mut self, mtl_command_queue: MTLCommandQueue_id) -> Self { - self.mtl_command_queue = mtl_command_queue; + pub fn attachment_feedback_loop_layout( + mut self, + attachment_feedback_loop_layout: bool, + ) -> Self { + self.attachment_feedback_loop_layout = attachment_feedback_loop_layout.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ExportMetalBufferInfoEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceDepthClampZeroOneFeaturesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub memory: DeviceMemory, - pub mtl_buffer: MTLBuffer_id, + pub p_next: *mut c_void, + pub depth_clamp_zero_one: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportMetalBufferInfoEXT<'_> { +impl ::std::default::Default for PhysicalDeviceDepthClampZeroOneFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - memory: DeviceMemory::default(), - mtl_buffer: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), + depth_clamp_zero_one: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ExportMetalBufferInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_BUFFER_INFO_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceDepthClampZeroOneFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT; } -unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalBufferInfoEXT<'_> {} -impl<'a> ExportMetalBufferInfoEXT<'a> { - #[inline] - pub fn memory(mut self, memory: DeviceMemory) -> Self { - self.memory = memory; - self - } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClampZeroOneFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceDepthClampZeroOneFeaturesEXT<'a> { #[inline] - pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { - self.mtl_buffer = mtl_buffer; + pub fn depth_clamp_zero_one(mut self, depth_clamp_zero_one: bool) -> Self { + self.depth_clamp_zero_one = depth_clamp_zero_one.into(); self } } #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ImportMetalBufferInfoEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub mtl_buffer: MTLBuffer_id, + pub p_next: *mut c_void, + pub report_address_binding: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMetalBufferInfoEXT<'_> { +impl ::std::default::Default for PhysicalDeviceAddressBindingReportFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - mtl_buffer: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), + report_address_binding: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ImportMetalBufferInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_BUFFER_INFO_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; } -unsafe impl ExtendsMemoryAllocateInfo for ImportMetalBufferInfoEXT<'_> {} -impl<'a> ImportMetalBufferInfoEXT<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAddressBindingReportFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAddressBindingReportFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceAddressBindingReportFeaturesEXT<'a> { #[inline] - pub fn mtl_buffer(mut self, mtl_buffer: MTLBuffer_id) -> Self { - self.mtl_buffer = mtl_buffer; + 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 ExportMetalTextureInfoEXT<'a> { +#[doc = ""] +pub struct DeviceAddressBindingCallbackDataEXT<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub image: Image, - pub image_view: ImageView, - pub buffer_view: BufferView, - pub plane: ImageAspectFlags, - pub mtl_texture: MTLTexture_id, + 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 ExportMetalTextureInfoEXT<'_> { +impl ::std::default::Default for DeviceAddressBindingCallbackDataEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - image: Image::default(), - image_view: ImageView::default(), - buffer_view: BufferView::default(), - plane: ImageAspectFlags::default(), - mtl_texture: unsafe { ::std::mem::zeroed() }, + 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 ExportMetalTextureInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_TEXTURE_INFO_EXT; +unsafe impl<'a> TaggedStructure for DeviceAddressBindingCallbackDataEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; } -unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalTextureInfoEXT<'_> {} -impl<'a> ExportMetalTextureInfoEXT<'a> { - #[inline] - pub fn image(mut self, image: Image) -> Self { - self.image = image; - self - } +unsafe impl ExtendsDebugUtilsMessengerCallbackDataEXT for DeviceAddressBindingCallbackDataEXT<'_> {} +impl<'a> DeviceAddressBindingCallbackDataEXT<'a> { #[inline] - pub fn image_view(mut self, image_view: ImageView) -> Self { - self.image_view = image_view; + pub fn flags(mut self, flags: DeviceAddressBindingFlagsEXT) -> Self { + self.flags = flags; self } #[inline] - pub fn buffer_view(mut self, buffer_view: BufferView) -> Self { - self.buffer_view = buffer_view; + pub fn base_address(mut self, base_address: DeviceAddress) -> Self { + self.base_address = base_address; self } #[inline] - pub fn plane(mut self, plane: ImageAspectFlags) -> Self { - self.plane = plane; + pub fn size(mut self, size: DeviceSize) -> Self { + self.size = size; self } #[inline] - pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { - self.mtl_texture = mtl_texture; + 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 ImportMetalTextureInfoEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceOpticalFlowFeaturesNV<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub plane: ImageAspectFlags, - pub mtl_texture: MTLTexture_id, + pub p_next: *mut c_void, + pub optical_flow: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMetalTextureInfoEXT<'_> { +impl ::std::default::Default for PhysicalDeviceOpticalFlowFeaturesNV<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - plane: ImageAspectFlags::default(), - mtl_texture: unsafe { ::std::mem::zeroed() }, + p_next: ::std::ptr::null_mut(), + optical_flow: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ImportMetalTextureInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_TEXTURE_INFO_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceOpticalFlowFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; } -unsafe impl ExtendsImageCreateInfo for ImportMetalTextureInfoEXT<'_> {} -impl<'a> ImportMetalTextureInfoEXT<'a> { - #[inline] - pub fn plane(mut self, plane: ImageAspectFlags) -> Self { - self.plane = plane; - self - } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceOpticalFlowFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceOpticalFlowFeaturesNV<'_> {} +impl<'a> PhysicalDeviceOpticalFlowFeaturesNV<'a> { #[inline] - pub fn mtl_texture(mut self, mtl_texture: MTLTexture_id) -> Self { - self.mtl_texture = mtl_texture; + 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 ExportMetalIOSurfaceInfoEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceOpticalFlowPropertiesNV<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub image: Image, - pub io_surface: IOSurfaceRef, + 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 ExportMetalIOSurfaceInfoEXT<'_> { +impl ::std::default::Default for PhysicalDeviceOpticalFlowPropertiesNV<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - image: Image::default(), - io_surface: unsafe { ::std::mem::zeroed() }, + 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 ExportMetalIOSurfaceInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_IO_SURFACE_INFO_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceOpticalFlowPropertiesNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; } -unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalIOSurfaceInfoEXT<'_> {} -impl<'a> ExportMetalIOSurfaceInfoEXT<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceOpticalFlowPropertiesNV<'_> {} +impl<'a> PhysicalDeviceOpticalFlowPropertiesNV<'a> { #[inline] - pub fn image(mut self, image: Image) -> Self { - self.image = image; + 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 io_surface(mut self, io_surface: IOSurfaceRef) -> Self { - self.io_surface = io_surface; + 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 } -} -#[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] -#[derive(Copy, Clone)] -#[doc = ""] -pub struct ImportMetalIOSurfaceInfoEXT<'a> { - pub s_type: StructureType, - pub p_next: *const c_void, - pub io_surface: IOSurfaceRef, - pub _marker: PhantomData<&'a ()>, -} -impl ::std::default::Default for ImportMetalIOSurfaceInfoEXT<'_> { #[inline] - fn default() -> Self { - Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - io_surface: unsafe { ::std::mem::zeroed() }, - _marker: PhantomData, - } + pub fn max_height(mut self, max_height: u32) -> Self { + self.max_height = max_height; + self } -} -unsafe impl<'a> TaggedStructure for ImportMetalIOSurfaceInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_IO_SURFACE_INFO_EXT; -} -unsafe impl ExtendsImageCreateInfo for ImportMetalIOSurfaceInfoEXT<'_> {} -impl<'a> ImportMetalIOSurfaceInfoEXT<'a> { #[inline] - pub fn io_surface(mut self, io_surface: IOSurfaceRef) -> Self { - self.io_surface = io_surface; + 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 ExportMetalSharedEventInfoEXT<'a> { +#[doc = ""] +pub struct OpticalFlowImageFormatInfoNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub semaphore: Semaphore, - pub event: Event, - pub mtl_shared_event: MTLSharedEvent_id, + pub usage: OpticalFlowUsageFlagsNV, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ExportMetalSharedEventInfoEXT<'_> { +impl ::std::default::Default for OpticalFlowImageFormatInfoNV<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - semaphore: Semaphore::default(), - event: Event::default(), - mtl_shared_event: unsafe { ::std::mem::zeroed() }, + usage: OpticalFlowUsageFlagsNV::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ExportMetalSharedEventInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::EXPORT_METAL_SHARED_EVENT_INFO_EXT; +unsafe impl<'a> TaggedStructure for OpticalFlowImageFormatInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; } -unsafe impl ExtendsExportMetalObjectsInfoEXT for ExportMetalSharedEventInfoEXT<'_> {} -impl<'a> ExportMetalSharedEventInfoEXT<'a> { - #[inline] - pub fn semaphore(mut self, semaphore: Semaphore) -> Self { - self.semaphore = semaphore; - self - } - #[inline] - pub fn event(mut self, event: Event) -> Self { - self.event = event; - self - } +unsafe impl ExtendsPhysicalDeviceImageFormatInfo2 for OpticalFlowImageFormatInfoNV<'_> {} +unsafe impl ExtendsImageCreateInfo for OpticalFlowImageFormatInfoNV<'_> {} +impl<'a> OpticalFlowImageFormatInfoNV<'a> { #[inline] - pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { - self.mtl_shared_event = mtl_shared_event; + 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 ImportMetalSharedEventInfoEXT<'a> { +#[doc = ""] +pub struct OpticalFlowImageFormatPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *const c_void, - pub mtl_shared_event: MTLSharedEvent_id, + pub format: Format, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for ImportMetalSharedEventInfoEXT<'_> { +impl ::std::default::Default for OpticalFlowImageFormatPropertiesNV<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null(), - mtl_shared_event: unsafe { ::std::mem::zeroed() }, + format: Format::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for ImportMetalSharedEventInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMPORT_METAL_SHARED_EVENT_INFO_EXT; +unsafe impl<'a> TaggedStructure for OpticalFlowImageFormatPropertiesNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; } -unsafe impl ExtendsSemaphoreCreateInfo for ImportMetalSharedEventInfoEXT<'_> {} -unsafe impl ExtendsEventCreateInfo for ImportMetalSharedEventInfoEXT<'_> {} -impl<'a> ImportMetalSharedEventInfoEXT<'a> { +impl<'a> OpticalFlowImageFormatPropertiesNV<'a> { #[inline] - pub fn mtl_shared_event(mut self, mtl_shared_event: MTLSharedEvent_id) -> Self { - self.mtl_shared_event = mtl_shared_event; + 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 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { +#[doc = ""] +pub struct OpticalFlowSessionCreateInfoNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub non_seamless_cube_map: Bool32, + 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 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'_> { +impl ::std::default::Default for OpticalFlowSessionCreateInfoNV<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - non_seamless_cube_map: Bool32::default(), + 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 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; +unsafe impl<'a> TaggedStructure for OpticalFlowSessionCreateInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_SESSION_CREATE_INFO_NV; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'_> {} -impl<'a> PhysicalDeviceNonSeamlessCubeMapFeaturesEXT<'a> { +pub unsafe trait ExtendsOpticalFlowSessionCreateInfoNV {} +impl<'a> OpticalFlowSessionCreateInfoNV<'a> { #[inline] - pub fn non_seamless_cube_map(mut self, non_seamless_cube_map: bool) -> Self { - self.non_seamless_cube_map = non_seamless_cube_map.into(); + 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 PhysicalDevicePipelineRobustnessFeaturesEXT<'a> { +#[doc = ""] +pub struct OpticalFlowSessionCreatePrivateDataInfoNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub pipeline_robustness: Bool32, + pub id: u32, + pub size: u32, + pub p_private_data: *const c_void, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePipelineRobustnessFeaturesEXT<'_> { +impl ::std::default::Default for OpticalFlowSessionCreatePrivateDataInfoNV<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - pipeline_robustness: Bool32::default(), + id: u32::default(), + size: u32::default(), + p_private_data: ::std::ptr::null(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDevicePipelineRobustnessFeaturesEXT<'a> { +unsafe impl<'a> TaggedStructure for OpticalFlowSessionCreatePrivateDataInfoNV<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT; + StructureType::OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDevicePipelineRobustnessFeaturesEXT<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDevicePipelineRobustnessFeaturesEXT<'_> {} -impl<'a> PhysicalDevicePipelineRobustnessFeaturesEXT<'a> { +unsafe impl ExtendsOpticalFlowSessionCreateInfoNV + for OpticalFlowSessionCreatePrivateDataInfoNV<'_> +{ +} +impl<'a> OpticalFlowSessionCreatePrivateDataInfoNV<'a> { #[inline] - pub fn pipeline_robustness(mut self, pipeline_robustness: bool) -> Self { - self.pipeline_robustness = pipeline_robustness.into(); + 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 PipelineRobustnessCreateInfoEXT<'a> { +#[doc = ""] +pub struct OpticalFlowExecuteInfoNV<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub storage_buffers: PipelineRobustnessBufferBehaviorEXT, - pub uniform_buffers: PipelineRobustnessBufferBehaviorEXT, - pub vertex_inputs: PipelineRobustnessBufferBehaviorEXT, - pub images: PipelineRobustnessImageBehaviorEXT, + 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 PipelineRobustnessCreateInfoEXT<'_> { +impl ::std::default::Default for OpticalFlowExecuteInfoNV<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(), - uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(), - vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(), - images: PipelineRobustnessImageBehaviorEXT::default(), + 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 PipelineRobustnessCreateInfoEXT<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::PIPELINE_ROBUSTNESS_CREATE_INFO_EXT; +unsafe impl<'a> TaggedStructure for OpticalFlowExecuteInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::OPTICAL_FLOW_EXECUTE_INFO_NV; } -unsafe impl ExtendsGraphicsPipelineCreateInfo for PipelineRobustnessCreateInfoEXT<'_> {} -unsafe impl ExtendsComputePipelineCreateInfo for PipelineRobustnessCreateInfoEXT<'_> {} -unsafe impl ExtendsPipelineShaderStageCreateInfo for PipelineRobustnessCreateInfoEXT<'_> {} -unsafe impl ExtendsRayTracingPipelineCreateInfoKHR for PipelineRobustnessCreateInfoEXT<'_> {} -impl<'a> PipelineRobustnessCreateInfoEXT<'a> { - #[inline] - pub fn storage_buffers(mut self, storage_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self { - self.storage_buffers = storage_buffers; - self - } +impl<'a> OpticalFlowExecuteInfoNV<'a> { #[inline] - pub fn uniform_buffers(mut self, uniform_buffers: PipelineRobustnessBufferBehaviorEXT) -> Self { - self.uniform_buffers = uniform_buffers; - self - } - #[inline] - pub fn vertex_inputs(mut self, vertex_inputs: PipelineRobustnessBufferBehaviorEXT) -> Self { - self.vertex_inputs = vertex_inputs; + pub fn flags(mut self, flags: OpticalFlowExecuteFlagsNV) -> Self { + self.flags = flags; self } #[inline] - pub fn images(mut self, images: PipelineRobustnessImageBehaviorEXT) -> Self { - self.images = images; + 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 PhysicalDevicePipelineRobustnessPropertiesEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceFaultFeaturesEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT, - pub default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT, - pub default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT, - pub default_robustness_images: PipelineRobustnessImageBehaviorEXT, + pub device_fault: Bool32, + pub device_fault_vendor_binary: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDevicePipelineRobustnessPropertiesEXT<'_> { +impl ::std::default::Default for PhysicalDeviceFaultFeaturesEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT::default(), - default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT::default(), - default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT::default(), - default_robustness_images: PipelineRobustnessImageBehaviorEXT::default(), + device_fault: Bool32::default(), + device_fault_vendor_binary: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDevicePipelineRobustnessPropertiesEXT<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT; +unsafe impl<'a> TaggedStructure for PhysicalDeviceFaultFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_FAULT_FEATURES_EXT; } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDevicePipelineRobustnessPropertiesEXT<'_> {} -impl<'a> PhysicalDevicePipelineRobustnessPropertiesEXT<'a> { +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFaultFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFaultFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceFaultFeaturesEXT<'a> { #[inline] - pub fn default_robustness_storage_buffers( - mut self, - default_robustness_storage_buffers: PipelineRobustnessBufferBehaviorEXT, - ) -> Self { - self.default_robustness_storage_buffers = default_robustness_storage_buffers; + pub fn device_fault(mut self, device_fault: bool) -> Self { + self.device_fault = device_fault.into(); self } #[inline] - pub fn default_robustness_uniform_buffers( - mut self, - default_robustness_uniform_buffers: PipelineRobustnessBufferBehaviorEXT, - ) -> Self { - self.default_robustness_uniform_buffers = default_robustness_uniform_buffers; + 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 default_robustness_vertex_inputs( - mut self, - default_robustness_vertex_inputs: PipelineRobustnessBufferBehaviorEXT, - ) -> Self { - self.default_robustness_vertex_inputs = default_robustness_vertex_inputs; + pub fn address_type(mut self, address_type: DeviceFaultAddressTypeEXT) -> Self { + self.address_type = address_type; self } #[inline] - pub fn default_robustness_images( - mut self, - default_robustness_images: PipelineRobustnessImageBehaviorEXT, - ) -> Self { - self.default_robustness_images = default_robustness_images; + 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)] -#[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct ImageViewSampleWeightCreateInfoQCOM<'a> { - pub s_type: StructureType, - pub p_next: *const c_void, - pub filter_center: Offset2D, - pub filter_size: Extent2D, - pub num_phases: u32, - pub _marker: PhantomData<&'a ()>, +#[doc = ""] +pub struct DeviceFaultVendorInfoEXT { + pub description: [c_char; MAX_DESCRIPTION_SIZE], + pub vendor_fault_code: u64, + pub vendor_fault_data: u64, } -impl ::std::default::Default for ImageViewSampleWeightCreateInfoQCOM<'_> { +#[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 { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - filter_center: Offset2D::default(), - filter_size: Extent2D::default(), - num_phases: u32::default(), - _marker: PhantomData, + description: unsafe { ::std::mem::zeroed() }, + vendor_fault_code: u64::default(), + vendor_fault_data: u64::default(), } } } -unsafe impl<'a> TaggedStructure for ImageViewSampleWeightCreateInfoQCOM<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; -} -unsafe impl ExtendsImageViewCreateInfo for ImageViewSampleWeightCreateInfoQCOM<'_> {} -impl<'a> ImageViewSampleWeightCreateInfoQCOM<'a> { +impl DeviceFaultVendorInfoEXT { #[inline] - pub fn filter_center(mut self, filter_center: Offset2D) -> Self { - self.filter_center = filter_center; + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.description = description; self } #[inline] - pub fn filter_size(mut self, filter_size: Extent2D) -> Self { - self.filter_size = filter_size; + pub fn vendor_fault_code(mut self, vendor_fault_code: u64) -> Self { + self.vendor_fault_code = vendor_fault_code; self } #[inline] - pub fn num_phases(mut self, num_phases: u32) -> Self { - self.num_phases = num_phases; + 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 PhysicalDeviceImageProcessingFeaturesQCOM<'a> { +#[doc = ""] +pub struct DeviceFaultCountsEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub texture_sample_weighted: Bool32, - pub texture_box_filter: Bool32, - pub texture_block_match: Bool32, + pub address_info_count: u32, + pub vendor_info_count: u32, + pub vendor_binary_size: DeviceSize, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceImageProcessingFeaturesQCOM<'_> { +impl ::std::default::Default for DeviceFaultCountsEXT<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - texture_sample_weighted: Bool32::default(), - texture_box_filter: Bool32::default(), - texture_block_match: Bool32::default(), + address_info_count: u32::default(), + vendor_info_count: u32::default(), + vendor_binary_size: DeviceSize::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceImageProcessingFeaturesQCOM<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; +unsafe impl<'a> TaggedStructure for DeviceFaultCountsEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_COUNTS_EXT; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageProcessingFeaturesQCOM<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessingFeaturesQCOM<'_> {} -impl<'a> PhysicalDeviceImageProcessingFeaturesQCOM<'a> { +impl<'a> DeviceFaultCountsEXT<'a> { #[inline] - pub fn texture_sample_weighted(mut self, texture_sample_weighted: bool) -> Self { - self.texture_sample_weighted = texture_sample_weighted.into(); + pub fn address_info_count(mut self, address_info_count: u32) -> Self { + self.address_info_count = address_info_count; self } #[inline] - pub fn texture_box_filter(mut self, texture_box_filter: bool) -> Self { - self.texture_box_filter = texture_box_filter.into(); + pub fn vendor_info_count(mut self, vendor_info_count: u32) -> Self { + self.vendor_info_count = vendor_info_count; self } #[inline] - pub fn texture_block_match(mut self, texture_block_match: bool) -> Self { - self.texture_block_match = texture_block_match.into(); + pub fn vendor_binary_size(mut self, vendor_binary_size: DeviceSize) -> Self { + self.vendor_binary_size = vendor_binary_size; self } } #[repr(C)] -#[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] -#[doc = ""] -pub struct PhysicalDeviceImageProcessingPropertiesQCOM<'a> { +#[doc = ""] +pub struct DeviceFaultInfoEXT<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub max_weight_filter_phases: u32, - pub max_weight_filter_dimension: Extent2D, - pub max_block_match_region: Extent2D, - pub max_box_filter_block_size: Extent2D, + 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 ()>, } -impl ::std::default::Default for PhysicalDeviceImageProcessingPropertiesQCOM<'_> { +#[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(), - max_weight_filter_phases: u32::default(), - max_weight_filter_dimension: Extent2D::default(), - max_block_match_region: Extent2D::default(), - max_box_filter_block_size: Extent2D::default(), + 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 PhysicalDeviceImageProcessingPropertiesQCOM<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; +unsafe impl<'a> TaggedStructure for DeviceFaultInfoEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::DEVICE_FAULT_INFO_EXT; } -unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageProcessingPropertiesQCOM<'_> {} -impl<'a> PhysicalDeviceImageProcessingPropertiesQCOM<'a> { +impl<'a> DeviceFaultInfoEXT<'a> { #[inline] - pub fn max_weight_filter_phases(mut self, max_weight_filter_phases: u32) -> Self { - self.max_weight_filter_phases = max_weight_filter_phases; + pub fn description(mut self, description: [c_char; MAX_DESCRIPTION_SIZE]) -> Self { + self.description = description; self } #[inline] - pub fn max_weight_filter_dimension(mut self, max_weight_filter_dimension: Extent2D) -> Self { - self.max_weight_filter_dimension = max_weight_filter_dimension; + pub fn address_infos(mut self, address_infos: &'a mut DeviceFaultAddressInfoEXT) -> Self { + self.p_address_infos = address_infos; self } #[inline] - pub fn max_block_match_region(mut self, max_block_match_region: Extent2D) -> Self { - self.max_block_match_region = max_block_match_region; + pub fn vendor_infos(mut self, vendor_infos: &'a mut DeviceFaultVendorInfoEXT) -> Self { + self.p_vendor_infos = vendor_infos; self } #[inline] - pub fn max_box_filter_block_size(mut self, max_box_filter_block_size: Extent2D) -> Self { - self.max_box_filter_block_size = max_box_filter_block_size; + 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 PhysicalDeviceTilePropertiesFeaturesQCOM<'a> { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub tile_properties: Bool32, - pub _marker: PhantomData<&'a ()>, +#[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 PhysicalDeviceTilePropertiesFeaturesQCOM<'_> { +impl ::std::default::Default for DeviceFaultVendorBinaryHeaderVersionOneEXT { #[inline] fn default() -> Self { Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - tile_properties: Bool32::default(), - _marker: PhantomData, + 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(), } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceTilePropertiesFeaturesQCOM<'a> { - const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; -} -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceTilePropertiesFeaturesQCOM<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceTilePropertiesFeaturesQCOM<'_> {} -impl<'a> PhysicalDeviceTilePropertiesFeaturesQCOM<'a> { +impl DeviceFaultVendorBinaryHeaderVersionOneEXT { #[inline] - pub fn tile_properties(mut self, tile_properties: bool) -> Self { - self.tile_properties = tile_properties.into(); + 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)] -#[doc = ""] -pub struct TilePropertiesQCOM<'a> { - pub s_type: StructureType, - pub p_next: *mut c_void, - pub tile_size: Extent3D, - pub apron_size: Extent2D, - pub origin: Offset2D, - pub _marker: PhantomData<&'a ()>, +#[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 ::std::default::Default for TilePropertiesQCOM<'_> { +impl DecompressMemoryRegionNV { #[inline] - fn default() -> Self { - Self { - s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null_mut(), - tile_size: Extent3D::default(), - apron_size: Extent2D::default(), - origin: Offset2D::default(), - _marker: PhantomData, - } + pub fn src_address(mut self, src_address: DeviceAddress) -> Self { + self.src_address = src_address; + self } -} -unsafe impl<'a> TaggedStructure for TilePropertiesQCOM<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::TILE_PROPERTIES_QCOM; -} -impl<'a> TilePropertiesQCOM<'a> { #[inline] - pub fn tile_size(mut self, tile_size: Extent3D) -> Self { - self.tile_size = tile_size; + pub fn dst_address(mut self, dst_address: DeviceAddress) -> Self { + self.dst_address = dst_address; self } #[inline] - pub fn apron_size(mut self, apron_size: Extent2D) -> Self { - self.apron_size = apron_size; + pub fn compressed_size(mut self, compressed_size: DeviceSize) -> Self { + self.compressed_size = compressed_size; self } #[inline] - pub fn origin(mut self, origin: Offset2D) -> Self { - self.origin = origin; + 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 PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { +#[doc = ""] +pub struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub amigo_profiling: Bool32, + 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 PhysicalDeviceAmigoProfilingFeaturesSEC<'_> { +impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - amigo_profiling: Bool32::default(), + shader_core_mask: u64::default(), + shader_core_count: u32::default(), + shader_warps_per_core: u32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC; + StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceAmigoProfilingFeaturesSEC<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAmigoProfilingFeaturesSEC<'_> {} -impl<'a> PhysicalDeviceAmigoProfilingFeaturesSEC<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'_> {} +impl<'a> PhysicalDeviceShaderCoreBuiltinsPropertiesARM<'a> { #[inline] - pub fn amigo_profiling(mut self, amigo_profiling: bool) -> Self { - self.amigo_profiling = amigo_profiling.into(); + 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 AmigoProfilingSubmitInfoSEC<'a> { +#[doc = ""] +pub struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { pub s_type: StructureType, - pub p_next: *const c_void, - pub first_draw_timestamp: u64, - pub swap_buffer_timestamp: u64, + pub p_next: *mut c_void, + pub shader_core_builtins: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for AmigoProfilingSubmitInfoSEC<'_> { +impl ::std::default::Default for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, - p_next: ::std::ptr::null(), - first_draw_timestamp: u64::default(), - swap_buffer_timestamp: u64::default(), + p_next: ::std::ptr::null_mut(), + shader_core_builtins: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for AmigoProfilingSubmitInfoSEC<'a> { - const STRUCTURE_TYPE: StructureType = StructureType::AMIGO_PROFILING_SUBMIT_INFO_SEC; +unsafe impl<'a> TaggedStructure for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; } -unsafe impl ExtendsSubmitInfo for AmigoProfilingSubmitInfoSEC<'_> {} -impl<'a> AmigoProfilingSubmitInfoSEC<'a> { - #[inline] - pub fn first_draw_timestamp(mut self, first_draw_timestamp: u64) -> Self { - self.first_draw_timestamp = first_draw_timestamp; - self - } +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'_> {} +impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { #[inline] - pub fn swap_buffer_timestamp(mut self, swap_buffer_timestamp: u64) -> Self { - self.swap_buffer_timestamp = swap_buffer_timestamp; + 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 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub attachment_feedback_loop_layout: Bool32, + pub ray_tracing_invocation_reorder: Bool32, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'_> { +impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - attachment_feedback_loop_layout: Bool32::default(), + ray_tracing_invocation_reorder: Bool32::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; + StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; } unsafe impl ExtendsPhysicalDeviceFeatures2 - for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'_> + for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'_> { } -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'_> {} -impl<'a> PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT<'a> { +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'_> {} +impl<'a> PhysicalDeviceRayTracingInvocationReorderFeaturesNV<'a> { #[inline] - pub fn attachment_feedback_loop_layout( - mut self, - attachment_feedback_loop_layout: bool, - ) -> Self { - self.attachment_feedback_loop_layout = attachment_feedback_loop_layout.into(); + 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 PhysicalDeviceDepthClampZeroOneFeaturesEXT<'a> { +#[doc = ""] +pub struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { pub s_type: StructureType, pub p_next: *mut c_void, - pub depth_clamp_zero_one: Bool32, + pub ray_tracing_invocation_reorder_reordering_hint: RayTracingInvocationReorderModeNV, pub _marker: PhantomData<&'a ()>, } -impl ::std::default::Default for PhysicalDeviceDepthClampZeroOneFeaturesEXT<'_> { +impl ::std::default::Default for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'_> { #[inline] fn default() -> Self { Self { s_type: Self::STRUCTURE_TYPE, p_next: ::std::ptr::null_mut(), - depth_clamp_zero_one: Bool32::default(), + ray_tracing_invocation_reorder_reordering_hint: + RayTracingInvocationReorderModeNV::default(), _marker: PhantomData, } } } -unsafe impl<'a> TaggedStructure for PhysicalDeviceDepthClampZeroOneFeaturesEXT<'a> { +unsafe impl<'a> TaggedStructure for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { const STRUCTURE_TYPE: StructureType = - StructureType::PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT; + StructureType::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; } -unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceDepthClampZeroOneFeaturesEXT<'_> {} -unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDepthClampZeroOneFeaturesEXT<'_> {} -impl<'a> PhysicalDeviceDepthClampZeroOneFeaturesEXT<'a> { +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'_> +{ +} +impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { #[inline] - pub fn depth_clamp_zero_one(mut self, depth_clamp_zero_one: bool) -> Self { - self.depth_clamp_zero_one = depth_clamp_zero_one.into(); + 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 4c18550fa..40c534daf 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 d42cbddd6..4f12a2fa8 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") } - } - pub const SPEC_VERSION: u32 = 0u32; + unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked( + b"VK_EXT_device_address_binding_report\0", + ) + } + } + 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,236 +20982,475 @@ impl KhrExtension396Fn { Self {} } } -impl NvExtension397Fn { - #[inline] - pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_397\0") } - } - pub const SPEC_VERSION: u32 = 0u32; -} -#[derive(Clone)] -pub struct NvExtension397Fn {} -unsafe impl Send for NvExtension397Fn {} -unsafe impl Sync for NvExtension397Fn {} -impl NvExtension397Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - Self {} - } -} -#[doc = "Generated from 'VK_NV_extension_397'"] -impl AccessFlags2 { - pub const RESERVED_44_NV: Self = - Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); - pub const RESERVED_45_NV: Self = - Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from 'VK_NV_extension_397'"] -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); -} -#[doc = "Generated from 'VK_NV_extension_397'"] -impl BuildAccelerationStructureFlagsKHR { - pub const RESERVED_6_NV: Self = Self(0b100_0000); - pub const RESERVED_7_NV: Self = Self(0b1000_0000); -} -#[doc = "Generated from 'VK_NV_extension_397'"] -impl GeometryInstanceFlagsKHR { - pub const RESERVED_4_NV: Self = Self(0b1_0000); - pub const RESERVED_5_NV: Self = Self(0b10_0000); -} -#[doc = "Generated from 'VK_NV_extension_397'"] -impl PipelineCreateFlags { - pub const RESERVED_24_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from 'VK_NV_extension_397'"] -impl PipelineStageFlags2 { - pub const RESERVED_30_NV: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); -} -impl NvExtension398Fn { - #[inline] - pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_398\0") } - } - pub const SPEC_VERSION: u32 = 0u32; -} -#[derive(Clone)] -pub struct NvExtension398Fn {} -unsafe impl Send for NvExtension398Fn {} -unsafe impl Sync for NvExtension398Fn {} -impl NvExtension398Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - Self {} - } -} -#[doc = "Generated from 'VK_NV_extension_398'"] -impl BuildAccelerationStructureFlagsKHR { - pub const RESERVED_9_NV: Self = Self(0b10_0000_0000); - pub const RESERVED_10_NV: Self = Self(0b100_0000_0000); -} -#[doc = "Generated from 'VK_NV_extension_398'"] -impl PipelineCreateFlags { - pub const RESERVED_28_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); -} -impl JuiceExtension399Fn { - #[inline] - pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_399\0") } - } - pub const SPEC_VERSION: u32 = 0u32; -} -#[derive(Clone)] -pub struct JuiceExtension399Fn {} -unsafe impl Send for JuiceExtension399Fn {} -unsafe impl Sync for JuiceExtension399Fn {} -impl JuiceExtension399Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - Self {} - } -} -impl JuiceExtension400Fn { - #[inline] - pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_400\0") } - } - pub const SPEC_VERSION: u32 = 0u32; -} -#[derive(Clone)] -pub struct JuiceExtension400Fn {} -unsafe impl Send for JuiceExtension400Fn {} -unsafe impl Sync for JuiceExtension400Fn {} -impl JuiceExtension400Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - Self {} - } -} -impl ExtLoadStoreOpNoneFn { - #[inline] - pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_load_store_op_none\0") } - } - pub const SPEC_VERSION: u32 = 1u32; -} -#[derive(Clone)] -pub struct ExtLoadStoreOpNoneFn {} -unsafe impl Send for ExtLoadStoreOpNoneFn {} -unsafe impl Sync for ExtLoadStoreOpNoneFn {} -impl ExtLoadStoreOpNoneFn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - Self {} - } -} -#[doc = "Generated from 'VK_EXT_load_store_op_none'"] -impl AttachmentLoadOp { - pub const NONE_EXT: Self = Self(1_000_400_000); -} -#[doc = "Generated from 'VK_EXT_load_store_op_none'"] -impl AttachmentStoreOp { - pub const NONE_EXT: Self = Self::NONE; -} -impl FbExtension402Fn { - #[inline] - pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_402\0") } - } - pub const SPEC_VERSION: u32 = 0u32; -} -#[derive(Clone)] -pub struct FbExtension402Fn {} -unsafe impl Send for FbExtension402Fn {} -unsafe impl Sync for FbExtension402Fn {} -impl FbExtension402Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - Self {} - } -} -impl FbExtension403Fn { - #[inline] - pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_403\0") } - } - pub const SPEC_VERSION: u32 = 0u32; -} -#[derive(Clone)] -pub struct FbExtension403Fn {} -unsafe impl Send for FbExtension403Fn {} -unsafe impl Sync for FbExtension403Fn {} -impl FbExtension403Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - Self {} - } -} -impl FbExtension404Fn { +impl ExtOpacityMicromapFn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_404\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 FbExtension404Fn {} -unsafe impl Send for FbExtension404Fn {} -unsafe impl Sync for FbExtension404Fn {} -impl FbExtension404Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - Self {} - } -} -impl HuaweiExtension405Fn { - #[inline] - pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_405\0") } - } - pub const SPEC_VERSION: u32 = 0u32; +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, } -#[derive(Clone)] -pub struct HuaweiExtension405Fn {} -unsafe impl Send for HuaweiExtension405Fn {} -unsafe impl Sync for HuaweiExtension405Fn {} -impl HuaweiExtension405Fn { +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 {} - } -} -impl HuaweiExtension406Fn { + 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_EXT_opacity_micromap'"] +impl AccessFlags2 { + pub const MICROMAP_READ_EXT: Self = + Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); + pub const MICROMAP_WRITE_EXT: Self = + Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl BufferUsageFlags { + 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_EXT_opacity_micromap'"] +impl BuildAccelerationStructureFlagsKHR { + 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_EXT_opacity_micromap'"] +impl GeometryInstanceFlagsKHR { + 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_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 RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); +} +#[doc = "Generated from 'VK_EXT_opacity_micromap'"] +impl PipelineStageFlags2 { + 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] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_406\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_398\0") } } pub const SPEC_VERSION: u32 = 0u32; } #[derive(Clone)] -pub struct HuaweiExtension406Fn {} -unsafe impl Send for HuaweiExtension406Fn {} -unsafe impl Sync for HuaweiExtension406Fn {} -impl HuaweiExtension406Fn { +pub struct NvExtension398Fn {} +unsafe impl Send for NvExtension398Fn {} +unsafe impl Sync for NvExtension398Fn {} +impl NvExtension398Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -20819,18 +21458,27 @@ impl HuaweiExtension406Fn { Self {} } } -impl GgpExtension407Fn { +#[doc = "Generated from 'VK_NV_extension_398'"] +impl BuildAccelerationStructureFlagsKHR { + pub const RESERVED_9_NV: Self = Self(0b10_0000_0000); + pub const RESERVED_10_NV: Self = Self(0b100_0000_0000); +} +#[doc = "Generated from 'VK_NV_extension_398'"] +impl PipelineCreateFlags { + pub const RESERVED_28_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); +} +impl JuiceExtension399Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_407\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_399\0") } } pub const SPEC_VERSION: u32 = 0u32; } #[derive(Clone)] -pub struct GgpExtension407Fn {} -unsafe impl Send for GgpExtension407Fn {} -unsafe impl Sync for GgpExtension407Fn {} -impl GgpExtension407Fn { +pub struct JuiceExtension399Fn {} +unsafe impl Send for JuiceExtension399Fn {} +unsafe impl Sync for JuiceExtension399Fn {} +impl JuiceExtension399Fn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, @@ -20838,17 +21486,186 @@ impl GgpExtension407Fn { Self {} } } -impl GgpExtension408Fn { +impl JuiceExtension400Fn { #[inline] pub const fn name() -> &'static ::std::ffi::CStr { - unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_408\0") } + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_400\0") } } pub const SPEC_VERSION: u32 = 0u32; } #[derive(Clone)] -pub struct GgpExtension408Fn {} -unsafe impl Send for GgpExtension408Fn {} -unsafe impl Sync for GgpExtension408Fn {} +pub struct JuiceExtension400Fn {} +unsafe impl Send for JuiceExtension400Fn {} +unsafe impl Sync for JuiceExtension400Fn {} +impl JuiceExtension400Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl ExtLoadStoreOpNoneFn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_load_store_op_none\0") } + } + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtLoadStoreOpNoneFn {} +unsafe impl Send for ExtLoadStoreOpNoneFn {} +unsafe impl Sync for ExtLoadStoreOpNoneFn {} +impl ExtLoadStoreOpNoneFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +#[doc = "Generated from 'VK_EXT_load_store_op_none'"] +impl AttachmentLoadOp { + pub const NONE_EXT: Self = Self(1_000_400_000); +} +#[doc = "Generated from 'VK_EXT_load_store_op_none'"] +impl AttachmentStoreOp { + pub const NONE_EXT: Self = Self::NONE; +} +impl FbExtension402Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_402\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension402Fn {} +unsafe impl Send for FbExtension402Fn {} +unsafe impl Sync for FbExtension402Fn {} +impl FbExtension402Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FbExtension403Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_403\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension403Fn {} +unsafe impl Send for FbExtension403Fn {} +unsafe impl Sync for FbExtension403Fn {} +impl FbExtension403Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl FbExtension404Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_404\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct FbExtension404Fn {} +unsafe impl Send for FbExtension404Fn {} +unsafe impl Sync for FbExtension404Fn {} +impl FbExtension404Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl HuaweiExtension405Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_405\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension405Fn {} +unsafe impl Send for HuaweiExtension405Fn {} +unsafe impl Sync for HuaweiExtension405Fn {} +impl HuaweiExtension405Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + 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 { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_406\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct HuaweiExtension406Fn {} +unsafe impl Send for HuaweiExtension406Fn {} +unsafe impl Sync for HuaweiExtension406Fn {} +impl HuaweiExtension406Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension407Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_407\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension407Fn {} +unsafe impl Send for GgpExtension407Fn {} +unsafe impl Sync for GgpExtension407Fn {} +impl GgpExtension407Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self {} + } +} +impl GgpExtension408Fn { + #[inline] + pub const fn name() -> &'static ::std::ffi::CStr { + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_408\0") } + } + pub const SPEC_VERSION: u32 = 0u32; +} +#[derive(Clone)] +pub struct GgpExtension408Fn {} +unsafe impl Send for GgpExtension408Fn {} +unsafe impl Sync for GgpExtension408Fn {} impl GgpExtension408Fn { pub fn load(mut _f: F) -> Self where @@ -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,45 +22265,181 @@ 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) + } + }, + } } } -impl NvExtension429Fn { +#[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 { unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_429\0") } @@ -22061,24 +23018,866 @@ 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 = 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 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 { + 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) + } + }, + } } - pub const SPEC_VERSION: u32 = 0u32; } -#[derive(Clone)] -pub struct NvExtension456Fn {} -unsafe impl Send for NvExtension456Fn {} -unsafe impl Sync for NvExtension456Fn {} -impl NvExtension456Fn { - pub fn load(mut _f: F) -> Self - where - F: FnMut(&::std::ffi::CStr) -> *const c_void, - { - Self {} - } +#[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] @@ -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_optical_flow'"] +impl ObjectType { + pub const OPTICAL_FLOW_SESSION_NV: Self = Self(1_000_464_000); } -#[doc = "Generated from 'VK_NV_extension_465'"] +#[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 09b7fb7e6..02edfba5c 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!( @@ -725,33 +739,67 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSetVui() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_frames) as usize - ptr as usize }, 24usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), "::", - stringify!(pHrdParameters) + stringify!(max_num_reorder_frames) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).max_num_reorder_frames) as usize - ptr as usize }, - 32usize, + unsafe { ::std::ptr::addr_of!((*ptr).max_dec_frame_buffering) as usize - ptr as usize }, + 25usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSetVui), "::", - stringify!(max_num_reorder_frames) + stringify!(max_dec_frame_buffering) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).max_dec_frame_buffering) as usize - ptr as usize }, - 33usize, + 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!(max_dec_frame_buffering) + 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) ) ); } @@ -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!( @@ -1190,28 +1240,28 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), "::", - stringify!(seq_parameter_set_id) + stringify!(chroma_format_idc) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).seq_parameter_set_id) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), "::", - stringify!(chroma_format_idc) + 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), @@ -1250,37 +1300,37 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize - }, - 28usize, + unsafe { ::std::ptr::addr_of!((*ptr).offset_for_non_ref_pic) as usize - ptr as usize }, + 24usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), "::", - stringify!(log2_max_pic_order_cnt_lsb_minus4) + stringify!(offset_for_non_ref_pic) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).offset_for_non_ref_pic) as usize - ptr as usize }, - 32usize, + unsafe { + ::std::ptr::addr_of!((*ptr).offset_for_top_to_bottom_field) as usize - ptr as usize + }, + 28usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), "::", - stringify!(offset_for_non_ref_pic) + stringify!(offset_for_top_to_bottom_field) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).offset_for_top_to_bottom_field) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize }, - 36usize, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoH264SequenceParameterSet), "::", - stringify!(offset_for_top_to_bottom_field) + stringify!(log2_max_pic_order_cnt_lsb_minus4) ) ); assert_eq!( @@ -1288,7 +1338,7 @@ fn bindgen_test_layout_StdVideoH264SequenceParameterSet() { ::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 { - unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) } - } - #[inline] - pub fn set_pic_order_present_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) } + unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 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) + self._bitfield_1.set(6usize, 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,371 +2183,125 @@ fn bindgen_test_layout_StdVideoDecodeH264ReferenceInfo() { ) ); } +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: + StdVideoH265ProfileIdc = 3; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS: + StdVideoH265ProfileIdc = 4; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: StdVideoH265ProfileIdc = + 9; +pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_INVALID: StdVideoH265ProfileIdc = + 2147483647; +pub type StdVideoH265ProfileIdc = ::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; +pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_INVALID: StdVideoH265SliceType = + 2147483647; +pub type StdVideoH265SliceType = ::std::os::raw::c_uint; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_P: StdVideoH265PictureType = 0; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_B: StdVideoH265PictureType = 1; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_I: StdVideoH265PictureType = 2; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_IDR: StdVideoH265PictureType = 3; +pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_INVALID: StdVideoH265PictureType = + 2147483647; +pub type StdVideoH265PictureType = ::std::os::raw::c_uint; +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)] -#[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], +pub struct StdVideoH265DecPicBufMgr { + pub max_latency_increase_plus1: [u32; 7usize], + pub max_dec_pic_buffering_minus1: [u8; 7usize], + pub max_num_reorder_pics: [u8; 7usize], } #[test] -fn bindgen_test_layout_StdVideoDecodeH264MvcElementFlags() { +fn bindgen_test_layout_StdVideoH265DecPicBufMgr() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); + let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::(), - 4usize, - concat!("Size of: ", stringify!(StdVideoDecodeH264MvcElementFlags)) + ::std::mem::size_of::(), + 44usize, + concat!("Size of: ", stringify!(StdVideoH265DecPicBufMgr)) ); assert_eq!( - ::std::mem::align_of::(), + ::std::mem::align_of::(), 4usize, + concat!("Alignment of ", stringify!(StdVideoH265DecPicBufMgr)) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).max_latency_increase_plus1) as usize - ptr as usize }, + 0usize, 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 StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN: StdVideoH265ProfileIdc = 1; -pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_10: StdVideoH265ProfileIdc = 2; -pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE: - StdVideoH265ProfileIdc = 3; -pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS: - StdVideoH265ProfileIdc = 4; -pub const StdVideoH265ProfileIdc_STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS: StdVideoH265ProfileIdc = - 9; -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 StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_B: StdVideoH265SliceType = 0; -pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_P: StdVideoH265SliceType = 1; -pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_I: StdVideoH265SliceType = 2; -pub const StdVideoH265SliceType_STD_VIDEO_H265_SLICE_TYPE_INVALID: StdVideoH265SliceType = - 2147483647; -pub type StdVideoH265SliceType = ::std::os::raw::c_uint; -pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_P: StdVideoH265PictureType = 0; -pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_B: StdVideoH265PictureType = 1; -pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_I: StdVideoH265PictureType = 2; -pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_IDR: StdVideoH265PictureType = 3; -pub const StdVideoH265PictureType_STD_VIDEO_H265_PICTURE_TYPE_INVALID: StdVideoH265PictureType = - 2147483647; -pub type StdVideoH265PictureType = ::std::os::raw::c_uint; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct StdVideoH265DecPicBufMgr { - pub max_latency_increase_plus1: [u32; 7usize], - pub max_dec_pic_buffering_minus1: [u8; 7usize], - pub max_num_reorder_pics: [u8; 7usize], -} -#[test] -fn bindgen_test_layout_StdVideoH265DecPicBufMgr() { - const UNINIT: ::std::mem::MaybeUninit = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::(), - 44usize, - concat!("Size of: ", stringify!(StdVideoH265DecPicBufMgr)) - ); - assert_eq!( - ::std::mem::align_of::(), - 4usize, - concat!("Alignment of ", stringify!(StdVideoH265DecPicBufMgr)) - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).max_latency_increase_plus1) as usize - ptr as usize }, - 0usize, - concat!( - "Offset of field: ", - stringify!(StdVideoH265DecPicBufMgr), - "::", - stringify!(max_latency_increase_plus1) + "Offset of field: ", + stringify!(StdVideoH265DecPicBufMgr), + "::", + stringify!(max_latency_increase_plus1) ) ); assert_eq!( @@ -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,25 +2848,198 @@ impl StdVideoH265VpsFlags { } } #[repr(C)] +#[repr(align(4))] #[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 vps_num_units_in_tick: u32, - pub vps_time_scale: u32, - pub vps_num_ticks_poc_diff_one_minus1: u32, - pub pDecPicBufMgr: *const StdVideoH265DecPicBufMgr, - pub pHrdParameters: *const StdVideoH265HrdParameters, +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_StdVideoH265VideoParameterSet() { - const UNINIT: ::std::mem::MaybeUninit = - ::std::mem::MaybeUninit::uninit(); +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() { + const UNINIT: ::std::mem::MaybeUninit = + ::std::mem::MaybeUninit::uninit(); 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), @@ -3770,30 +3835,30 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSetVui() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHrdParameters) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).min_spatial_segmentation_idc) as usize - ptr as usize + }, 40usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), "::", - stringify!(pHrdParameters) + stringify!(min_spatial_segmentation_idc) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).min_spatial_segmentation_idc) as usize - ptr as usize - }, - 48usize, + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 42usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSetVui), "::", - stringify!(min_spatial_segmentation_idc) + 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,253 +4834,288 @@ 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) + stringify!(chroma_format_idc) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).level_idc) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_luma_samples) as usize - ptr as usize }, 8usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(level_idc) + stringify!(pic_width_in_luma_samples) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pic_width_in_luma_samples) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pic_height_in_luma_samples) as usize - ptr as usize }, 12usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(pic_width_in_luma_samples) + stringify!(pic_height_in_luma_samples) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pic_height_in_luma_samples) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, 16usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(pic_height_in_luma_samples) + stringify!(sps_video_parameter_set_id) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sps_video_parameter_set_id) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).sps_max_sub_layers_minus1) as usize - ptr as usize }, + 17usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_max_sub_layers_minus1) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).sps_seq_parameter_set_id) as usize - ptr as usize }, + 18usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(sps_seq_parameter_set_id) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize }, + 19usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265SequenceParameterSet), + "::", + stringify!(bit_depth_luma_minus8) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize }, 20usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(sps_video_parameter_set_id) + stringify!(bit_depth_chroma_minus8) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sps_max_sub_layers_minus1) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize + }, 21usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(sps_max_sub_layers_minus1) + stringify!(log2_max_pic_order_cnt_lsb_minus4) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sps_seq_parameter_set_id) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).log2_min_luma_coding_block_size_minus3) as usize + - ptr as usize + }, 22usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(sps_seq_parameter_set_id) + stringify!(log2_min_luma_coding_block_size_minus3) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chroma_format_idc) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_coding_block_size) as usize + - ptr as usize + }, 23usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(chroma_format_idc) + stringify!(log2_diff_max_min_luma_coding_block_size) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_luma_minus8) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).log2_min_luma_transform_block_size_minus2) as usize + - ptr as usize + }, 24usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(bit_depth_luma_minus8) + stringify!(log2_min_luma_transform_block_size_minus2) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bit_depth_chroma_minus8) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_transform_block_size) as usize + - ptr as usize + }, 25usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(bit_depth_chroma_minus8) + stringify!(log2_diff_max_min_luma_transform_block_size) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).log2_max_pic_order_cnt_lsb_minus4) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_inter) as usize - ptr as usize }, 26usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(log2_max_pic_order_cnt_lsb_minus4) + stringify!(max_transform_hierarchy_depth_inter) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).log2_min_luma_coding_block_size_minus3) as usize - - ptr as usize + ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_intra) as usize - ptr as usize }, 27usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(log2_min_luma_coding_block_size_minus3) + stringify!(max_transform_hierarchy_depth_intra) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_coding_block_size) as usize - - ptr as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).num_short_term_ref_pic_sets) as usize - ptr as usize }, 28usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(log2_diff_max_min_luma_coding_block_size) + stringify!(num_short_term_ref_pic_sets) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).log2_min_luma_transform_block_size_minus2) as usize - - ptr as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_ref_pics_sps) as usize - ptr as usize }, 29usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(log2_min_luma_transform_block_size_minus2) + stringify!(num_long_term_ref_pics_sps) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).log2_diff_max_min_luma_transform_block_size) as usize - - ptr as usize + ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_luma_minus1) as usize - ptr as usize }, 30usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(log2_diff_max_min_luma_transform_block_size) + stringify!(pcm_sample_bit_depth_luma_minus1) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_inter) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_chroma_minus1) as usize - ptr as usize }, 31usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(max_transform_hierarchy_depth_inter) + stringify!(pcm_sample_bit_depth_chroma_minus1) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).max_transform_hierarchy_depth_intra) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).log2_min_pcm_luma_coding_block_size_minus3) as usize + - ptr as usize }, 32usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(max_transform_hierarchy_depth_intra) + stringify!(log2_min_pcm_luma_coding_block_size_minus3) ) ); 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).log2_diff_max_min_pcm_luma_coding_block_size) as usize + - ptr as usize + }, 33usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(num_short_term_ref_pic_sets) + stringify!(log2_diff_max_min_pcm_luma_coding_block_size) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_long_term_ref_pics_sps) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, 34usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(num_long_term_ref_pics_sps) + stringify!(reserved1) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_luma_minus1) as usize - ptr as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, 35usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(pcm_sample_bit_depth_luma_minus1) + stringify!(reserved2) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).pcm_sample_bit_depth_chroma_minus1) as usize - ptr as usize - }, + unsafe { ::std::ptr::addr_of!((*ptr).palette_max_size) as usize - ptr as usize }, 36usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(pcm_sample_bit_depth_chroma_minus1) + stringify!(palette_max_size) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).log2_min_pcm_luma_coding_block_size_minus3) as usize - - ptr as usize + ::std::ptr::addr_of!((*ptr).delta_palette_max_predictor_size) as usize - ptr as usize }, 37usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(log2_min_pcm_luma_coding_block_size_minus3) + stringify!(delta_palette_max_predictor_size) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).log2_diff_max_min_pcm_luma_coding_block_size) as usize + ::std::ptr::addr_of!((*ptr).motion_vector_resolution_control_idc) as usize - ptr as usize }, 38usize, @@ -4693,7 +5123,20 @@ fn bindgen_test_layout_StdVideoH265SequenceParameterSet() { "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(log2_diff_max_min_pcm_luma_coding_block_size) + 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!( @@ -4737,86 +5180,68 @@ 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!(pDecPicBufMgr) + stringify!(pProfileTierLevel) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pDecPicBufMgr) as usize - ptr as usize }, 64usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(pScalingLists) + stringify!(pDecPicBufMgr) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, 72usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(pSequenceParameterSetVui) + stringify!(pScalingLists) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).palette_max_size) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).pShortTermRefPicSet) 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) + stringify!(pShortTermRefPicSet) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).motion_vector_resolution_control_idc) as usize - - ptr as usize - }, - 82usize, + unsafe { ::std::ptr::addr_of!((*ptr).pLongTermRefPicsSps) as usize - ptr as usize }, + 88usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(motion_vector_resolution_control_idc) + stringify!(pLongTermRefPicsSps) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).sps_num_palette_predictor_initializer_minus1) as usize - - ptr as usize - }, - 83usize, + unsafe { ::std::ptr::addr_of!((*ptr).pSequenceParameterSetVui) as usize - ptr as usize }, + 96usize, concat!( "Offset of field: ", stringify!(StdVideoH265SequenceParameterSet), "::", - stringify!(sps_num_palette_predictor_initializer_minus1) + stringify!(pSequenceParameterSetVui) ) ); 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), @@ -5534,229 +5973,259 @@ fn bindgen_test_layout_StdVideoH265PictureParameterSet() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_tile_columns_minus1) as usize - ptr as usize }, - 13usize, + unsafe { ::std::ptr::addr_of!((*ptr).pps_beta_offset_div2) as usize - ptr as usize }, + 14usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(num_tile_columns_minus1) + stringify!(pps_beta_offset_div2) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).num_tile_rows_minus1) as usize - ptr as usize }, - 14usize, + unsafe { ::std::ptr::addr_of!((*ptr).pps_tc_offset_div2) as usize - ptr as usize }, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(num_tile_rows_minus1) + stringify!(pps_tc_offset_div2) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).column_width_minus1) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).log2_parallel_merge_level_minus2) as usize - ptr as usize + }, 16usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(column_width_minus1) + stringify!(log2_parallel_merge_level_minus2) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).row_height_minus1) as usize - ptr as usize }, - 54usize, + unsafe { + ::std::ptr::addr_of!((*ptr).log2_max_transform_skip_block_size_minus2) as usize + - ptr as usize + }, + 17usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(row_height_minus1) + stringify!(log2_max_transform_skip_block_size_minus2) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pps_beta_offset_div2) as usize - ptr as usize }, - 96usize, + unsafe { + ::std::ptr::addr_of!((*ptr).diff_cu_chroma_qp_offset_depth) as usize - ptr as usize + }, + 18usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(pps_beta_offset_div2) + stringify!(diff_cu_chroma_qp_offset_depth) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pps_tc_offset_div2) as usize - ptr as usize }, - 97usize, + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_qp_offset_list_len_minus1) as usize - ptr as usize + }, + 19usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(pps_tc_offset_div2) + stringify!(chroma_qp_offset_list_len_minus1) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).log2_parallel_merge_level_minus2) as usize - ptr as usize - }, - 98usize, + unsafe { ::std::ptr::addr_of!((*ptr).cb_qp_offset_list) as usize - ptr as usize }, + 20usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(log2_parallel_merge_level_minus2) + stringify!(cb_qp_offset_list) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, - 104usize, + unsafe { ::std::ptr::addr_of!((*ptr).cr_qp_offset_list) as usize - ptr as usize }, + 26usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(pScalingLists) + stringify!(cr_qp_offset_list) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).log2_max_transform_skip_block_size_minus2) as usize - - ptr as usize - }, - 112usize, + unsafe { ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_luma) as usize - ptr as usize }, + 32usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(log2_max_transform_skip_block_size_minus2) + stringify!(log2_sao_offset_scale_luma) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).diff_cu_chroma_qp_offset_depth) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_chroma) as usize - ptr as usize }, - 113usize, + 33usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(diff_cu_chroma_qp_offset_depth) + stringify!(log2_sao_offset_scale_chroma) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_act_y_qp_offset_plus5) as usize - ptr as usize }, + 34usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_act_y_qp_offset_plus5) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cb_qp_offset_plus5) as usize - ptr as usize }, + 35usize, + concat!( + "Offset of field: ", + stringify!(StdVideoH265PictureParameterSet), + "::", + stringify!(pps_act_cb_qp_offset_plus5) + ) + ); + assert_eq!( + 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_plus3) ) ); assert_eq!( unsafe { - ::std::ptr::addr_of!((*ptr).chroma_qp_offset_list_len_minus1) as usize - ptr as usize + ::std::ptr::addr_of!((*ptr).pps_num_palette_predictor_initializers) as usize + - ptr as usize }, - 114usize, + 37usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(chroma_qp_offset_list_len_minus1) + stringify!(pps_num_palette_predictor_initializers) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cb_qp_offset_list) as usize - ptr as usize }, - 115usize, + unsafe { ::std::ptr::addr_of!((*ptr).luma_bit_depth_entry_minus8) as usize - ptr as usize }, + 38usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(cb_qp_offset_list) + stringify!(luma_bit_depth_entry_minus8) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cr_qp_offset_list) as usize - ptr as usize }, - 121usize, + unsafe { + ::std::ptr::addr_of!((*ptr).chroma_bit_depth_entry_minus8) as usize - ptr as usize + }, + 39usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(cr_qp_offset_list) + stringify!(chroma_bit_depth_entry_minus8) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_luma) as usize - ptr as usize }, - 127usize, + unsafe { ::std::ptr::addr_of!((*ptr).num_tile_columns_minus1) as usize - ptr as usize }, + 40usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(log2_sao_offset_scale_luma) + stringify!(num_tile_columns_minus1) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).log2_sao_offset_scale_chroma) as usize - ptr as usize - }, - 128usize, + unsafe { ::std::ptr::addr_of!((*ptr).num_tile_rows_minus1) as usize - ptr as usize }, + 41usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(log2_sao_offset_scale_chroma) + stringify!(num_tile_rows_minus1) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pps_act_y_qp_offset_plus5) as usize - ptr as usize }, - 129usize, + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 42usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(pps_act_y_qp_offset_plus5) + stringify!(reserved1) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pps_act_cb_qp_offset_plus5) as usize - ptr as usize }, - 130usize, + unsafe { ::std::ptr::addr_of!((*ptr).reserved2) as usize - ptr as usize }, + 43usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(pps_act_cb_qp_offset_plus5) + stringify!(reserved2) ) ); 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).column_width_minus1) as usize - ptr as usize }, + 44usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(pps_act_cr_qp_offset_plus5) + stringify!(column_width_minus1) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).pps_num_palette_predictor_initializer) as usize - - ptr as usize - }, - 132usize, + unsafe { ::std::ptr::addr_of!((*ptr).row_height_minus1) as usize - ptr as usize }, + 82usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(pps_num_palette_predictor_initializer) + stringify!(row_height_minus1) ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).luma_bit_depth_entry_minus8) as usize - ptr as usize }, - 133usize, + unsafe { ::std::ptr::addr_of!((*ptr).reserved3) as usize - ptr as usize }, + 124usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(luma_bit_depth_entry_minus8) + stringify!(reserved3) ) ); assert_eq!( - unsafe { - ::std::ptr::addr_of!((*ptr).chroma_bit_depth_entry_minus8) as usize - ptr as usize - }, - 134usize, + unsafe { ::std::ptr::addr_of!((*ptr).pScalingLists) as usize - ptr as usize }, + 128usize, concat!( "Offset of field: ", stringify!(StdVideoH265PictureParameterSet), "::", - stringify!(chroma_bit_depth_entry_minus8) + stringify!(pScalingLists) ) ); assert_eq!( @@ -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,39 +8024,61 @@ 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_loop_filter_across_slices_enabled_flag(&mut self, val: u32) { + 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(15usize, 1u8, val as u64) + } + } + #[inline] pub fn new_bitfield_1( first_slice_segment_in_pic_flag: u32, no_output_of_prior_pics_flag: u32, @@ -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 5177b119b..b7a86d3b2 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 5177b119bbdf463b7b909855a83230253c2d8b68 +Subproject commit b7a86d3b2bf8fbe73fcd40df9ec62a5966e9db89