alex/ash
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Update Vulkan-Headers to 1.3.269 (#783)

Browse source 
* Update Vulkan-Headers to 1.3.261

* Update Vulkan-Headers to 1.3.262

* Update Vulkan-Headers to 1.3.263

* Update Vulkan-Headers to 1.3.264

* Update Vulkan-Headers to 1.3.266

* generator: Fix `clippy::filter_map_bool_then`

* Update Vulkan-Headers to 1.3.267

* Update Vulkan-Headers to 1.3.268

* Update Vulkan-Headers to 1.3.269
This commit is contained in:
Marijn Suijten 2023-10-21 00:47:28 +02:00 committed by GitHub
parent d0d5ea1370
commit 11647de859
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 2607 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Changelog.md
View file

@ -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)

2
ash/Cargo.toml
View file

@ -1,6 +1,6 @@
[package]
name = "ash"
version = "0.37.0+1.3.260"
version = "0.37.0+1.3.269"
authors = [
"Maik Klein <maikklein@googlemail.com>",
"Benjamin Saunders <ben.e.saunders@gmail.com>",

21
ash/src/vk/bitflags.rs
View file

@ -1169,6 +1169,14 @@ impl DeviceAddressBindingFlagsEXT {
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkFrameBoundaryFlagBitsEXT.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPresentScalingFlagBitsEXT.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPhysicalDeviceSchedulingControlsFlagBitsARM.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoCodecOperationFlagBitsKHR.html>"]
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)]

318
ash/src/vk/const_debugs.rs
View file

@ -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)
}

1600
ash/src/vk/definitions.rs
View file

File diff suppressed because it is too large Load diff

106
ash/src/vk/enums.rs
View file

@ -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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkCubicFilterWeightsQCOM.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkBlockMatchWindowCompareModeQCOM.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLayeredDriverUnderlyingApiMSFT.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkLatencyMarkerNV.html>"]
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 = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkOutOfBandQueueTypeNV.html>"]
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"),

584
ash/src/vk/extensions.rs
View file

@ -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<F>(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<F>(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);
}

71
ash/src/vk/native.rs
View file

@ -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<StdVideoEncodeH265SliceSegmentLongTermRefPics> =
fn bindgen_test_layout_StdVideoEncodeH265LongTermRefPics() {
const UNINIT: ::std::mem::MaybeUninit<StdVideoEncodeH265LongTermRefPics> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<StdVideoEncodeH265SliceSegmentLongTermRefPics>(),
::std::mem::size_of::<StdVideoEncodeH265LongTermRefPics>(),
148usize,
concat!(
"Size of: ",
stringify!(StdVideoEncodeH265SliceSegmentLongTermRefPics)
)
concat!("Size of: ", stringify!(StdVideoEncodeH265LongTermRefPics))
);
assert_eq!(
::std::mem::align_of::<StdVideoEncodeH265SliceSegmentLongTermRefPics>(),
::std::mem::align_of::<StdVideoEncodeH265LongTermRefPics>(),
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() {

2
generator/Vulkan-Headers

@ -1 +1 @@
Subproject commit 94bb3c998b9156b9101421f7614617dfcf7f4256
Subproject commit 374f9fd97520f6dd1b80745de09208d878ab4a52

2
generator/src/lib.rs
View file

@ -2968,7 +2968,7 @@ pub fn write_source_code<P: AsRef<Path>>(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))