diff --git a/Changelog.md b/Changelog.md index 1adb937..225d3eb 100644 --- a/Changelog.md +++ b/Changelog.md @@ -11,7 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Added `Handle::is_null()` to allow checking if a handle is a `NULL` value (#694) - Allow building `Entry`/`Instance`/`Device` from handle+fns (see their `from_parts_1_x()` associated functions) (#748) -- Update Vulkan-Headers to 1.3.260 (#760, #763) +- Update Vulkan-Headers to 1.3.269 (#760, #763, #783) - Added `VK_NV_memory_decompression` device extension (#761) - Added `VK_GOOGLE_display_timing` device extension (#765) - Added `VK_ANDROID_external_memory_android_hardware_buffer` device extension (#769) diff --git a/ash/Cargo.toml b/ash/Cargo.toml index db85169..fa424e8 100644 --- a/ash/Cargo.toml +++ b/ash/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ash" -version = "0.37.0+1.3.260" +version = "0.37.0+1.3.269" authors = [ "Maik Klein ", "Benjamin Saunders ", diff --git a/ash/src/vk/bitflags.rs b/ash/src/vk/bitflags.rs index dec02d9..130d576 100644 --- a/ash/src/vk/bitflags.rs +++ b/ash/src/vk/bitflags.rs @@ -1169,6 +1169,14 @@ impl DeviceAddressBindingFlagsEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct FrameBoundaryFlagsEXT(pub(crate) Flags); +vk_bitflags_wrapped!(FrameBoundaryFlagsEXT, Flags); +impl FrameBoundaryFlagsEXT { + pub const FRAME_END: Self = Self(0b1); +} +#[repr(transparent)] +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc = ""] pub struct PresentScalingFlagsEXT(pub(crate) Flags); vk_bitflags_wrapped!(PresentScalingFlagsEXT, Flags); @@ -1189,6 +1197,14 @@ impl PresentGravityFlagsEXT { } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +#[doc = ""] +pub struct PhysicalDeviceSchedulingControlsFlagsARM(pub(crate) Flags); +vk_bitflags_wrapped!(PhysicalDeviceSchedulingControlsFlagsARM, Flags); +impl PhysicalDeviceSchedulingControlsFlagsARM { + pub const SHADER_CORE_COUNT: 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); @@ -1303,6 +1319,7 @@ pub struct VideoEncodeCapabilityFlagsKHR(pub(crate) Flags); vk_bitflags_wrapped!(VideoEncodeCapabilityFlagsKHR, Flags); impl VideoEncodeCapabilityFlagsKHR { pub const PRECEDING_EXTERNALLY_ENCODED_BYTES: Self = Self(0b1); + pub const INSUFFICIENTSTREAM_BUFFER_RANGE_DETECTION: Self = Self(0b10); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -1365,6 +1382,8 @@ impl VideoEncodeH264StdFlagsEXT { pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1000_0000_0000_0000); pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b1_0000_0000_0000_0000); pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b10_0000_0000_0000_0000); + pub const SLICE_QP_DELTA: Self = Self(0b1000_0000_0000_0000_0000); + pub const DIFFERENT_SLICE_QP_DELTA: Self = Self(0b1_0000_0000_0000_0000_0000); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -1530,6 +1549,8 @@ impl VideoEncodeH265StdFlagsEXT { pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET: Self = Self(0b1_0000_0000_0000_0000); pub const DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET: Self = Self(0b10_0000_0000_0000_0000); pub const DEPENDENT_SLICE_SEGMENT_FLAG_SET: Self = Self(0b100_0000_0000_0000_0000); + pub const SLICE_QP_DELTA: Self = Self(0b1000_0000_0000_0000_0000); + pub const DIFFERENT_SLICE_QP_DELTA: Self = Self(0b1_0000_0000_0000_0000_0000); } #[repr(transparent)] #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] diff --git a/ash/src/vk/const_debugs.rs b/ash/src/vk/const_debugs.rs index 4923a8a..eb28195 100644 --- a/ash/src/vk/const_debugs.rs +++ b/ash/src/vk/const_debugs.rs @@ -484,6 +484,20 @@ impl fmt::Debug for BlendOverlapEXT { } } } +impl fmt::Debug for BlockMatchWindowCompareModeQCOM { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::MIN => Some("MIN"), + Self::MAX => Some("MAX"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for BorderColor { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -636,20 +650,20 @@ impl fmt::Debug for BufferUsageFlags2KHR { "EXECUTION_GRAPH_SCRATCH_AMDX", ), ( - BufferUsageFlags2KHR::CONDITIONAL_RENDERING.0, - "CONDITIONAL_RENDERING", + BufferUsageFlags2KHR::CONDITIONAL_RENDERING_EXT.0, + "CONDITIONAL_RENDERING_EXT", ), ( BufferUsageFlags2KHR::SHADER_BINDING_TABLE.0, "SHADER_BINDING_TABLE", ), ( - BufferUsageFlags2KHR::TRANSFORM_FEEDBACK_BUFFER.0, - "TRANSFORM_FEEDBACK_BUFFER", + BufferUsageFlags2KHR::TRANSFORM_FEEDBACK_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_BUFFER_EXT", ), ( - BufferUsageFlags2KHR::TRANSFORM_FEEDBACK_COUNTER_BUFFER.0, - "TRANSFORM_FEEDBACK_COUNTER_BUFFER", + BufferUsageFlags2KHR::TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT.0, + "TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT", ), (BufferUsageFlags2KHR::VIDEO_DECODE_SRC.0, "VIDEO_DECODE_SRC"), (BufferUsageFlags2KHR::VIDEO_DECODE_DST.0, "VIDEO_DECODE_DST"), @@ -668,22 +682,25 @@ impl fmt::Debug for BufferUsageFlags2KHR { "ACCELERATION_STRUCTURE_STORAGE", ), ( - BufferUsageFlags2KHR::SAMPLER_DESCRIPTOR_BUFFER.0, - "SAMPLER_DESCRIPTOR_BUFFER", + BufferUsageFlags2KHR::SAMPLER_DESCRIPTOR_BUFFER_EXT.0, + "SAMPLER_DESCRIPTOR_BUFFER_EXT", ), ( - BufferUsageFlags2KHR::RESOURCE_DESCRIPTOR_BUFFER.0, - "RESOURCE_DESCRIPTOR_BUFFER", + BufferUsageFlags2KHR::RESOURCE_DESCRIPTOR_BUFFER_EXT.0, + "RESOURCE_DESCRIPTOR_BUFFER_EXT", ), ( - BufferUsageFlags2KHR::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER.0, - "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER", + BufferUsageFlags2KHR::PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT.0, + "PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT", ), ( - BufferUsageFlags2KHR::MICROMAP_BUILD_INPUT_READ_ONLY.0, - "MICROMAP_BUILD_INPUT_READ_ONLY", + BufferUsageFlags2KHR::MICROMAP_BUILD_INPUT_READ_ONLY_EXT.0, + "MICROMAP_BUILD_INPUT_READ_ONLY_EXT", + ), + ( + BufferUsageFlags2KHR::MICROMAP_STORAGE_EXT.0, + "MICROMAP_STORAGE_EXT", ), - (BufferUsageFlags2KHR::MICROMAP_STORAGE.0, "MICROMAP_STORAGE"), ]; debug_flags(f, KNOWN, self.0) } @@ -1083,6 +1100,22 @@ impl fmt::Debug for CoverageReductionModeNV { } } } +impl fmt::Debug for CubicFilterWeightsQCOM { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::CATMULL_ROM => Some("CATMULL_ROM"), + Self::ZERO_TANGENT_CARDINAL => Some("ZERO_TANGENT_CARDINAL"), + Self::B_SPLINE => Some("B_SPLINE"), + Self::MITCHELL_NETRAVALI => Some("MITCHELL_NETRAVALI"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for CullModeFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -1150,6 +1183,8 @@ impl fmt::Debug for DebugReportObjectTypeEXT { Self::CU_FUNCTION_NVX => Some("CU_FUNCTION_NVX"), Self::ACCELERATION_STRUCTURE_KHR => Some("ACCELERATION_STRUCTURE_KHR"), Self::ACCELERATION_STRUCTURE_NV => Some("ACCELERATION_STRUCTURE_NV"), + Self::CUDA_MODULE_NV => Some("CUDA_MODULE_NV"), + Self::CUDA_FUNCTION_NV => Some("CUDA_FUNCTION_NV"), Self::BUFFER_COLLECTION_FUCHSIA => Some("BUFFER_COLLECTION_FUCHSIA"), _ => None, }; @@ -1253,6 +1288,14 @@ impl fmt::Debug for DescriptorPoolCreateFlags { "FREE_DESCRIPTOR_SET", ), (DescriptorPoolCreateFlags::HOST_ONLY_EXT.0, "HOST_ONLY_EXT"), + ( + DescriptorPoolCreateFlags::ALLOW_OVERALLOCATION_SETS_NV.0, + "ALLOW_OVERALLOCATION_SETS_NV", + ), + ( + DescriptorPoolCreateFlags::ALLOW_OVERALLOCATION_POOLS_NV.0, + "ALLOW_OVERALLOCATION_POOLS_NV", + ), ( DescriptorPoolCreateFlags::UPDATE_AFTER_BIND.0, "UPDATE_AFTER_BIND", @@ -1624,6 +1667,7 @@ impl fmt::Debug for DriverId { Self::MESA_DOZEN => Some("MESA_DOZEN"), Self::MESA_NVK => Some("MESA_NVK"), Self::IMAGINATION_OPEN_SOURCE_MESA => Some("IMAGINATION_OPEN_SOURCE_MESA"), + Self::MESA_AGXV => Some("MESA_AGXV"), _ => None, }; if let Some(x) = name { @@ -2314,6 +2358,12 @@ impl fmt::Debug for FragmentShadingRateTypeNV { } } } +impl fmt::Debug for FrameBoundaryFlagsEXT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[(FrameBoundaryFlagsEXT::FRAME_END.0, "FRAME_END")]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for FramebufferCreateFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[(FramebufferCreateFlags::IMAGELESS.0, "IMAGELESS")]; @@ -2918,6 +2968,44 @@ impl fmt::Debug for InternalAllocationType { } } } +impl fmt::Debug for LatencyMarkerNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::SIMULATION_START => Some("SIMULATION_START"), + Self::SIMULATION_END => Some("SIMULATION_END"), + Self::RENDERSUBMIT_START => Some("RENDERSUBMIT_START"), + Self::RENDERSUBMIT_END => Some("RENDERSUBMIT_END"), + Self::PRESENT_START => Some("PRESENT_START"), + Self::PRESENT_END => Some("PRESENT_END"), + Self::INPUT_SAMPLE => Some("INPUT_SAMPLE"), + Self::TRIGGER_FLASH => Some("TRIGGER_FLASH"), + Self::OUT_OF_BAND_RENDERSUBMIT_START => Some("OUT_OF_BAND_RENDERSUBMIT_START"), + Self::OUT_OF_BAND_RENDERSUBMIT_END => Some("OUT_OF_BAND_RENDERSUBMIT_END"), + Self::OUT_OF_BAND_PRESENT_START => Some("OUT_OF_BAND_PRESENT_START"), + Self::OUT_OF_BAND_PRESENT_END => Some("OUT_OF_BAND_PRESENT_END"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} +impl fmt::Debug for LayeredDriverUnderlyingApiMSFT { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::NONE => Some("NONE"), + Self::D3D12 => Some("D3D12"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for LineRasterizationModeEXT { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -3205,6 +3293,20 @@ impl fmt::Debug for OpticalFlowUsageFlagsNV { debug_flags(f, KNOWN, self.0) } } +impl fmt::Debug for OutOfBandQueueTypeNV { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let name = match *self { + Self::RENDER => Some("RENDER"), + Self::PRESENT => Some("PRESENT"), + _ => None, + }; + if let Some(x) = name { + f.write_str(x) + } else { + self.0.fmt(f) + } + } +} impl fmt::Debug for PeerMemoryFeatureFlags { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { const KNOWN: &[(Flags, &str)] = &[ @@ -3347,6 +3449,15 @@ impl fmt::Debug for PerformanceValueTypeINTEL { } } } +impl fmt::Debug for PhysicalDeviceSchedulingControlsFlagsARM { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + const KNOWN: &[(Flags, &str)] = &[( + PhysicalDeviceSchedulingControlsFlagsARM::SHADER_CORE_COUNT.0, + "SHADER_CORE_COUNT", + )]; + debug_flags(f, KNOWN, self.0) + } +} impl fmt::Debug for PhysicalDeviceType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -3567,13 +3678,15 @@ impl fmt::Debug for PipelineCreateFlags2KHR { "ALLOW_DERIVATIVES", ), (PipelineCreateFlags2KHR::DERIVATIVE.0, "DERIVATIVE"), - (PipelineCreateFlags2KHR::RESERVED_28_NV.0, "RESERVED_28_NV"), ( PipelineCreateFlags2KHR::VIEW_INDEX_FROM_DEVICE_INDEX.0, "VIEW_INDEX_FROM_DEVICE_INDEX", ), (PipelineCreateFlags2KHR::DISPATCH_BASE.0, "DISPATCH_BASE"), - (PipelineCreateFlags2KHR::DEFER_COMPILE.0, "DEFER_COMPILE"), + ( + PipelineCreateFlags2KHR::DEFER_COMPILE_NV.0, + "DEFER_COMPILE_NV", + ), ( PipelineCreateFlags2KHR::CAPTURE_STATISTICS.0, "CAPTURE_STATISTICS", @@ -3591,12 +3704,12 @@ impl fmt::Debug for PipelineCreateFlags2KHR { "EARLY_RETURN_ON_FAILURE", ), ( - PipelineCreateFlags2KHR::LINK_TIME_OPTIMIZATION.0, - "LINK_TIME_OPTIMIZATION", + PipelineCreateFlags2KHR::LINK_TIME_OPTIMIZATION_EXT.0, + "LINK_TIME_OPTIMIZATION_EXT", ), ( - PipelineCreateFlags2KHR::RETAIN_LINK_TIME_OPTIMIZATION_INFO.0, - "RETAIN_LINK_TIME_OPTIMIZATION_INFO", + PipelineCreateFlags2KHR::RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT.0, + "RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT", ), (PipelineCreateFlags2KHR::LIBRARY.0, "LIBRARY"), ( @@ -3628,44 +3741,48 @@ impl fmt::Debug for PipelineCreateFlags2KHR { "RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY", ), ( - PipelineCreateFlags2KHR::INDIRECT_BINDABLE.0, - "INDIRECT_BINDABLE", + PipelineCreateFlags2KHR::INDIRECT_BINDABLE_NV.0, + "INDIRECT_BINDABLE_NV", ), ( - PipelineCreateFlags2KHR::RAY_TRACING_ALLOW_MOTION.0, - "RAY_TRACING_ALLOW_MOTION", + PipelineCreateFlags2KHR::RAY_TRACING_ALLOW_MOTION_NV.0, + "RAY_TRACING_ALLOW_MOTION_NV", ), ( PipelineCreateFlags2KHR::RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT.0, "RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT", ), ( - PipelineCreateFlags2KHR::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT.0, - "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT", + PipelineCreateFlags2KHR::RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT.0, + "RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT", ), ( - PipelineCreateFlags2KHR::RAY_TRACING_OPACITY_MICROMAP.0, - "RAY_TRACING_OPACITY_MICROMAP", + PipelineCreateFlags2KHR::RAY_TRACING_OPACITY_MICROMAP_EXT.0, + "RAY_TRACING_OPACITY_MICROMAP_EXT", ), ( - PipelineCreateFlags2KHR::COLOR_ATTACHMENT_FEEDBACK_LOOP.0, - "COLOR_ATTACHMENT_FEEDBACK_LOOP", + PipelineCreateFlags2KHR::COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT.0, + "COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT", ), ( - PipelineCreateFlags2KHR::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP.0, - "DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP", + PipelineCreateFlags2KHR::DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT.0, + "DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT", ), ( - PipelineCreateFlags2KHR::NO_PROTECTED_ACCESS.0, - "NO_PROTECTED_ACCESS", + PipelineCreateFlags2KHR::NO_PROTECTED_ACCESS_EXT.0, + "NO_PROTECTED_ACCESS_EXT", ), ( - PipelineCreateFlags2KHR::PROTECTED_ACCESS_ONLY.0, - "PROTECTED_ACCESS_ONLY", + PipelineCreateFlags2KHR::PROTECTED_ACCESS_ONLY_EXT.0, + "PROTECTED_ACCESS_ONLY_EXT", ), ( - PipelineCreateFlags2KHR::DESCRIPTOR_BUFFER.0, - "DESCRIPTOR_BUFFER", + PipelineCreateFlags2KHR::RAY_TRACING_DISPLACEMENT_MICROMAP_NV.0, + "RAY_TRACING_DISPLACEMENT_MICROMAP_NV", + ), + ( + PipelineCreateFlags2KHR::DESCRIPTOR_BUFFER_EXT.0, + "DESCRIPTOR_BUFFER_EXT", ), ]; debug_flags(f, KNOWN, self.0) @@ -4233,6 +4350,7 @@ impl fmt::Debug for QueryResultStatusKHR { Self::ERROR => Some("ERROR"), Self::NOT_READY => Some("NOT_READY"), Self::COMPLETE => Some("COMPLETE"), + Self::INSUFFICIENTSTREAM_BUFFER_RANGE => Some("INSUFFICIENTSTREAM_BUFFER_RANGE"), _ => None, }; if let Some(x) = name { @@ -4369,6 +4487,7 @@ impl fmt::Debug for RenderingFlags { ), (RenderingFlags::SUSPENDING.0, "SUSPENDING"), (RenderingFlags::RESUMING.0, "RESUMING"), + (RenderingFlags::CONTENTS_INLINE_EXT.0, "CONTENTS_INLINE_EXT"), ( RenderingFlags::ENABLE_LEGACY_DITHERING_EXT.0, "ENABLE_LEGACY_DITHERING_EXT", @@ -4385,6 +4504,10 @@ impl fmt::Debug for ResolveModeFlags { (ResolveModeFlags::AVERAGE.0, "AVERAGE"), (ResolveModeFlags::MIN.0, "MIN"), (ResolveModeFlags::MAX.0, "MAX"), + ( + ResolveModeFlags::EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID.0, + "EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -4464,6 +4587,7 @@ impl fmt::Debug for SamplerReductionMode { Self::WEIGHTED_AVERAGE => Some("WEIGHTED_AVERAGE"), Self::MIN => Some("MIN"), Self::MAX => Some("MAX"), + Self::WEIGHTED_AVERAGE_RANGECLAMP_QCOM => Some("WEIGHTED_AVERAGE_RANGECLAMP_QCOM"), _ => None, }; if let Some(x) = name { @@ -5773,6 +5897,15 @@ impl fmt::Debug for StructureType { Self::DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV => { Some("DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV") } + Self::CUDA_MODULE_CREATE_INFO_NV => Some("CUDA_MODULE_CREATE_INFO_NV"), + Self::CUDA_FUNCTION_CREATE_INFO_NV => Some("CUDA_FUNCTION_CREATE_INFO_NV"), + Self::CUDA_LAUNCH_INFO_NV => Some("CUDA_LAUNCH_INFO_NV"), + Self::PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV => { + Some("PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV") + } Self::QUERY_LOW_LATENCY_SUPPORT_NV => Some("QUERY_LOW_LATENCY_SUPPORT_NV"), Self::EXPORT_METAL_OBJECT_CREATE_INFO_EXT => { Some("EXPORT_METAL_OBJECT_CREATE_INFO_EXT") @@ -5987,6 +6120,10 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT") + } + Self::FRAME_BOUNDARY_EXT => Some("FRAME_BOUNDARY_EXT"), Self::PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT => { Some("PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT") } @@ -6074,6 +6211,15 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM => { Some("PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM") } + Self::DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM => { + Some("DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM") + } + Self::PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM => { + Some("PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM") + } + Self::PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM => { + Some("PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM") + } Self::PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT => { Some("PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT") } @@ -6138,6 +6284,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_NESTED_COMMAND_BUFFER_FEATURES_EXT => { + Some("PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT") + } + Self::PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT => { + Some("PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT") + } Self::EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT => { Some("EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT") } @@ -6195,6 +6347,15 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT") } + Self::PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID => { + Some("PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID") + } + Self::PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID => { + Some("PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID") + } + Self::ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID => { + Some("ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID") + } Self::PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR => { Some("PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR") } @@ -6238,6 +6399,12 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV => { Some("PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV") } + Self::PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV => { + Some("PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV") + } + Self::PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV => { + Some("PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV") + } Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT => { Some("PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT") } @@ -6256,6 +6423,15 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT => { Some("PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT") } + Self::LATENCY_SLEEP_MODE_INFO_NV => Some("LATENCY_SLEEP_MODE_INFO_NV"), + Self::LATENCY_SLEEP_INFO_NV => Some("LATENCY_SLEEP_INFO_NV"), + Self::SET_LATENCY_MARKER_INFO_NV => Some("SET_LATENCY_MARKER_INFO_NV"), + Self::GET_LATENCY_MARKER_INFO_NV => Some("GET_LATENCY_MARKER_INFO_NV"), + Self::LATENCY_TIMINGS_FRAME_REPORT_NV => Some("LATENCY_TIMINGS_FRAME_REPORT_NV"), + Self::LATENCY_SUBMISSION_PRESENT_ID_NV => Some("LATENCY_SUBMISSION_PRESENT_ID_NV"), + Self::OUT_OF_BAND_QUEUE_TYPE_INFO_NV => Some("OUT_OF_BAND_QUEUE_TYPE_INFO_NV"), + Self::SWAPCHAIN_LATENCY_CREATE_INFO_NV => Some("SWAPCHAIN_LATENCY_CREATE_INFO_NV"), + Self::LATENCY_SURFACE_CAPABILITIES_NV => Some("LATENCY_SURFACE_CAPABILITIES_NV"), Self::PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR => { Some("PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR") } @@ -6269,6 +6445,31 @@ impl fmt::Debug for StructureType { Self::MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM => { Some("MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM") } + Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM") + } + Self::PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM => { + Some("PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM") + } + Self::SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM => { + Some("SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM") + } + Self::SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM => { + Some("SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM") + } + Self::PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM") + } + Self::BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM => Some("BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM"), + Self::PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM") + } + Self::SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM => { + Some("SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM") + } + Self::PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM => { + Some("PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM") + } Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT => { Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT") } @@ -6281,6 +6482,12 @@ impl fmt::Debug for StructureType { Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX => { Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX") } + Self::PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT => { + Some("PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT") + } + Self::PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV => { + Some("PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV") + } Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => { Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES") } @@ -6654,6 +6861,9 @@ impl fmt::Debug for SubpassContents { let name = match *self { Self::INLINE => Some("INLINE"), Self::SECONDARY_COMMAND_BUFFERS => Some("SECONDARY_COMMAND_BUFFERS"), + Self::INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT => { + Some("INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT") + } _ => None, }; if let Some(x) = name { @@ -7096,10 +7306,16 @@ impl fmt::Debug for VideoDecodeUsageFlagsKHR { } impl fmt::Debug for VideoEncodeCapabilityFlagsKHR { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - const KNOWN: &[(Flags, &str)] = &[( - VideoEncodeCapabilityFlagsKHR::PRECEDING_EXTERNALLY_ENCODED_BYTES.0, - "PRECEDING_EXTERNALLY_ENCODED_BYTES", - )]; + const KNOWN: &[(Flags, &str)] = &[ + ( + VideoEncodeCapabilityFlagsKHR::PRECEDING_EXTERNALLY_ENCODED_BYTES.0, + "PRECEDING_EXTERNALLY_ENCODED_BYTES", + ), + ( + VideoEncodeCapabilityFlagsKHR::INSUFFICIENTSTREAM_BUFFER_RANGE_DETECTION.0, + "INSUFFICIENTSTREAM_BUFFER_RANGE_DETECTION", + ), + ]; debug_flags(f, KNOWN, self.0) } } @@ -7284,6 +7500,14 @@ impl fmt::Debug for VideoEncodeH264StdFlagsEXT { VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0, "DEBLOCKING_FILTER_PARTIAL", ), + ( + VideoEncodeH264StdFlagsEXT::SLICE_QP_DELTA.0, + "SLICE_QP_DELTA", + ), + ( + VideoEncodeH264StdFlagsEXT::DIFFERENT_SLICE_QP_DELTA.0, + "DIFFERENT_SLICE_QP_DELTA", + ), ]; debug_flags(f, KNOWN, self.0) } @@ -7451,6 +7675,14 @@ impl fmt::Debug for VideoEncodeH265StdFlagsEXT { VideoEncodeH265StdFlagsEXT::DEPENDENT_SLICE_SEGMENT_FLAG_SET.0, "DEPENDENT_SLICE_SEGMENT_FLAG_SET", ), + ( + VideoEncodeH265StdFlagsEXT::SLICE_QP_DELTA.0, + "SLICE_QP_DELTA", + ), + ( + VideoEncodeH265StdFlagsEXT::DIFFERENT_SLICE_QP_DELTA.0, + "DIFFERENT_SLICE_QP_DELTA", + ), ]; debug_flags(f, KNOWN, self.0) } diff --git a/ash/src/vk/definitions.rs b/ash/src/vk/definitions.rs index c5ab81e..13dfe63 100644 --- a/ash/src/vk/definitions.rs +++ b/ash/src/vk/definitions.rs @@ -58,7 +58,7 @@ 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); #[doc = ""] -pub const HEADER_VERSION: u32 = 260; +pub const HEADER_VERSION: u32 = 269; #[doc = ""] pub const HEADER_VERSION_COMPLETE: u32 = make_api_version(0, 1, 3, HEADER_VERSION); #[doc = ""] @@ -21055,6 +21055,9 @@ unsafe impl<'a> TaggedStructure for ExternalFormatANDROID<'a> { } unsafe impl ExtendsImageCreateInfo for ExternalFormatANDROID<'_> {} unsafe impl ExtendsSamplerYcbcrConversionCreateInfo for ExternalFormatANDROID<'_> {} +unsafe impl ExtendsAttachmentDescription2 for ExternalFormatANDROID<'_> {} +unsafe impl ExtendsGraphicsPipelineCreateInfo for ExternalFormatANDROID<'_> {} +unsafe impl ExtendsCommandBufferInheritanceInfo for ExternalFormatANDROID<'_> {} impl<'a> ExternalFormatANDROID<'a> { #[inline] pub fn external_format(mut self, external_format: u64) -> Self { @@ -34175,6 +34178,7 @@ impl ::std::default::Default for BlitImageInfo2<'_> { unsafe impl<'a> TaggedStructure for BlitImageInfo2<'a> { const STRUCTURE_TYPE: StructureType = StructureType::BLIT_IMAGE_INFO_2; } +pub unsafe trait ExtendsBlitImageInfo2 {} impl<'a> BlitImageInfo2<'a> { #[inline] pub fn src_image(mut self, src_image: Image) -> Self { @@ -34207,6 +34211,20 @@ impl<'a> BlitImageInfo2<'a> { self.filter = filter; 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))] @@ -43711,6 +43729,180 @@ impl<'a> BufferCollectionConstraintsInfoFUCHSIA<'a> { self } } +handle_nondispatchable ! (CudaModuleNV , CUDA_MODULE_NV , doc = "") ; +handle_nondispatchable ! (CudaFunctionNV , CUDA_FUNCTION_NV , doc = "") ; +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CudaModuleCreateInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub data_size: usize, + pub p_data: *const c_void, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for CudaModuleCreateInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + data_size: usize::default(), + p_data: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CudaModuleCreateInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::CUDA_MODULE_CREATE_INFO_NV; +} +impl<'a> CudaModuleCreateInfoNV<'a> { + #[inline] + pub fn data(mut self, data: &'a [u8]) -> Self { + self.data_size = data.len(); + self.p_data = data.as_ptr().cast(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CudaFunctionCreateInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub module: CudaModuleNV, + pub p_name: *const c_char, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for CudaFunctionCreateInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + module: CudaModuleNV::default(), + p_name: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CudaFunctionCreateInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::CUDA_FUNCTION_CREATE_INFO_NV; +} +impl<'a> CudaFunctionCreateInfoNV<'a> { + #[inline] + pub fn module(mut self, module: CudaModuleNV) -> Self { + self.module = module; + self + } + #[inline] + pub fn name(mut self, name: &'a ::std::ffi::CStr) -> Self { + self.p_name = name.as_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct CudaLaunchInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub function: CudaFunctionNV, + pub grid_dim_x: u32, + pub grid_dim_y: u32, + pub grid_dim_z: u32, + pub block_dim_x: u32, + pub block_dim_y: u32, + pub block_dim_z: u32, + pub shared_mem_bytes: u32, + pub param_count: usize, + pub p_params: *const *const c_void, + pub extra_count: usize, + pub p_extras: *const *const c_void, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for CudaLaunchInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + function: CudaFunctionNV::default(), + grid_dim_x: u32::default(), + grid_dim_y: u32::default(), + grid_dim_z: u32::default(), + block_dim_x: u32::default(), + block_dim_y: u32::default(), + block_dim_z: u32::default(), + shared_mem_bytes: u32::default(), + param_count: usize::default(), + p_params: ::std::ptr::null(), + extra_count: usize::default(), + p_extras: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for CudaLaunchInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::CUDA_LAUNCH_INFO_NV; +} +impl<'a> CudaLaunchInfoNV<'a> { + #[inline] + pub fn function(mut self, function: CudaFunctionNV) -> Self { + self.function = function; + self + } + #[inline] + pub fn grid_dim_x(mut self, grid_dim_x: u32) -> Self { + self.grid_dim_x = grid_dim_x; + self + } + #[inline] + pub fn grid_dim_y(mut self, grid_dim_y: u32) -> Self { + self.grid_dim_y = grid_dim_y; + self + } + #[inline] + pub fn grid_dim_z(mut self, grid_dim_z: u32) -> Self { + self.grid_dim_z = grid_dim_z; + self + } + #[inline] + pub fn block_dim_x(mut self, block_dim_x: u32) -> Self { + self.block_dim_x = block_dim_x; + self + } + #[inline] + pub fn block_dim_y(mut self, block_dim_y: u32) -> Self { + self.block_dim_y = block_dim_y; + self + } + #[inline] + pub fn block_dim_z(mut self, block_dim_z: u32) -> Self { + self.block_dim_z = block_dim_z; + self + } + #[inline] + pub fn shared_mem_bytes(mut self, shared_mem_bytes: u32) -> Self { + self.shared_mem_bytes = shared_mem_bytes; + self + } + #[inline] + pub fn params(mut self, params: &'a [*const c_void]) -> Self { + self.param_count = params.len(); + self.p_params = params.as_ptr(); + self + } + #[inline] + pub fn extras(mut self, extras: &'a [*const c_void]) -> Self { + self.extra_count = extras.len(); + self.p_extras = extras.as_ptr(); + self + } +} #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] @@ -44889,6 +45081,99 @@ impl<'a> DescriptorSetLayoutHostMappingInfoVALVE<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub nested_command_buffer: Bool32, + pub nested_command_buffer_rendering: Bool32, + pub nested_command_buffer_simultaneous_use: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceNestedCommandBufferFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + nested_command_buffer: Bool32::default(), + nested_command_buffer_rendering: Bool32::default(), + nested_command_buffer_simultaneous_use: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceNestedCommandBufferFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceNestedCommandBufferFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceNestedCommandBufferFeaturesEXT<'a> { + #[inline] + pub fn nested_command_buffer(mut self, nested_command_buffer: bool) -> Self { + self.nested_command_buffer = nested_command_buffer.into(); + self + } + #[inline] + pub fn nested_command_buffer_rendering( + mut self, + nested_command_buffer_rendering: bool, + ) -> Self { + self.nested_command_buffer_rendering = nested_command_buffer_rendering.into(); + self + } + #[inline] + pub fn nested_command_buffer_simultaneous_use( + mut self, + nested_command_buffer_simultaneous_use: bool, + ) -> Self { + self.nested_command_buffer_simultaneous_use = nested_command_buffer_simultaneous_use.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_command_buffer_nesting_level: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceNestedCommandBufferPropertiesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_command_buffer_nesting_level: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceNestedCommandBufferPropertiesEXT<'_> +{ +} +impl<'a> PhysicalDeviceNestedCommandBufferPropertiesEXT<'a> { + #[inline] + pub fn max_command_buffer_nesting_level( + mut self, + max_command_buffer_nesting_level: u32, + ) -> Self { + self.max_command_buffer_nesting_level = max_command_buffer_nesting_level; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT<'a> { pub s_type: StructureType, @@ -48660,6 +48945,119 @@ impl<'a> PhysicalDeviceShaderCoreBuiltinsFeaturesARM<'a> { #[repr(C)] #[cfg_attr(feature = "debug", derive(Debug))] #[derive(Copy, Clone)] +#[doc = ""] +pub struct FrameBoundaryEXT<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub flags: FrameBoundaryFlagsEXT, + pub frame_id: u64, + pub image_count: u32, + pub p_images: *const Image, + pub buffer_count: u32, + pub p_buffers: *const Buffer, + pub tag_name: u64, + pub tag_size: usize, + pub p_tag: *const c_void, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for FrameBoundaryEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + flags: FrameBoundaryFlagsEXT::default(), + frame_id: u64::default(), + image_count: u32::default(), + p_images: ::std::ptr::null(), + buffer_count: u32::default(), + p_buffers: ::std::ptr::null(), + tag_name: u64::default(), + tag_size: usize::default(), + p_tag: ::std::ptr::null(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for FrameBoundaryEXT<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::FRAME_BOUNDARY_EXT; +} +unsafe impl ExtendsSubmitInfo for FrameBoundaryEXT<'_> {} +unsafe impl ExtendsSubmitInfo2 for FrameBoundaryEXT<'_> {} +unsafe impl ExtendsPresentInfoKHR for FrameBoundaryEXT<'_> {} +unsafe impl ExtendsBindSparseInfo for FrameBoundaryEXT<'_> {} +impl<'a> FrameBoundaryEXT<'a> { + #[inline] + pub fn flags(mut self, flags: FrameBoundaryFlagsEXT) -> Self { + self.flags = flags; + self + } + #[inline] + pub fn frame_id(mut self, frame_id: u64) -> Self { + self.frame_id = frame_id; + self + } + #[inline] + pub fn images(mut self, images: &'a [Image]) -> Self { + self.image_count = images.len() as _; + self.p_images = images.as_ptr(); + self + } + #[inline] + pub fn buffers(mut self, buffers: &'a [Buffer]) -> Self { + self.buffer_count = buffers.len() as _; + self.p_buffers = buffers.as_ptr(); + self + } + #[inline] + pub fn tag_name(mut self, tag_name: u64) -> Self { + self.tag_name = tag_name; + self + } + #[inline] + pub fn tag(mut self, tag: &'a [u8]) -> Self { + self.tag_size = tag.len(); + self.p_tag = tag.as_ptr().cast(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceFrameBoundaryFeaturesEXT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub frame_boundary: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceFrameBoundaryFeaturesEXT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + frame_boundary: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceFrameBoundaryFeaturesEXT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceFrameBoundaryFeaturesEXT<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceFrameBoundaryFeaturesEXT<'_> {} +impl<'a> PhysicalDeviceFrameBoundaryFeaturesEXT<'a> { + #[inline] + pub fn frame_boundary(mut self, frame_boundary: bool) -> Self { + self.frame_boundary = frame_boundary.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] #[doc = ""] pub struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT<'a> { pub s_type: StructureType, @@ -49200,6 +49598,102 @@ impl<'a> PhysicalDeviceRayTracingInvocationReorderPropertiesNV<'a> { } } #[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_sparse_address_space: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + extended_sparse_address_space: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'_> {} +impl<'a> PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV<'a> { + #[inline] + pub fn extended_sparse_address_space(mut self, extended_sparse_address_space: bool) -> Self { + self.extended_sparse_address_space = extended_sparse_address_space.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub extended_sparse_address_space_size: DeviceSize, + pub extended_sparse_image_usage_flags: ImageUsageFlags, + pub extended_sparse_buffer_usage_flags: BufferUsageFlags, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + extended_sparse_address_space_size: DeviceSize::default(), + extended_sparse_image_usage_flags: ImageUsageFlags::default(), + extended_sparse_buffer_usage_flags: BufferUsageFlags::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'_> +{ +} +impl<'a> PhysicalDeviceExtendedSparseAddressSpacePropertiesNV<'a> { + #[inline] + pub fn extended_sparse_address_space_size( + mut self, + extended_sparse_address_space_size: DeviceSize, + ) -> Self { + self.extended_sparse_address_space_size = extended_sparse_address_space_size; + self + } + #[inline] + pub fn extended_sparse_image_usage_flags( + mut self, + extended_sparse_image_usage_flags: ImageUsageFlags, + ) -> Self { + self.extended_sparse_image_usage_flags = extended_sparse_image_usage_flags; + self + } + #[inline] + pub fn extended_sparse_buffer_usage_flags( + mut self, + extended_sparse_buffer_usage_flags: BufferUsageFlags, + ) -> Self { + self.extended_sparse_buffer_usage_flags = extended_sparse_buffer_usage_flags; + self + } +} +#[repr(C)] #[derive(Copy, Clone)] #[doc = ""] pub struct DirectDriverLoadingInfoLUNARG<'a> { @@ -50712,3 +51206,1107 @@ impl DispatchGraphCountInfoAMDX { self } } +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCubicClampFeaturesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub cubic_range_clamp: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceCubicClampFeaturesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + cubic_range_clamp: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceCubicClampFeaturesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCubicClampFeaturesQCOM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCubicClampFeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceCubicClampFeaturesQCOM<'a> { + #[inline] + pub fn cubic_range_clamp(mut self, cubic_range_clamp: bool) -> Self { + self.cubic_range_clamp = cubic_range_clamp.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub ycbcr_degamma: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + ycbcr_degamma: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceYcbcrDegammaFeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceYcbcrDegammaFeaturesQCOM<'a> { + #[inline] + pub fn ycbcr_degamma(mut self, ycbcr_degamma: bool) -> Self { + self.ycbcr_degamma = ycbcr_degamma.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub enable_y_degamma: Bool32, + pub enable_cb_cr_degamma: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + enable_y_degamma: Bool32::default(), + enable_cb_cr_degamma: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM; +} +unsafe impl ExtendsSamplerYcbcrConversionCreateInfo + for SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'_> +{ +} +impl<'a> SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM<'a> { + #[inline] + pub fn enable_y_degamma(mut self, enable_y_degamma: bool) -> Self { + self.enable_y_degamma = enable_y_degamma.into(); + self + } + #[inline] + pub fn enable_cb_cr_degamma(mut self, enable_cb_cr_degamma: bool) -> Self { + self.enable_cb_cr_degamma = enable_cb_cr_degamma.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCubicWeightsFeaturesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub selectable_cubic_weights: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceCubicWeightsFeaturesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + selectable_cubic_weights: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceCubicWeightsFeaturesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCubicWeightsFeaturesQCOM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCubicWeightsFeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceCubicWeightsFeaturesQCOM<'a> { + #[inline] + pub fn selectable_cubic_weights(mut self, selectable_cubic_weights: bool) -> Self { + self.selectable_cubic_weights = selectable_cubic_weights.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerCubicWeightsCreateInfoQCOM<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub cubic_weights: CubicFilterWeightsQCOM, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SamplerCubicWeightsCreateInfoQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + cubic_weights: CubicFilterWeightsQCOM::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SamplerCubicWeightsCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM; +} +unsafe impl ExtendsSamplerCreateInfo for SamplerCubicWeightsCreateInfoQCOM<'_> {} +impl<'a> SamplerCubicWeightsCreateInfoQCOM<'a> { + #[inline] + pub fn cubic_weights(mut self, cubic_weights: CubicFilterWeightsQCOM) -> Self { + self.cubic_weights = cubic_weights; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct BlitImageCubicWeightsInfoQCOM<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub cubic_weights: CubicFilterWeightsQCOM, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for BlitImageCubicWeightsInfoQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + cubic_weights: CubicFilterWeightsQCOM::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for BlitImageCubicWeightsInfoQCOM<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM; +} +unsafe impl ExtendsBlitImageInfo2 for BlitImageCubicWeightsInfoQCOM<'_> {} +impl<'a> BlitImageCubicWeightsInfoQCOM<'a> { + #[inline] + pub fn cubic_weights(mut self, cubic_weights: CubicFilterWeightsQCOM) -> Self { + self.cubic_weights = cubic_weights; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageProcessing2FeaturesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub texture_block_match2: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceImageProcessing2FeaturesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + texture_block_match2: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceImageProcessing2FeaturesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceImageProcessing2FeaturesQCOM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceImageProcessing2FeaturesQCOM<'_> {} +impl<'a> PhysicalDeviceImageProcessing2FeaturesQCOM<'a> { + #[inline] + pub fn texture_block_match2(mut self, texture_block_match2: bool) -> Self { + self.texture_block_match2 = texture_block_match2.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceImageProcessing2PropertiesQCOM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub max_block_match_window: Extent2D, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceImageProcessing2PropertiesQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + max_block_match_window: Extent2D::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceImageProcessing2PropertiesQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceImageProcessing2PropertiesQCOM<'_> {} +impl<'a> PhysicalDeviceImageProcessing2PropertiesQCOM<'a> { + #[inline] + pub fn max_block_match_window(mut self, max_block_match_window: Extent2D) -> Self { + self.max_block_match_window = max_block_match_window; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SamplerBlockMatchWindowCreateInfoQCOM<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub window_extent: Extent2D, + pub window_compare_mode: BlockMatchWindowCompareModeQCOM, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SamplerBlockMatchWindowCreateInfoQCOM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + window_extent: Extent2D::default(), + window_compare_mode: BlockMatchWindowCompareModeQCOM::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SamplerBlockMatchWindowCreateInfoQCOM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM; +} +unsafe impl ExtendsSamplerCreateInfo for SamplerBlockMatchWindowCreateInfoQCOM<'_> {} +impl<'a> SamplerBlockMatchWindowCreateInfoQCOM<'a> { + #[inline] + pub fn window_extent(mut self, window_extent: Extent2D) -> Self { + self.window_extent = window_extent; + self + } + #[inline] + pub fn window_compare_mode( + mut self, + window_compare_mode: BlockMatchWindowCompareModeQCOM, + ) -> Self { + self.window_compare_mode = window_compare_mode; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub descriptor_pool_overallocation: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + descriptor_pool_overallocation: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'_> {} +impl<'a> PhysicalDeviceDescriptorPoolOverallocationFeaturesNV<'a> { + #[inline] + pub fn descriptor_pool_overallocation(mut self, descriptor_pool_overallocation: bool) -> Self { + self.descriptor_pool_overallocation = descriptor_pool_overallocation.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceLayeredDriverPropertiesMSFT<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub underlying_api: LayeredDriverUnderlyingApiMSFT, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceLayeredDriverPropertiesMSFT<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + underlying_api: LayeredDriverUnderlyingApiMSFT::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceLayeredDriverPropertiesMSFT<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceLayeredDriverPropertiesMSFT<'_> {} +impl<'a> PhysicalDeviceLayeredDriverPropertiesMSFT<'a> { + #[inline] + pub fn underlying_api(mut self, underlying_api: LayeredDriverUnderlyingApiMSFT) -> Self { + self.underlying_api = underlying_api; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub external_format_resolve: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + external_format_resolve: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 + for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'_> +{ +} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceExternalFormatResolveFeaturesANDROID<'_> {} +impl<'a> PhysicalDeviceExternalFormatResolveFeaturesANDROID<'a> { + #[inline] + pub fn external_format_resolve(mut self, external_format_resolve: bool) -> Self { + self.external_format_resolve = external_format_resolve.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub null_color_attachment_with_external_format_resolve: Bool32, + pub external_format_resolve_chroma_offset_x: ChromaLocation, + pub external_format_resolve_chroma_offset_y: ChromaLocation, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceExternalFormatResolvePropertiesANDROID<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + null_color_attachment_with_external_format_resolve: Bool32::default(), + external_format_resolve_chroma_offset_x: ChromaLocation::default(), + external_format_resolve_chroma_offset_y: ChromaLocation::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID; +} +unsafe impl ExtendsPhysicalDeviceProperties2 + for PhysicalDeviceExternalFormatResolvePropertiesANDROID<'_> +{ +} +impl<'a> PhysicalDeviceExternalFormatResolvePropertiesANDROID<'a> { + #[inline] + pub fn null_color_attachment_with_external_format_resolve( + mut self, + null_color_attachment_with_external_format_resolve: bool, + ) -> Self { + self.null_color_attachment_with_external_format_resolve = + null_color_attachment_with_external_format_resolve.into(); + self + } + #[inline] + pub fn external_format_resolve_chroma_offset_x( + mut self, + external_format_resolve_chroma_offset_x: ChromaLocation, + ) -> Self { + self.external_format_resolve_chroma_offset_x = external_format_resolve_chroma_offset_x; + self + } + #[inline] + pub fn external_format_resolve_chroma_offset_y( + mut self, + external_format_resolve_chroma_offset_y: ChromaLocation, + ) -> Self { + self.external_format_resolve_chroma_offset_y = external_format_resolve_chroma_offset_y; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub color_attachment_format: Format, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for AndroidHardwareBufferFormatResolvePropertiesANDROID<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + color_attachment_format: Format::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID; +} +unsafe impl ExtendsAndroidHardwareBufferPropertiesANDROID + for AndroidHardwareBufferFormatResolvePropertiesANDROID<'_> +{ +} +impl<'a> AndroidHardwareBufferFormatResolvePropertiesANDROID<'a> { + #[inline] + pub fn color_attachment_format(mut self, color_attachment_format: Format) -> Self { + self.color_attachment_format = color_attachment_format; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct LatencySleepModeInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub low_latency_mode: Bool32, + pub low_latency_boost: Bool32, + pub minimum_interval_us: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for LatencySleepModeInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + low_latency_mode: Bool32::default(), + low_latency_boost: Bool32::default(), + minimum_interval_us: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for LatencySleepModeInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_SLEEP_MODE_INFO_NV; +} +impl<'a> LatencySleepModeInfoNV<'a> { + #[inline] + pub fn low_latency_mode(mut self, low_latency_mode: bool) -> Self { + self.low_latency_mode = low_latency_mode.into(); + self + } + #[inline] + pub fn low_latency_boost(mut self, low_latency_boost: bool) -> Self { + self.low_latency_boost = low_latency_boost.into(); + self + } + #[inline] + pub fn minimum_interval_us(mut self, minimum_interval_us: u32) -> Self { + self.minimum_interval_us = minimum_interval_us; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct LatencySleepInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub signal_semaphore: Semaphore, + pub value: u64, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for LatencySleepInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + signal_semaphore: Semaphore::default(), + value: u64::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for LatencySleepInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_SLEEP_INFO_NV; +} +impl<'a> LatencySleepInfoNV<'a> { + #[inline] + pub fn signal_semaphore(mut self, signal_semaphore: Semaphore) -> Self { + self.signal_semaphore = signal_semaphore; + self + } + #[inline] + pub fn value(mut self, value: u64) -> Self { + self.value = value; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SetLatencyMarkerInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub present_id: u64, + pub marker: LatencyMarkerNV, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SetLatencyMarkerInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + present_id: u64::default(), + marker: LatencyMarkerNV::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SetLatencyMarkerInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SET_LATENCY_MARKER_INFO_NV; +} +impl<'a> SetLatencyMarkerInfoNV<'a> { + #[inline] + pub fn present_id(mut self, present_id: u64) -> Self { + self.present_id = present_id; + self + } + #[inline] + pub fn marker(mut self, marker: LatencyMarkerNV) -> Self { + self.marker = marker; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct GetLatencyMarkerInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub p_timings: *mut LatencyTimingsFrameReportNV<'a>, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for GetLatencyMarkerInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + p_timings: ::std::ptr::null_mut(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for GetLatencyMarkerInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::GET_LATENCY_MARKER_INFO_NV; +} +impl<'a> GetLatencyMarkerInfoNV<'a> { + #[inline] + pub fn timings(mut self, timings: &'a mut LatencyTimingsFrameReportNV<'a>) -> Self { + self.p_timings = timings; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct LatencyTimingsFrameReportNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub present_id: u64, + pub input_sample_time_us: u64, + pub sim_start_time_us: u64, + pub sim_end_time_us: u64, + pub render_submit_start_time_us: u64, + pub render_submit_end_time_us: u64, + pub present_start_time_us: u64, + pub present_end_time_us: u64, + pub driver_start_time_us: u64, + pub driver_end_time_us: u64, + pub os_render_queue_start_time_us: u64, + pub os_render_queue_end_time_us: u64, + pub gpu_render_start_time_us: u64, + pub gpu_render_end_time_us: u64, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for LatencyTimingsFrameReportNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + present_id: u64::default(), + input_sample_time_us: u64::default(), + sim_start_time_us: u64::default(), + sim_end_time_us: u64::default(), + render_submit_start_time_us: u64::default(), + render_submit_end_time_us: u64::default(), + present_start_time_us: u64::default(), + present_end_time_us: u64::default(), + driver_start_time_us: u64::default(), + driver_end_time_us: u64::default(), + os_render_queue_start_time_us: u64::default(), + os_render_queue_end_time_us: u64::default(), + gpu_render_start_time_us: u64::default(), + gpu_render_end_time_us: u64::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for LatencyTimingsFrameReportNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_TIMINGS_FRAME_REPORT_NV; +} +impl<'a> LatencyTimingsFrameReportNV<'a> { + #[inline] + pub fn present_id(mut self, present_id: u64) -> Self { + self.present_id = present_id; + self + } + #[inline] + pub fn input_sample_time_us(mut self, input_sample_time_us: u64) -> Self { + self.input_sample_time_us = input_sample_time_us; + self + } + #[inline] + pub fn sim_start_time_us(mut self, sim_start_time_us: u64) -> Self { + self.sim_start_time_us = sim_start_time_us; + self + } + #[inline] + pub fn sim_end_time_us(mut self, sim_end_time_us: u64) -> Self { + self.sim_end_time_us = sim_end_time_us; + self + } + #[inline] + pub fn render_submit_start_time_us(mut self, render_submit_start_time_us: u64) -> Self { + self.render_submit_start_time_us = render_submit_start_time_us; + self + } + #[inline] + pub fn render_submit_end_time_us(mut self, render_submit_end_time_us: u64) -> Self { + self.render_submit_end_time_us = render_submit_end_time_us; + self + } + #[inline] + pub fn present_start_time_us(mut self, present_start_time_us: u64) -> Self { + self.present_start_time_us = present_start_time_us; + self + } + #[inline] + pub fn present_end_time_us(mut self, present_end_time_us: u64) -> Self { + self.present_end_time_us = present_end_time_us; + self + } + #[inline] + pub fn driver_start_time_us(mut self, driver_start_time_us: u64) -> Self { + self.driver_start_time_us = driver_start_time_us; + self + } + #[inline] + pub fn driver_end_time_us(mut self, driver_end_time_us: u64) -> Self { + self.driver_end_time_us = driver_end_time_us; + self + } + #[inline] + pub fn os_render_queue_start_time_us(mut self, os_render_queue_start_time_us: u64) -> Self { + self.os_render_queue_start_time_us = os_render_queue_start_time_us; + self + } + #[inline] + pub fn os_render_queue_end_time_us(mut self, os_render_queue_end_time_us: u64) -> Self { + self.os_render_queue_end_time_us = os_render_queue_end_time_us; + self + } + #[inline] + pub fn gpu_render_start_time_us(mut self, gpu_render_start_time_us: u64) -> Self { + self.gpu_render_start_time_us = gpu_render_start_time_us; + self + } + #[inline] + pub fn gpu_render_end_time_us(mut self, gpu_render_end_time_us: u64) -> Self { + self.gpu_render_end_time_us = gpu_render_end_time_us; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct OutOfBandQueueTypeInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub queue_type: OutOfBandQueueTypeNV, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for OutOfBandQueueTypeInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + queue_type: OutOfBandQueueTypeNV::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for OutOfBandQueueTypeInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::OUT_OF_BAND_QUEUE_TYPE_INFO_NV; +} +impl<'a> OutOfBandQueueTypeInfoNV<'a> { + #[inline] + pub fn queue_type(mut self, queue_type: OutOfBandQueueTypeNV) -> Self { + self.queue_type = queue_type; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct LatencySubmissionPresentIdNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub present_id: u64, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for LatencySubmissionPresentIdNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + present_id: u64::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for LatencySubmissionPresentIdNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_SUBMISSION_PRESENT_ID_NV; +} +unsafe impl ExtendsSubmitInfo for LatencySubmissionPresentIdNV<'_> {} +unsafe impl ExtendsSubmitInfo2 for LatencySubmissionPresentIdNV<'_> {} +impl<'a> LatencySubmissionPresentIdNV<'a> { + #[inline] + pub fn present_id(mut self, present_id: u64) -> Self { + self.present_id = present_id; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct SwapchainLatencyCreateInfoNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub latency_mode_enable: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for SwapchainLatencyCreateInfoNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + latency_mode_enable: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for SwapchainLatencyCreateInfoNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::SWAPCHAIN_LATENCY_CREATE_INFO_NV; +} +unsafe impl ExtendsSwapchainCreateInfoKHR for SwapchainLatencyCreateInfoNV<'_> {} +impl<'a> SwapchainLatencyCreateInfoNV<'a> { + #[inline] + pub fn latency_mode_enable(mut self, latency_mode_enable: bool) -> Self { + self.latency_mode_enable = latency_mode_enable.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct LatencySurfaceCapabilitiesNV<'a> { + pub s_type: StructureType, + pub p_next: *const c_void, + pub present_mode_count: u32, + pub p_present_modes: *mut PresentModeKHR, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for LatencySurfaceCapabilitiesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null(), + present_mode_count: u32::default(), + p_present_modes: ::std::ptr::null_mut(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for LatencySurfaceCapabilitiesNV<'a> { + const STRUCTURE_TYPE: StructureType = StructureType::LATENCY_SURFACE_CAPABILITIES_NV; +} +unsafe impl ExtendsSurfaceCapabilities2KHR for LatencySurfaceCapabilitiesNV<'_> {} +impl<'a> LatencySurfaceCapabilitiesNV<'a> { + #[inline] + pub fn present_modes(mut self, present_modes: &'a mut [PresentModeKHR]) -> Self { + self.present_mode_count = present_modes.len() as _; + self.p_present_modes = present_modes.as_mut_ptr(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub cuda_kernel_launch_features: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceCudaKernelLaunchFeaturesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + cuda_kernel_launch_features: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceCudaKernelLaunchFeaturesNV<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceCudaKernelLaunchFeaturesNV<'_> {} +impl<'a> PhysicalDeviceCudaKernelLaunchFeaturesNV<'a> { + #[inline] + pub fn cuda_kernel_launch_features(mut self, cuda_kernel_launch_features: bool) -> Self { + self.cuda_kernel_launch_features = cuda_kernel_launch_features.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceCudaKernelLaunchPropertiesNV<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub compute_capability_minor: u32, + pub compute_capability_major: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceCudaKernelLaunchPropertiesNV<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + compute_capability_minor: u32::default(), + compute_capability_major: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceCudaKernelLaunchPropertiesNV<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceCudaKernelLaunchPropertiesNV<'_> {} +impl<'a> PhysicalDeviceCudaKernelLaunchPropertiesNV<'a> { + #[inline] + pub fn compute_capability_minor(mut self, compute_capability_minor: u32) -> Self { + self.compute_capability_minor = compute_capability_minor; + self + } + #[inline] + pub fn compute_capability_major(mut self, compute_capability_major: u32) -> Self { + self.compute_capability_major = compute_capability_major; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct DeviceQueueShaderCoreControlCreateInfoARM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub shader_core_count: u32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for DeviceQueueShaderCoreControlCreateInfoARM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + shader_core_count: u32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for DeviceQueueShaderCoreControlCreateInfoARM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; +} +unsafe impl ExtendsDeviceQueueCreateInfo for DeviceQueueShaderCoreControlCreateInfoARM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for DeviceQueueShaderCoreControlCreateInfoARM<'_> {} +impl<'a> DeviceQueueShaderCoreControlCreateInfoARM<'a> { + #[inline] + pub fn shader_core_count(mut self, shader_core_count: u32) -> Self { + self.shader_core_count = shader_core_count; + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSchedulingControlsFeaturesARM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub scheduling_controls: Bool32, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceSchedulingControlsFeaturesARM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + scheduling_controls: Bool32::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceSchedulingControlsFeaturesARM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; +} +unsafe impl ExtendsPhysicalDeviceFeatures2 for PhysicalDeviceSchedulingControlsFeaturesARM<'_> {} +unsafe impl ExtendsDeviceCreateInfo for PhysicalDeviceSchedulingControlsFeaturesARM<'_> {} +impl<'a> PhysicalDeviceSchedulingControlsFeaturesARM<'a> { + #[inline] + pub fn scheduling_controls(mut self, scheduling_controls: bool) -> Self { + self.scheduling_controls = scheduling_controls.into(); + self + } +} +#[repr(C)] +#[cfg_attr(feature = "debug", derive(Debug))] +#[derive(Copy, Clone)] +#[doc = ""] +pub struct PhysicalDeviceSchedulingControlsPropertiesARM<'a> { + pub s_type: StructureType, + pub p_next: *mut c_void, + pub scheduling_controls_flags: PhysicalDeviceSchedulingControlsFlagsARM, + pub _marker: PhantomData<&'a ()>, +} +impl ::std::default::Default for PhysicalDeviceSchedulingControlsPropertiesARM<'_> { + #[inline] + fn default() -> Self { + Self { + s_type: Self::STRUCTURE_TYPE, + p_next: ::std::ptr::null_mut(), + scheduling_controls_flags: PhysicalDeviceSchedulingControlsFlagsARM::default(), + _marker: PhantomData, + } + } +} +unsafe impl<'a> TaggedStructure for PhysicalDeviceSchedulingControlsPropertiesARM<'a> { + const STRUCTURE_TYPE: StructureType = + StructureType::PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; +} +unsafe impl ExtendsPhysicalDeviceProperties2 for PhysicalDeviceSchedulingControlsPropertiesARM<'_> {} +impl<'a> PhysicalDeviceSchedulingControlsPropertiesARM<'a> { + #[inline] + pub fn scheduling_controls_flags( + mut self, + scheduling_controls_flags: PhysicalDeviceSchedulingControlsFlagsARM, + ) -> Self { + self.scheduling_controls_flags = scheduling_controls_flags; + self + } +} diff --git a/ash/src/vk/enums.rs b/ash/src/vk/enums.rs index 55f9994..a41d1ab 100644 --- a/ash/src/vk/enums.rs +++ b/ash/src/vk/enums.rs @@ -1812,6 +1812,8 @@ impl DriverId { pub const MESA_NVK: Self = Self(24); #[doc = "Imagination Technologies"] pub const IMAGINATION_OPEN_SOURCE_MESA: Self = Self(25); + #[doc = "Mesa open source project"] + pub const MESA_AGXV: Self = Self(26); } #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] #[repr(transparent)] @@ -2802,6 +2804,108 @@ impl ComponentTypeKHR { pub const UINT32: Self = Self(9); pub const UINT64: Self = Self(10); } +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct CubicFilterWeightsQCOM(pub(crate) i32); +impl CubicFilterWeightsQCOM { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl CubicFilterWeightsQCOM { + pub const CATMULL_ROM: Self = Self(0); + pub const ZERO_TANGENT_CARDINAL: Self = Self(1); + pub const B_SPLINE: Self = Self(2); + pub const MITCHELL_NETRAVALI: Self = Self(3); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct BlockMatchWindowCompareModeQCOM(pub(crate) i32); +impl BlockMatchWindowCompareModeQCOM { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl BlockMatchWindowCompareModeQCOM { + pub const MIN: Self = Self(0); + pub const MAX: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct LayeredDriverUnderlyingApiMSFT(pub(crate) i32); +impl LayeredDriverUnderlyingApiMSFT { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl LayeredDriverUnderlyingApiMSFT { + pub const NONE: Self = Self(0); + pub const D3D12: Self = Self(1); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct LatencyMarkerNV(pub(crate) i32); +impl LatencyMarkerNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl LatencyMarkerNV { + pub const SIMULATION_START: Self = Self(0); + pub const SIMULATION_END: Self = Self(1); + pub const RENDERSUBMIT_START: Self = Self(2); + pub const RENDERSUBMIT_END: Self = Self(3); + pub const PRESENT_START: Self = Self(4); + pub const PRESENT_END: Self = Self(5); + pub const INPUT_SAMPLE: Self = Self(6); + pub const TRIGGER_FLASH: Self = Self(7); + pub const OUT_OF_BAND_RENDERSUBMIT_START: Self = Self(8); + pub const OUT_OF_BAND_RENDERSUBMIT_END: Self = Self(9); + pub const OUT_OF_BAND_PRESENT_START: Self = Self(10); + pub const OUT_OF_BAND_PRESENT_END: Self = Self(11); +} +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] +#[repr(transparent)] +#[doc = ""] +pub struct OutOfBandQueueTypeNV(pub(crate) i32); +impl OutOfBandQueueTypeNV { + #[inline] + pub const fn from_raw(x: i32) -> Self { + Self(x) + } + #[inline] + pub const fn as_raw(self) -> i32 { + self.0 + } +} +impl OutOfBandQueueTypeNV { + pub const RENDER: Self = Self(0); + pub const PRESENT: Self = Self(1); +} impl fmt::Debug for ObjectType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let name = match *self { @@ -2847,6 +2951,8 @@ impl fmt::Debug for ObjectType { Self::PERFORMANCE_CONFIGURATION_INTEL => Some("PERFORMANCE_CONFIGURATION_INTEL"), Self::DEFERRED_OPERATION_KHR => Some("DEFERRED_OPERATION_KHR"), Self::INDIRECT_COMMANDS_LAYOUT_NV => Some("INDIRECT_COMMANDS_LAYOUT_NV"), + Self::CUDA_MODULE_NV => Some("CUDA_MODULE_NV"), + Self::CUDA_FUNCTION_NV => Some("CUDA_FUNCTION_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"), diff --git a/ash/src/vk/extensions.rs b/ash/src/vk/extensions.rs index 53571df..a1396ee 100644 --- a/ash/src/vk/extensions.rs +++ b/ash/src/vk/extensions.rs @@ -2752,7 +2752,7 @@ pub struct AmdShaderBallotFn; impl ExtVideoEncodeH264Fn { pub const 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 = 11u32; + pub const SPEC_VERSION: u32 = 12u32; } #[derive(Clone)] pub struct ExtVideoEncodeH264Fn; @@ -2780,7 +2780,7 @@ impl VideoCodecOperationFlagsKHR { impl ExtVideoEncodeH265Fn { pub const 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 = 11u32; + pub const SPEC_VERSION: u32 = 12u32; } #[derive(Clone)] pub struct ExtVideoEncodeH265Fn; @@ -14036,7 +14036,7 @@ impl StructureType { impl KhrVideoEncodeQueueFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_encode_queue\0") }; - pub const SPEC_VERSION: u32 = 9u32; + pub const SPEC_VERSION: u32 = 10u32; } #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = @@ -14174,6 +14174,10 @@ impl PipelineStageFlags2 { pub const VIDEO_ENCODE_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_KHR_video_encode_queue'"] +impl QueryResultStatusKHR { + pub const INSUFFICIENTSTREAM_BUFFER_RANGE: Self = Self(-1_000_299_000); +} +#[doc = "Generated from 'VK_KHR_video_encode_queue'"] impl QueryType { pub const VIDEO_ENCODE_FEEDBACK_KHR: Self = Self(1_000_299_000); } @@ -14233,6 +14237,209 @@ pub struct QcomRenderPassStoreOpsFn; impl AttachmentStoreOp { pub const NONE_QCOM: Self = Self::NONE; } +impl NvCudaKernelLaunchFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_cuda_kernel_launch\0") }; + pub const SPEC_VERSION: u32 = 2u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCudaModuleNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const CudaModuleCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_module: *mut CudaModuleNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkGetCudaModuleCacheNV = unsafe extern "system" fn( + device: Device, + module: CudaModuleNV, + p_cache_size: *mut usize, + p_cache_data: *mut c_void, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkCreateCudaFunctionNV = unsafe extern "system" fn( + device: Device, + p_create_info: *const CudaFunctionCreateInfoNV, + p_allocator: *const AllocationCallbacks, + p_function: *mut CudaFunctionNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCudaModuleNV = unsafe extern "system" fn( + device: Device, + module: CudaModuleNV, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkDestroyCudaFunctionNV = unsafe extern "system" fn( + device: Device, + function: CudaFunctionNV, + p_allocator: *const AllocationCallbacks, +); +#[allow(non_camel_case_types)] +pub type PFN_vkCmdCudaLaunchKernelNV = unsafe extern "system" fn( + command_buffer: CommandBuffer, + p_launch_info: *const CudaLaunchInfoNV, +); +#[derive(Clone)] +pub struct NvCudaKernelLaunchFn { + pub create_cuda_module_nv: PFN_vkCreateCudaModuleNV, + pub get_cuda_module_cache_nv: PFN_vkGetCudaModuleCacheNV, + pub create_cuda_function_nv: PFN_vkCreateCudaFunctionNV, + pub destroy_cuda_module_nv: PFN_vkDestroyCudaModuleNV, + pub destroy_cuda_function_nv: PFN_vkDestroyCudaFunctionNV, + pub cmd_cuda_launch_kernel_nv: PFN_vkCmdCudaLaunchKernelNV, +} +unsafe impl Send for NvCudaKernelLaunchFn {} +unsafe impl Sync for NvCudaKernelLaunchFn {} +impl NvCudaKernelLaunchFn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + create_cuda_module_nv: unsafe { + unsafe extern "system" fn create_cuda_module_nv( + _device: Device, + _p_create_info: *const CudaModuleCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_module: *mut CudaModuleNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_cuda_module_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCudaModuleNV\0"); + let val = _f(cname); + if val.is_null() { + create_cuda_module_nv + } else { + ::std::mem::transmute(val) + } + }, + get_cuda_module_cache_nv: unsafe { + unsafe extern "system" fn get_cuda_module_cache_nv( + _device: Device, + _module: CudaModuleNV, + _p_cache_size: *mut usize, + _p_cache_data: *mut c_void, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(get_cuda_module_cache_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetCudaModuleCacheNV\0"); + let val = _f(cname); + if val.is_null() { + get_cuda_module_cache_nv + } else { + ::std::mem::transmute(val) + } + }, + create_cuda_function_nv: unsafe { + unsafe extern "system" fn create_cuda_function_nv( + _device: Device, + _p_create_info: *const CudaFunctionCreateInfoNV, + _p_allocator: *const AllocationCallbacks, + _p_function: *mut CudaFunctionNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(create_cuda_function_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCudaFunctionNV\0"); + let val = _f(cname); + if val.is_null() { + create_cuda_function_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_cuda_module_nv: unsafe { + unsafe extern "system" fn destroy_cuda_module_nv( + _device: Device, + _module: CudaModuleNV, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_cuda_module_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCudaModuleNV\0"); + let val = _f(cname); + if val.is_null() { + destroy_cuda_module_nv + } else { + ::std::mem::transmute(val) + } + }, + destroy_cuda_function_nv: unsafe { + unsafe extern "system" fn destroy_cuda_function_nv( + _device: Device, + _function: CudaFunctionNV, + _p_allocator: *const AllocationCallbacks, + ) { + panic!(concat!( + "Unable to load ", + stringify!(destroy_cuda_function_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCudaFunctionNV\0"); + let val = _f(cname); + if val.is_null() { + destroy_cuda_function_nv + } else { + ::std::mem::transmute(val) + } + }, + cmd_cuda_launch_kernel_nv: unsafe { + unsafe extern "system" fn cmd_cuda_launch_kernel_nv( + _command_buffer: CommandBuffer, + _p_launch_info: *const CudaLaunchInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(cmd_cuda_launch_kernel_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCudaLaunchKernelNV\0"); + let val = _f(cname); + if val.is_null() { + cmd_cuda_launch_kernel_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_cuda_kernel_launch'"] +impl DebugReportObjectTypeEXT { + pub const CUDA_MODULE_NV: Self = Self(1_000_307_000); + pub const CUDA_FUNCTION_NV: Self = Self(1_000_307_001); +} +#[doc = "Generated from 'VK_NV_cuda_kernel_launch'"] +impl ObjectType { + pub const CUDA_MODULE_NV: Self = Self(1_000_307_000); + pub const CUDA_FUNCTION_NV: Self = Self(1_000_307_001); +} +#[doc = "Generated from 'VK_NV_cuda_kernel_launch'"] +impl StructureType { + pub const CUDA_MODULE_CREATE_INFO_NV: Self = Self(1_000_307_000); + pub const CUDA_FUNCTION_CREATE_INFO_NV: Self = Self(1_000_307_001); + pub const CUDA_LAUNCH_INFO_NV: Self = Self(1_000_307_002); + pub const PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: Self = Self(1_000_307_003); + pub const PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: Self = Self(1_000_307_004); +} impl NvLowLatencyFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_low_latency\0") }; @@ -16696,6 +16903,18 @@ impl StructureType { pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: Self = Self(1_000_372_001); pub const PIPELINE_INFO_EXT: Self = Self::PIPELINE_INFO_KHR; } +impl ExtFrameBoundaryFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_frame_boundary\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtFrameBoundaryFn; +#[doc = "Generated from 'VK_EXT_frame_boundary'"] +impl StructureType { + pub const PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: Self = Self(1_000_375_000); + pub const FRAME_BOUNDARY_EXT: Self = Self(1_000_375_001); +} impl ExtMultisampledRenderToSingleSampledFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked( @@ -17718,10 +17937,6 @@ impl PipelineCreateFlags { Self(0b1_0000_0000_0000_0000_0000_0000_0000); } #[doc = "Generated from 'VK_NV_displacement_micromap'"] -impl PipelineCreateFlags2KHR { - pub const RESERVED_28_NV: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000); -} -#[doc = "Generated from 'VK_NV_displacement_micromap'"] impl StructureType { pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: Self = Self(1_000_397_000); pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: Self = Self(1_000_397_001); @@ -18027,6 +18242,19 @@ pub struct ArmShaderCorePropertiesFn; impl StructureType { pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: Self = Self(1_000_415_000); } +impl ArmSchedulingControlsFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_scheduling_controls\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ArmSchedulingControlsFn; +#[doc = "Generated from 'VK_ARM_scheduling_controls'"] +impl StructureType { + pub const DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: Self = Self(1_000_417_000); + pub const PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: Self = Self(1_000_417_001); + pub const PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: Self = Self(1_000_417_002); +} impl ExtImageSlicedViewOf3dFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_sliced_view_of_3d\0") @@ -18538,6 +18766,27 @@ impl StructureType { pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: Self = Self(1_000_440_001); pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: Self = Self(1_000_440_002); } +impl ExtNestedCommandBufferFn { + pub const NAME: &'static ::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_nested_command_buffer\0") + }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct ExtNestedCommandBufferFn; +#[doc = "Generated from 'VK_EXT_nested_command_buffer'"] +impl RenderingFlags { + pub const CONTENTS_INLINE_EXT: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_EXT_nested_command_buffer'"] +impl StructureType { + pub const PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: Self = Self(1_000_451_000); + pub const PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: Self = Self(1_000_451_001); +} +#[doc = "Generated from 'VK_EXT_nested_command_buffer'"] +impl SubpassContents { + pub const INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT: Self = Self(1_000_451_000); +} impl ExtExternalMemoryAcquireUnmodifiedFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked( @@ -19796,6 +20045,25 @@ impl PipelineCreateFlags { impl StructureType { pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: Self = Self(1_000_466_000); } +impl AndroidExternalFormatResolveFn { + pub const NAME: &'static ::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_external_format_resolve\0") + }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct AndroidExternalFormatResolveFn; +#[doc = "Generated from 'VK_ANDROID_external_format_resolve'"] +impl ResolveModeFlags { + pub const EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_ANDROID_external_format_resolve'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: Self = Self(1_000_468_000); + pub const PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: Self = + Self(1_000_468_001); + pub const ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: Self = Self(1_000_468_002); +} impl KhrMaintenance5Fn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance5\0") }; @@ -19927,11 +20195,11 @@ impl KhrMaintenance5Fn { } #[doc = "Generated from 'VK_KHR_maintenance5'"] impl BufferUsageFlags2KHR { - pub const CONDITIONAL_RENDERING: Self = Self(0b10_0000_0000); + pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b10_0000_0000); pub const SHADER_BINDING_TABLE: Self = Self(0b100_0000_0000); - pub const RAY_TRACING: Self = Self::SHADER_BINDING_TABLE; - pub const TRANSFORM_FEEDBACK_BUFFER: Self = Self(0b1000_0000_0000); - pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER: Self = Self(0b1_0000_0000_0000); + pub const RAY_TRACING_NV: Self = Self::SHADER_BINDING_TABLE; + pub const TRANSFORM_FEEDBACK_BUFFER_EXT: Self = Self(0b1000_0000_0000); + pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT: Self = Self(0b1_0000_0000_0000); pub const VIDEO_DECODE_SRC: Self = Self(0b10_0000_0000_0000); pub const VIDEO_DECODE_DST: Self = Self(0b100_0000_0000_0000); pub const VIDEO_ENCODE_DST: Self = Self(0b1000_0000_0000_0000); @@ -19939,11 +20207,12 @@ impl BufferUsageFlags2KHR { pub const SHADER_DEVICE_ADDRESS: Self = Self(0b10_0000_0000_0000_0000); pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY: Self = Self(0b1000_0000_0000_0000_0000); pub const ACCELERATION_STRUCTURE_STORAGE: Self = Self(0b1_0000_0000_0000_0000_0000); - pub const SAMPLER_DESCRIPTOR_BUFFER: Self = Self(0b10_0000_0000_0000_0000_0000); - pub const RESOURCE_DESCRIPTOR_BUFFER: Self = Self(0b100_0000_0000_0000_0000_0000); - pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER: Self = Self(0b100_0000_0000_0000_0000_0000_0000); - pub const MICROMAP_BUILD_INPUT_READ_ONLY: Self = Self(0b1000_0000_0000_0000_0000_0000); - pub const MICROMAP_STORAGE: Self = Self(0b1_0000_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); + 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_KHR_maintenance5'"] impl Format { @@ -19954,13 +20223,13 @@ impl Format { impl PipelineCreateFlags2KHR { pub const VIEW_INDEX_FROM_DEVICE_INDEX: Self = Self(0b1000); pub const DISPATCH_BASE: Self = Self(0b1_0000); - pub const DEFER_COMPILE: Self = Self(0b10_0000); + pub const DEFER_COMPILE_NV: Self = Self(0b10_0000); pub const CAPTURE_STATISTICS: Self = Self(0b100_0000); pub const CAPTURE_INTERNAL_REPRESENTATIONS: Self = Self(0b1000_0000); pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED: Self = Self(0b1_0000_0000); pub const EARLY_RETURN_ON_FAILURE: Self = Self(0b10_0000_0000); - pub const LINK_TIME_OPTIMIZATION: Self = Self(0b100_0000_0000); - pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO: Self = Self(0b1000_0000_0000_0000_0000_0000); + pub const LINK_TIME_OPTIMIZATION_EXT: Self = Self(0b100_0000_0000); + pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000); pub const LIBRARY: Self = Self(0b1000_0000_0000); pub const RAY_TRACING_SKIP_TRIANGLES: Self = Self(0b1_0000_0000_0000); pub const RAY_TRACING_SKIP_AABBS: Self = Self(0b10_0000_0000_0000); @@ -19970,19 +20239,21 @@ impl PipelineCreateFlags2KHR { pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS: Self = Self(0b10_0000_0000_0000_0000); pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY: Self = Self(0b1000_0000_0000_0000_0000); - pub const INDIRECT_BINDABLE: Self = Self(0b100_0000_0000_0000_0000); - pub const RAY_TRACING_ALLOW_MOTION: Self = Self(0b1_0000_0000_0000_0000_0000); + pub const INDIRECT_BINDABLE_NV: Self = Self(0b100_0000_0000_0000_0000); + pub const RAY_TRACING_ALLOW_MOTION_NV: Self = Self(0b1_0000_0000_0000_0000_0000); pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(0b10_0000_0000_0000_0000_0000); - pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = + pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self = Self(0b100_0000_0000_0000_0000_0000); - pub const RAY_TRACING_OPACITY_MICROMAP: Self = Self(0b1_0000_0000_0000_0000_0000_0000); - pub const COLOR_ATTACHMENT_FEEDBACK_LOOP: Self = Self(0b10_0000_0000_0000_0000_0000_0000); - pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP: Self = + pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000); + pub const COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000); + pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000); - pub const NO_PROTECTED_ACCESS: Self = Self(0b1000_0000_0000_0000_0000_0000_0000); - pub const PROTECTED_ACCESS_ONLY: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000); - pub const DESCRIPTOR_BUFFER: Self = Self(0b10_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); + pub const RAY_TRACING_DISPLACEMENT_MICROMAP_NV: Self = + Self(0b1_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_KHR_maintenance5'"] impl StructureType { @@ -21330,6 +21601,20 @@ impl StructureType { pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: Self = Self(1_000_490_001); } +impl NvExtendedSparseAddressSpaceFn { + pub const NAME: &'static ::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extended_sparse_address_space\0") + }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvExtendedSparseAddressSpaceFn; +#[doc = "Generated from 'VK_NV_extended_sparse_address_space'"] +impl StructureType { + pub const PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: Self = Self(1_000_492_000); + pub const PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: Self = + Self(1_000_492_001); +} impl ExtMutableDescriptorTypeFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_mutable_descriptor_type\0") @@ -21396,6 +21681,166 @@ impl StructureType { pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: Self = Self(1_000_499_000); } +impl NvLowLatency2Fn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_low_latency2\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[allow(non_camel_case_types)] +pub type PFN_vkSetLatencySleepModeNV = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_sleep_mode_info: *const LatencySleepModeInfoNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkLatencySleepNV = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_sleep_info: *const LatencySleepInfoNV, +) -> Result; +#[allow(non_camel_case_types)] +pub type PFN_vkSetLatencyMarkerNV = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_latency_marker_info: *const SetLatencyMarkerInfoNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkGetLatencyTimingsNV = unsafe extern "system" fn( + device: Device, + swapchain: SwapchainKHR, + p_timing_count: *mut u32, + p_latency_marker_info: *mut GetLatencyMarkerInfoNV, +); +#[allow(non_camel_case_types)] +pub type PFN_vkQueueNotifyOutOfBandNV = + unsafe extern "system" fn(queue: Queue, p_queue_type_info: *const OutOfBandQueueTypeInfoNV); +#[derive(Clone)] +pub struct NvLowLatency2Fn { + pub set_latency_sleep_mode_nv: PFN_vkSetLatencySleepModeNV, + pub latency_sleep_nv: PFN_vkLatencySleepNV, + pub set_latency_marker_nv: PFN_vkSetLatencyMarkerNV, + pub get_latency_timings_nv: PFN_vkGetLatencyTimingsNV, + pub queue_notify_out_of_band_nv: PFN_vkQueueNotifyOutOfBandNV, +} +unsafe impl Send for NvLowLatency2Fn {} +unsafe impl Sync for NvLowLatency2Fn {} +impl NvLowLatency2Fn { + pub fn load(mut _f: F) -> Self + where + F: FnMut(&::std::ffi::CStr) -> *const c_void, + { + Self { + set_latency_sleep_mode_nv: unsafe { + unsafe extern "system" fn set_latency_sleep_mode_nv( + _device: Device, + _swapchain: SwapchainKHR, + _p_sleep_mode_info: *const LatencySleepModeInfoNV, + ) -> Result { + panic!(concat!( + "Unable to load ", + stringify!(set_latency_sleep_mode_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetLatencySleepModeNV\0"); + let val = _f(cname); + if val.is_null() { + set_latency_sleep_mode_nv + } else { + ::std::mem::transmute(val) + } + }, + latency_sleep_nv: unsafe { + unsafe extern "system" fn latency_sleep_nv( + _device: Device, + _swapchain: SwapchainKHR, + _p_sleep_info: *const LatencySleepInfoNV, + ) -> Result { + panic!(concat!("Unable to load ", stringify!(latency_sleep_nv))) + } + let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkLatencySleepNV\0"); + let val = _f(cname); + if val.is_null() { + latency_sleep_nv + } else { + ::std::mem::transmute(val) + } + }, + set_latency_marker_nv: unsafe { + unsafe extern "system" fn set_latency_marker_nv( + _device: Device, + _swapchain: SwapchainKHR, + _p_latency_marker_info: *const SetLatencyMarkerInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(set_latency_marker_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetLatencyMarkerNV\0"); + let val = _f(cname); + if val.is_null() { + set_latency_marker_nv + } else { + ::std::mem::transmute(val) + } + }, + get_latency_timings_nv: unsafe { + unsafe extern "system" fn get_latency_timings_nv( + _device: Device, + _swapchain: SwapchainKHR, + _p_timing_count: *mut u32, + _p_latency_marker_info: *mut GetLatencyMarkerInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(get_latency_timings_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetLatencyTimingsNV\0"); + let val = _f(cname); + if val.is_null() { + get_latency_timings_nv + } else { + ::std::mem::transmute(val) + } + }, + queue_notify_out_of_band_nv: unsafe { + unsafe extern "system" fn queue_notify_out_of_band_nv( + _queue: Queue, + _p_queue_type_info: *const OutOfBandQueueTypeInfoNV, + ) { + panic!(concat!( + "Unable to load ", + stringify!(queue_notify_out_of_band_nv) + )) + } + let cname = + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueNotifyOutOfBandNV\0"); + let val = _f(cname); + if val.is_null() { + queue_notify_out_of_band_nv + } else { + ::std::mem::transmute(val) + } + }, + } + } +} +#[doc = "Generated from 'VK_NV_low_latency2'"] +impl StructureType { + pub const LATENCY_SLEEP_MODE_INFO_NV: Self = Self(1_000_505_000); + pub const LATENCY_SLEEP_INFO_NV: Self = Self(1_000_505_001); + pub const SET_LATENCY_MARKER_INFO_NV: Self = Self(1_000_505_002); + pub const GET_LATENCY_MARKER_INFO_NV: Self = Self(1_000_505_003); + pub const LATENCY_TIMINGS_FRAME_REPORT_NV: Self = Self(1_000_505_004); + pub const LATENCY_SUBMISSION_PRESENT_ID_NV: Self = Self(1_000_505_005); + pub const OUT_OF_BAND_QUEUE_TYPE_INFO_NV: Self = Self(1_000_505_006); + pub const SWAPCHAIN_LATENCY_CREATE_INFO_NV: Self = Self(1_000_505_007); + pub const LATENCY_SURFACE_CAPABILITIES_NV: Self = Self(1_000_505_008); +} impl KhrCooperativeMatrixFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_cooperative_matrix\0") }; @@ -21468,6 +21913,60 @@ impl StructureType { pub const MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: Self = Self(1_000_510_001); } +impl QcomImageProcessing2Fn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_image_processing2\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomImageProcessing2Fn; +#[doc = "Generated from 'VK_QCOM_image_processing2'"] +impl StructureType { + pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: Self = Self(1_000_518_000); + pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: Self = Self(1_000_518_001); + pub const SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: Self = Self(1_000_518_002); +} +impl QcomFilterCubicWeightsFn { + pub const NAME: &'static ::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_filter_cubic_weights\0") + }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomFilterCubicWeightsFn; +#[doc = "Generated from 'VK_QCOM_filter_cubic_weights'"] +impl StructureType { + pub const SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: Self = Self(1_000_519_000); + pub const PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: Self = Self(1_000_519_001); + pub const BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: Self = Self(1_000_519_002); +} +impl QcomYcbcrDegammaFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_ycbcr_degamma\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomYcbcrDegammaFn; +#[doc = "Generated from 'VK_QCOM_ycbcr_degamma'"] +impl StructureType { + pub const PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: Self = Self(1_000_520_000); + pub const SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: Self = Self(1_000_520_001); +} +impl QcomFilterCubicClampFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_filter_cubic_clamp\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct QcomFilterCubicClampFn; +#[doc = "Generated from 'VK_QCOM_filter_cubic_clamp'"] +impl SamplerReductionMode { + pub const WEIGHTED_AVERAGE_RANGECLAMP_QCOM: Self = Self(1_000_521_000); +} +#[doc = "Generated from 'VK_QCOM_filter_cubic_clamp'"] +impl StructureType { + pub const PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: Self = Self(1_000_521_000); +} impl ExtAttachmentFeedbackLoopDynamicStateFn { pub const NAME: &'static ::std::ffi::CStr = unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked( @@ -21584,3 +22083,32 @@ impl StructureType { pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: Self = Self(1_000_529_004); } +impl MsftLayeredDriverFn { + pub const NAME: &'static ::std::ffi::CStr = + unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MSFT_layered_driver\0") }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct MsftLayeredDriverFn; +#[doc = "Generated from 'VK_MSFT_layered_driver'"] +impl StructureType { + pub const PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: Self = Self(1_000_530_000); +} +impl NvDescriptorPoolOverallocationFn { + pub const NAME: &'static ::std::ffi::CStr = unsafe { + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_descriptor_pool_overallocation\0") + }; + pub const SPEC_VERSION: u32 = 1u32; +} +#[derive(Clone)] +pub struct NvDescriptorPoolOverallocationFn; +#[doc = "Generated from 'VK_NV_descriptor_pool_overallocation'"] +impl DescriptorPoolCreateFlags { + pub const ALLOW_OVERALLOCATION_SETS_NV: Self = Self(0b1000); + pub const ALLOW_OVERALLOCATION_POOLS_NV: Self = Self(0b1_0000); +} +#[doc = "Generated from 'VK_NV_descriptor_pool_overallocation'"] +impl StructureType { + pub const PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: Self = + Self(1_000_546_000); +} diff --git a/ash/src/vk/native.rs b/ash/src/vk/native.rs index 8592377..ac304d0 100644 --- a/ash/src/vk/native.rs +++ b/ash/src/vk/native.rs @@ -7220,7 +7220,7 @@ fn bindgen_test_layout_StdVideoEncodeH264RefListModEntry() { #[repr(C)] #[derive(Debug, Copy, Clone)] pub struct StdVideoEncodeH264RefPicMarkingEntry { - pub operation: StdVideoH264MemMgmtControlOp, + pub memory_management_control_operation: StdVideoH264MemMgmtControlOp, pub difference_of_pic_nums_minus1: u16, pub long_term_pic_num: u16, pub long_term_frame_idx: u16, @@ -7248,13 +7248,15 @@ fn bindgen_test_layout_StdVideoEncodeH264RefPicMarkingEntry() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).operation) as usize - ptr as usize }, + unsafe { + ::std::ptr::addr_of!((*ptr).memory_management_control_operation) as usize - ptr as usize + }, 0usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264RefPicMarkingEntry), "::", - stringify!(operation) + stringify!(memory_management_control_operation) ) ); assert_eq!( @@ -7699,7 +7701,8 @@ pub struct StdVideoEncodeH264SliceHeader { pub slice_type: StdVideoH264SliceType, pub slice_alpha_c0_offset_div2: i8, pub slice_beta_offset_div2: i8, - pub reserved1: u16, + pub slice_qp_delta: i8, + pub reserved1: u8, pub cabac_init_idc: StdVideoH264CabacInitIdc, pub disable_deblocking_filter_idc: StdVideoH264DisableDeblockingFilterIdc, pub pWeightTable: *const StdVideoEncodeH264WeightTable, @@ -7770,8 +7773,18 @@ fn bindgen_test_layout_StdVideoEncodeH264SliceHeader() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).slice_qp_delta) as usize - ptr as usize }, 14usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH264SliceHeader), + "::", + stringify!(slice_qp_delta) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 15usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH264SliceHeader), @@ -8288,7 +8301,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 reserved1: [u8; 3usize], + pub slice_qp_delta: i8, + pub reserved1: u16, pub pWeightTable: *const StdVideoEncodeH265WeightTable, } #[test] @@ -8433,8 +8447,18 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentHeader() { ) ); assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + unsafe { ::std::ptr::addr_of!((*ptr).slice_qp_delta) as usize - ptr as usize }, 21usize, + concat!( + "Offset of field: ", + stringify!(StdVideoEncodeH265SliceSegmentHeader), + "::", + stringify!(slice_qp_delta) + ) + ); + assert_eq!( + unsafe { ::std::ptr::addr_of!((*ptr).reserved1) as usize - ptr as usize }, + 22usize, concat!( "Offset of field: ", stringify!(StdVideoEncodeH265SliceSegmentHeader), @@ -8841,7 +8865,7 @@ impl StdVideoEncodeH265PictureInfoFlags { } #[repr(C)] #[derive(Debug, Copy, Clone)] -pub struct StdVideoEncodeH265SliceSegmentLongTermRefPics { +pub struct StdVideoEncodeH265LongTermRefPics { pub num_long_term_sps: u8, pub num_long_term_pics: u8, pub lt_idx_sps: [u8; 32usize], @@ -8851,24 +8875,21 @@ pub struct StdVideoEncodeH265SliceSegmentLongTermRefPics { pub delta_poc_msb_cycle_lt: [u8; 48usize], } #[test] -fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { - const UNINIT: ::std::mem::MaybeUninit = +fn bindgen_test_layout_StdVideoEncodeH265LongTermRefPics() { + const UNINIT: ::std::mem::MaybeUninit = ::std::mem::MaybeUninit::uninit(); let ptr = UNINIT.as_ptr(); assert_eq!( - ::std::mem::size_of::(), + ::std::mem::size_of::(), 148usize, - concat!( - "Size of: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) - ) + concat!("Size of: ", stringify!(StdVideoEncodeH265LongTermRefPics)) ); assert_eq!( - ::std::mem::align_of::(), + ::std::mem::align_of::(), 2usize, concat!( "Alignment of ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics) + stringify!(StdVideoEncodeH265LongTermRefPics) ) ); assert_eq!( @@ -8876,7 +8897,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { 0usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265LongTermRefPics), "::", stringify!(num_long_term_sps) ) @@ -8886,7 +8907,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { 1usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265LongTermRefPics), "::", stringify!(num_long_term_pics) ) @@ -8896,7 +8917,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { 2usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265LongTermRefPics), "::", stringify!(lt_idx_sps) ) @@ -8906,7 +8927,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { 34usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265LongTermRefPics), "::", stringify!(poc_lsb_lt) ) @@ -8916,7 +8937,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { 50usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265LongTermRefPics), "::", stringify!(used_by_curr_pic_lt_flag) ) @@ -8926,7 +8947,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { 52usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265LongTermRefPics), "::", stringify!(delta_poc_msb_present_flag) ) @@ -8936,7 +8957,7 @@ fn bindgen_test_layout_StdVideoEncodeH265SliceSegmentLongTermRefPics() { 100usize, concat!( "Offset of field: ", - stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics), + stringify!(StdVideoEncodeH265LongTermRefPics), "::", stringify!(delta_poc_msb_cycle_lt) ) @@ -8956,7 +8977,7 @@ pub struct StdVideoEncodeH265PictureInfo { pub reserved1: [u8; 7usize], pub pRefLists: *const StdVideoEncodeH265ReferenceListsInfo, pub pShortTermRefPicSet: *const StdVideoH265ShortTermRefPicSet, - pub pLongTermRefPics: *const StdVideoEncodeH265SliceSegmentLongTermRefPics, + pub pLongTermRefPics: *const StdVideoEncodeH265LongTermRefPics, } #[test] fn bindgen_test_layout_StdVideoEncodeH265PictureInfo() { diff --git a/generator/Vulkan-Headers b/generator/Vulkan-Headers index 94bb3c9..374f9fd 160000 --- a/generator/Vulkan-Headers +++ b/generator/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 94bb3c998b9156b9101421f7614617dfcf7f4256 +Subproject commit 374f9fd97520f6dd1b80745de09208d878ab4a52 diff --git a/generator/src/lib.rs b/generator/src/lib.rs index 7db199e..8ccf65a 100644 --- a/generator/src/lib.rs +++ b/generator/src/lib.rs @@ -2968,7 +2968,7 @@ pub fn write_source_code>(vk_headers_dir: &Path, src_dir: P) { let mut has_lifetimes = definitions .iter() .filter_map(get_variant!(vkxml::DefinitionsElement::Struct)) - .filter(|&s| { + .filter(|s| { s.elements .iter() .filter_map(get_variant!(vkxml::StructElement::Member))