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

Update Vulkan-Headers to 1.3.254 (#760)

Browse source 
* Update Vulkan-Headers to 1.3.252

* Update Vulkan-Headers to 1.3.253

* Update Vulkan-Headers to 1.3.254

* vk/platform_types: Add `_screen_buffer` type for QNX
This commit is contained in:
Marijn Suijten 2023-06-16 17:05:11 +02:00 committed by GitHub
parent 9985b2ca69
commit eb1712944e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 3140 additions and 1402 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Changelog.md
View file

@ -11,6 +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.254 (#760)
### Changed

2
ash/Cargo.toml
View file

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

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

@ -1286,6 +1286,7 @@ vk_bitflags_wrapped!(VideoEncodeFeedbackFlagsKHR, Flags);
impl VideoEncodeFeedbackFlagsKHR {
pub const BITSTREAM_BUFFER_OFFSET: Self = Self(0b1);
pub const BITSTREAM_BYTES_WRITTEN: Self = Self(0b10);
pub const BITSTREAM_HAS_OVERRIDES: Self = Self(0b100);
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@ -1304,32 +1305,52 @@ impl VideoEncodeRateControlModeFlagsKHR {
pub struct VideoEncodeH264CapabilityFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH264CapabilityFlagsEXT, Flags);
impl VideoEncodeH264CapabilityFlagsEXT {
pub const DIRECT_8X8_INFERENCE_ENABLED: Self = Self(0b1);
pub const DIRECT_8X8_INFERENCE_DISABLED: Self = Self(0b10);
pub const SEPARATE_COLOUR_PLANE: Self = Self(0b100);
pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS: Self = Self(0b1000);
pub const SCALING_LISTS: Self = Self(0b1_0000);
pub const HRD_COMPLIANCE: Self = Self(0b10_0000);
pub const CHROMA_QP_OFFSET: Self = Self(0b100_0000);
pub const SECOND_CHROMA_QP_OFFSET: Self = Self(0b1000_0000);
pub const PIC_INIT_QP_MINUS26: Self = Self(0b1_0000_0000);
pub const WEIGHTED_PRED: Self = Self(0b10_0000_0000);
pub const WEIGHTED_BIPRED_EXPLICIT: Self = Self(0b100_0000_0000);
pub const WEIGHTED_BIPRED_IMPLICIT: Self = Self(0b1000_0000_0000);
pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b1_0000_0000_0000);
pub const TRANSFORM_8X8: Self = Self(0b10_0000_0000_0000);
pub const CABAC: Self = Self(0b100_0000_0000_0000);
pub const CAVLC: Self = Self(0b1000_0000_0000_0000);
pub const DEBLOCKING_FILTER_DISABLED: Self = Self(0b1_0000_0000_0000_0000);
pub const DEBLOCKING_FILTER_ENABLED: Self = Self(0b10_0000_0000_0000_0000);
pub const DEBLOCKING_FILTER_PARTIAL: Self = Self(0b100_0000_0000_0000_0000);
pub const DISABLE_DIRECT_SPATIAL_MV_PRED: Self = Self(0b1000_0000_0000_0000_0000);
pub const MULTIPLE_SLICE_PER_FRAME: Self = Self(0b1_0000_0000_0000_0000_0000);
pub const SLICE_MB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000);
pub const ROW_UNALIGNED_SLICE: Self = Self(0b100_0000_0000_0000_0000_0000);
pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000_0000_0000_0000_0000_0000);
pub const B_FRAME_IN_L1_LIST: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
pub const HRD_COMPLIANCE: Self = Self(0b1);
pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(0b10);
pub const ROW_UNALIGNED_SLICE: Self = Self(0b100);
pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1000);
pub const B_FRAME_IN_L0_LIST: Self = Self(0b1_0000);
pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000);
pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(0b100_0000);
pub const PER_SLICE_CONSTANT_QP: Self = Self(0b1000_0000);
pub const GENERATE_PREFIX_NALU: Self = Self(0b1_0000_0000);
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264StdFlagBitsEXT.html>"]
pub struct VideoEncodeH264StdFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH264StdFlagsEXT, Flags);
impl VideoEncodeH264StdFlagsEXT {
pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(0b1);
pub const QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET: Self = Self(0b10);
pub const SCALING_MATRIX_PRESENT_FLAG_SET: Self = Self(0b100);
pub const CHROMA_QP_INDEX_OFFSET: Self = Self(0b1000);
pub const SECOND_CHROMA_QP_INDEX_OFFSET: Self = Self(0b1_0000);
pub const PIC_INIT_QP_MINUS26: Self = Self(0b10_0000);
pub const WEIGHTED_PRED_FLAG_SET: Self = Self(0b100_0000);
pub const WEIGHTED_BIPRED_IDC_EXPLICIT: Self = Self(0b1000_0000);
pub const WEIGHTED_BIPRED_IDC_IMPLICIT: Self = Self(0b1_0000_0000);
pub const TRANSFORM_8X8_MODE_FLAG_SET: Self = Self(0b10_0000_0000);
pub const DIRECT_SPATIAL_MV_PRED_FLAG_UNSET: Self = Self(0b100_0000_0000);
pub const ENTROPY_CODING_MODE_FLAG_UNSET: Self = Self(0b1000_0000_0000);
pub const ENTROPY_CODING_MODE_FLAG_SET: Self = Self(0b1_0000_0000_0000);
pub const DIRECT_8X8_INFERENCE_FLAG_UNSET: Self = Self(0b10_0000_0000_0000);
pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(0b100_0000_0000_0000);
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);
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlFlagBitsEXT.html>"]
pub struct VideoEncodeH264RateControlFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH264RateControlFlagsEXT, Flags);
impl VideoEncodeH264RateControlFlagsEXT {
pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(0b1);
pub const REGULAR_GOP: Self = Self(0b10);
pub const REFERENCE_PATTERN_FLAT: Self = Self(0b100);
pub const REFERENCE_PATTERN_DYADIC: Self = Self(0b1000);
pub const TEMPORAL_LAYER_PATTERN_DYADIC: Self = Self(0b1_0000);
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@ -1439,33 +1460,54 @@ impl RenderingFlags {
pub struct VideoEncodeH265CapabilityFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH265CapabilityFlagsEXT, Flags);
impl VideoEncodeH265CapabilityFlagsEXT {
pub const SEPARATE_COLOUR_PLANE: Self = Self(0b1);
pub const SCALING_LISTS: Self = Self(0b10);
pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED: Self = Self(0b100);
pub const PCM_ENABLE: Self = Self(0b1000);
pub const SPS_TEMPORAL_MVP_ENABLED: Self = Self(0b1_0000);
pub const HRD_COMPLIANCE: Self = Self(0b10_0000);
pub const INIT_QP_MINUS26: Self = Self(0b100_0000);
pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1000_0000);
pub const SIGN_DATA_HIDING_ENABLED: Self = Self(0b1_0000_0000);
pub const TRANSFORM_SKIP_ENABLED: Self = Self(0b10_0000_0000);
pub const TRANSFORM_SKIP_DISABLED: Self = Self(0b100_0000_0000);
pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT: Self = Self(0b1000_0000_0000);
pub const WEIGHTED_PRED: Self = Self(0b1_0000_0000_0000);
pub const WEIGHTED_BIPRED: Self = Self(0b10_0000_0000_0000);
pub const WEIGHTED_PRED_NO_TABLE: Self = Self(0b100_0000_0000_0000);
pub const TRANSQUANT_BYPASS_ENABLED: Self = Self(0b1000_0000_0000_0000);
pub const ENTROPY_CODING_SYNC_ENABLED: Self = Self(0b1_0000_0000_0000_0000);
pub const DEBLOCKING_FILTER_OVERRIDE_ENABLED: Self = Self(0b10_0000_0000_0000_0000);
pub const MULTIPLE_TILE_PER_FRAME: Self = Self(0b100_0000_0000_0000_0000);
pub const MULTIPLE_SLICE_PER_TILE: Self = Self(0b1000_0000_0000_0000_0000);
pub const MULTIPLE_TILE_PER_SLICE: Self = Self(0b1_0000_0000_0000_0000_0000);
pub const SLICE_SEGMENT_CTB_COUNT: Self = Self(0b10_0000_0000_0000_0000_0000);
pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100_0000_0000_0000_0000_0000);
pub const DEPENDENT_SLICE_SEGMENT: Self = Self(0b1000_0000_0000_0000_0000_0000);
pub const DIFFERENT_SLICE_TYPE: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
pub const DIFFERENT_REFERENCE_FINAL_LISTS: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
pub const HRD_COMPLIANCE: Self = Self(0b1);
pub const PREDICTION_WEIGHT_TABLE_GENERATED: Self = Self(0b10);
pub const ROW_UNALIGNED_SLICE_SEGMENT: Self = Self(0b100);
pub const DIFFERENT_SLICE_SEGMENT_TYPE: Self = Self(0b1000);
pub const B_FRAME_IN_L0_LIST: Self = Self(0b1_0000);
pub const B_FRAME_IN_L1_LIST: Self = Self(0b10_0000);
pub const PER_PICTURE_TYPE_MIN_MAX_QP: Self = Self(0b100_0000);
pub const PER_SLICE_SEGMENT_CONSTANT_QP: Self = Self(0b1000_0000);
pub const MULTIPLE_TILES_PER_SLICE_SEGMENT: Self = Self(0b1_0000_0000);
pub const MULTIPLE_SLICE_SEGMENTS_PER_TILE: Self = Self(0b10_0000_0000);
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265StdFlagBitsEXT.html>"]
pub struct VideoEncodeH265StdFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH265StdFlagsEXT, Flags);
impl VideoEncodeH265StdFlagsEXT {
pub const SEPARATE_COLOR_PLANE_FLAG_SET: Self = Self(0b1);
pub const SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET: Self = Self(0b10);
pub const SCALING_LIST_DATA_PRESENT_FLAG_SET: Self = Self(0b100);
pub const PCM_ENABLED_FLAG_SET: Self = Self(0b1000);
pub const SPS_TEMPORAL_MVP_ENABLED_FLAG_SET: Self = Self(0b1_0000);
pub const INIT_QP_MINUS26: Self = Self(0b10_0000);
pub const WEIGHTED_PRED_FLAG_SET: Self = Self(0b100_0000);
pub const WEIGHTED_BIPRED_FLAG_SET: Self = Self(0b1000_0000);
pub const LOG2_PARALLEL_MERGE_LEVEL_MINUS2: Self = Self(0b1_0000_0000);
pub const SIGN_DATA_HIDING_ENABLED_FLAG_SET: Self = Self(0b10_0000_0000);
pub const TRANSFORM_SKIP_ENABLED_FLAG_SET: Self = Self(0b100_0000_0000);
pub const TRANSFORM_SKIP_ENABLED_FLAG_UNSET: Self = Self(0b1000_0000_0000);
pub const PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET: Self = Self(0b1_0000_0000_0000);
pub const TRANSQUANT_BYPASS_ENABLED_FLAG_SET: Self = Self(0b10_0000_0000_0000);
pub const CONSTRAINED_INTRA_PRED_FLAG_SET: Self = Self(0b100_0000_0000_0000);
pub const ENTROPY_CODING_SYNC_ENABLED_FLAG_SET: Self = Self(0b1000_0000_0000_0000);
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);
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlFlagBitsEXT.html>"]
pub struct VideoEncodeH265RateControlFlagsEXT(pub(crate) Flags);
vk_bitflags_wrapped!(VideoEncodeH265RateControlFlagsEXT, Flags);
impl VideoEncodeH265RateControlFlagsEXT {
pub const ATTEMPT_HRD_COMPLIANCE: Self = Self(0b1);
pub const REGULAR_GOP: Self = Self(0b10);
pub const REFERENCE_PATTERN_FLAT: Self = Self(0b100);
pub const REFERENCE_PATTERN_DYADIC: Self = Self(0b1000);
pub const TEMPORAL_SUB_LAYER_PATTERN_DYADIC: Self = Self(0b1_0000);
}
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]

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

@ -1129,6 +1129,23 @@ impl fmt::Debug for DependencyFlags {
debug_flags(f, KNOWN, self.0)
}
}
impl fmt::Debug for DepthBiasRepresentationEXT {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let name = match *self {
Self::LEAST_REPRESENTABLE_VALUE_FORMAT => Some("LEAST_REPRESENTABLE_VALUE_FORMAT"),
Self::LEAST_REPRESENTABLE_VALUE_FORCE_UNORM => {
Some("LEAST_REPRESENTABLE_VALUE_FORCE_UNORM")
}
Self::FLOAT => Some("FLOAT"),
_ => None,
};
if let Some(x) = name {
f.write_str(x)
} else {
self.0.fmt(f)
}
}
}
impl fmt::Debug for DescriptorBindingFlags {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
const KNOWN: &[(Flags, &str)] = &[
@ -1761,6 +1778,10 @@ impl fmt::Debug for ExternalMemoryHandleTypeFlags {
ExternalMemoryHandleTypeFlags::RDMA_ADDRESS_NV.0,
"RDMA_ADDRESS_NV",
),
(
ExternalMemoryHandleTypeFlags::SCREEN_BUFFER_QNX.0,
"SCREEN_BUFFER_QNX",
),
];
debug_flags(f, KNOWN, self.0)
}
@ -4723,15 +4744,16 @@ impl fmt::Debug for StructureType {
Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT => {
Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT")
}
Self::VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT => {
Some("VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT")
}
Self::VIDEO_ENCODE_H264_PICTURE_INFO_EXT => Some("VIDEO_ENCODE_H264_PICTURE_INFO_EXT"),
Self::VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT => {
Some("VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT")
}
Self::VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT => {
Some("VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT")
}
Self::VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT => {
Some("VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT")
}
Self::VIDEO_ENCODE_H264_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H264_PROFILE_INFO_EXT"),
Self::VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT => {
Some("VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT")
@ -4739,6 +4761,18 @@ impl fmt::Debug for StructureType {
Self::VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT => {
Some("VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT")
}
Self::VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT => {
Some("VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT")
}
Self::VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT => {
Some("VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT")
}
Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT => {
Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT")
}
Self::VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT => {
Some("VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT")
}
Self::VIDEO_ENCODE_H265_CAPABILITIES_EXT => Some("VIDEO_ENCODE_H265_CAPABILITIES_EXT"),
Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT => {
Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT")
@ -4746,15 +4780,16 @@ impl fmt::Debug for StructureType {
Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT => {
Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT")
}
Self::VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT => {
Some("VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT")
}
Self::VIDEO_ENCODE_H265_PICTURE_INFO_EXT => Some("VIDEO_ENCODE_H265_PICTURE_INFO_EXT"),
Self::VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT => {
Some("VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT")
}
Self::VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT => {
Some("VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT")
}
Self::VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT => {
Some("VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT")
}
Self::VIDEO_ENCODE_H265_PROFILE_INFO_EXT => Some("VIDEO_ENCODE_H265_PROFILE_INFO_EXT"),
Self::VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT => {
Some("VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT")
@ -4762,6 +4797,18 @@ impl fmt::Debug for StructureType {
Self::VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT => {
Some("VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT")
}
Self::VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT => {
Some("VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT")
}
Self::VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT => {
Some("VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT")
}
Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT => {
Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT")
}
Self::VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT => {
Some("VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT")
}
Self::VIDEO_DECODE_H264_CAPABILITIES_KHR => Some("VIDEO_DECODE_H264_CAPABILITIES_KHR"),
Self::VIDEO_DECODE_H264_PICTURE_INFO_KHR => Some("VIDEO_DECODE_H264_PICTURE_INFO_KHR"),
Self::VIDEO_DECODE_H264_PROFILE_INFO_KHR => Some("VIDEO_DECODE_H264_PROFILE_INFO_KHR"),
@ -5408,6 +5455,11 @@ impl fmt::Debug for StructureType {
Self::RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM => {
Some("RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM")
}
Self::PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT => {
Some("PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT")
}
Self::DEPTH_BIAS_INFO_EXT => Some("DEPTH_BIAS_INFO_EXT"),
Self::DEPTH_BIAS_REPRESENTATION_INFO_EXT => Some("DEPTH_BIAS_REPRESENTATION_INFO_EXT"),
Self::PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT => {
Some("PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT")
}
@ -5456,6 +5508,21 @@ impl fmt::Debug for StructureType {
Self::QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR => {
Some("QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR")
}
Self::PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR => {
Some("PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR")
}
Self::VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR => {
Some("VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR")
}
Self::VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR => {
Some("VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR")
}
Self::VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR => {
Some("VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR")
}
Self::VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR => {
Some("VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR")
}
Self::PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV => {
Some("PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV")
}
@ -5820,6 +5887,9 @@ impl fmt::Debug for StructureType {
Self::IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM => {
Some("IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM")
}
Self::EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT => {
Some("EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT")
}
Self::PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT => {
Some("PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT")
}
@ -5928,6 +5998,15 @@ impl fmt::Debug for StructureType {
Self::PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT => {
Some("PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT")
}
Self::SCREEN_BUFFER_PROPERTIES_QNX => Some("SCREEN_BUFFER_PROPERTIES_QNX"),
Self::SCREEN_BUFFER_FORMAT_PROPERTIES_QNX => {
Some("SCREEN_BUFFER_FORMAT_PROPERTIES_QNX")
}
Self::IMPORT_SCREEN_BUFFER_INFO_QNX => Some("IMPORT_SCREEN_BUFFER_INFO_QNX"),
Self::EXTERNAL_FORMAT_QNX => Some("EXTERNAL_FORMAT_QNX"),
Self::PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX => {
Some("PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX")
}
Self::PHYSICAL_DEVICE_SUBGROUP_PROPERTIES => {
Some("PHYSICAL_DEVICE_SUBGROUP_PROPERTIES")
}
@ -6672,8 +6751,8 @@ impl fmt::Debug for VideoCodingControlFlagsKHR {
"ENCODE_RATE_CONTROL",
),
(
VideoCodingControlFlagsKHR::ENCODE_RATE_CONTROL_LAYER.0,
"ENCODE_RATE_CONTROL_LAYER",
VideoCodingControlFlagsKHR::ENCODE_QUALITY_LEVEL.0,
"ENCODE_QUALITY_LEVEL",
),
];
debug_flags(f, KNOWN, self.0)
@ -6772,6 +6851,10 @@ impl fmt::Debug for VideoEncodeFeedbackFlagsKHR {
VideoEncodeFeedbackFlagsKHR::BITSTREAM_BYTES_WRITTEN.0,
"BITSTREAM_BYTES_WRITTEN",
),
(
VideoEncodeFeedbackFlagsKHR::BITSTREAM_HAS_OVERRIDES.0,
"BITSTREAM_HAS_OVERRIDES",
),
];
debug_flags(f, KNOWN, self.0)
}
@ -6785,87 +6868,13 @@ impl fmt::Debug for VideoEncodeFlagsKHR {
impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
const KNOWN: &[(Flags, &str)] = &[
(
VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_ENABLED.0,
"DIRECT_8X8_INFERENCE_ENABLED",
),
(
VideoEncodeH264CapabilityFlagsEXT::DIRECT_8X8_INFERENCE_DISABLED.0,
"DIRECT_8X8_INFERENCE_DISABLED",
),
(
VideoEncodeH264CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0,
"SEPARATE_COLOUR_PLANE",
),
(
VideoEncodeH264CapabilityFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS.0,
"QPPRIME_Y_ZERO_TRANSFORM_BYPASS",
),
(
VideoEncodeH264CapabilityFlagsEXT::SCALING_LISTS.0,
"SCALING_LISTS",
),
(
VideoEncodeH264CapabilityFlagsEXT::HRD_COMPLIANCE.0,
"HRD_COMPLIANCE",
),
(
VideoEncodeH264CapabilityFlagsEXT::CHROMA_QP_OFFSET.0,
"CHROMA_QP_OFFSET",
),
(
VideoEncodeH264CapabilityFlagsEXT::SECOND_CHROMA_QP_OFFSET.0,
"SECOND_CHROMA_QP_OFFSET",
),
(
VideoEncodeH264CapabilityFlagsEXT::PIC_INIT_QP_MINUS26.0,
"PIC_INIT_QP_MINUS26",
),
(
VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED.0,
"WEIGHTED_PRED",
),
(
VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_EXPLICIT.0,
"WEIGHTED_BIPRED_EXPLICIT",
),
(
VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_BIPRED_IMPLICIT.0,
"WEIGHTED_BIPRED_IMPLICIT",
),
(
VideoEncodeH264CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0,
"WEIGHTED_PRED_NO_TABLE",
),
(
VideoEncodeH264CapabilityFlagsEXT::TRANSFORM_8X8.0,
"TRANSFORM_8X8",
),
(VideoEncodeH264CapabilityFlagsEXT::CABAC.0, "CABAC"),
(VideoEncodeH264CapabilityFlagsEXT::CAVLC.0, "CAVLC"),
(
VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_DISABLED.0,
"DEBLOCKING_FILTER_DISABLED",
),
(
VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_ENABLED.0,
"DEBLOCKING_FILTER_ENABLED",
),
(
VideoEncodeH264CapabilityFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0,
"DEBLOCKING_FILTER_PARTIAL",
),
(
VideoEncodeH264CapabilityFlagsEXT::DISABLE_DIRECT_SPATIAL_MV_PRED.0,
"DISABLE_DIRECT_SPATIAL_MV_PRED",
),
(
VideoEncodeH264CapabilityFlagsEXT::MULTIPLE_SLICE_PER_FRAME.0,
"MULTIPLE_SLICE_PER_FRAME",
),
(
VideoEncodeH264CapabilityFlagsEXT::SLICE_MB_COUNT.0,
"SLICE_MB_COUNT",
VideoEncodeH264CapabilityFlagsEXT::PREDICTION_WEIGHT_TABLE_GENERATED.0,
"PREDICTION_WEIGHT_TABLE_GENERATED",
),
(
VideoEncodeH264CapabilityFlagsEXT::ROW_UNALIGNED_SLICE.0,
@ -6875,143 +6884,178 @@ impl fmt::Debug for VideoEncodeH264CapabilityFlagsEXT {
VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0,
"DIFFERENT_SLICE_TYPE",
),
(
VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L0_LIST.0,
"B_FRAME_IN_L0_LIST",
),
(
VideoEncodeH264CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0,
"B_FRAME_IN_L1_LIST",
),
(
VideoEncodeH264CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0,
"DIFFERENT_REFERENCE_FINAL_LISTS",
VideoEncodeH264CapabilityFlagsEXT::PER_PICTURE_TYPE_MIN_MAX_QP.0,
"PER_PICTURE_TYPE_MIN_MAX_QP",
),
(
VideoEncodeH264CapabilityFlagsEXT::PER_SLICE_CONSTANT_QP.0,
"PER_SLICE_CONSTANT_QP",
),
(
VideoEncodeH264CapabilityFlagsEXT::GENERATE_PREFIX_NALU.0,
"GENERATE_PREFIX_NALU",
),
];
debug_flags(f, KNOWN, self.0)
}
}
impl fmt::Debug for VideoEncodeH264RateControlStructureEXT {
impl fmt::Debug for VideoEncodeH264RateControlFlagsEXT {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let name = match *self {
Self::UNKNOWN => Some("UNKNOWN"),
Self::FLAT => Some("FLAT"),
Self::DYADIC => Some("DYADIC"),
_ => None,
};
if let Some(x) = name {
f.write_str(x)
} else {
self.0.fmt(f)
}
const KNOWN: &[(Flags, &str)] = &[
(
VideoEncodeH264RateControlFlagsEXT::ATTEMPT_HRD_COMPLIANCE.0,
"ATTEMPT_HRD_COMPLIANCE",
),
(
VideoEncodeH264RateControlFlagsEXT::REGULAR_GOP.0,
"REGULAR_GOP",
),
(
VideoEncodeH264RateControlFlagsEXT::REFERENCE_PATTERN_FLAT.0,
"REFERENCE_PATTERN_FLAT",
),
(
VideoEncodeH264RateControlFlagsEXT::REFERENCE_PATTERN_DYADIC.0,
"REFERENCE_PATTERN_DYADIC",
),
(
VideoEncodeH264RateControlFlagsEXT::TEMPORAL_LAYER_PATTERN_DYADIC.0,
"TEMPORAL_LAYER_PATTERN_DYADIC",
),
];
debug_flags(f, KNOWN, self.0)
}
}
impl fmt::Debug for VideoEncodeH264StdFlagsEXT {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
const KNOWN: &[(Flags, &str)] = &[
(
VideoEncodeH264StdFlagsEXT::SEPARATE_COLOR_PLANE_FLAG_SET.0,
"SEPARATE_COLOR_PLANE_FLAG_SET",
),
(
VideoEncodeH264StdFlagsEXT::QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET.0,
"QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET",
),
(
VideoEncodeH264StdFlagsEXT::SCALING_MATRIX_PRESENT_FLAG_SET.0,
"SCALING_MATRIX_PRESENT_FLAG_SET",
),
(
VideoEncodeH264StdFlagsEXT::CHROMA_QP_INDEX_OFFSET.0,
"CHROMA_QP_INDEX_OFFSET",
),
(
VideoEncodeH264StdFlagsEXT::SECOND_CHROMA_QP_INDEX_OFFSET.0,
"SECOND_CHROMA_QP_INDEX_OFFSET",
),
(
VideoEncodeH264StdFlagsEXT::PIC_INIT_QP_MINUS26.0,
"PIC_INIT_QP_MINUS26",
),
(
VideoEncodeH264StdFlagsEXT::WEIGHTED_PRED_FLAG_SET.0,
"WEIGHTED_PRED_FLAG_SET",
),
(
VideoEncodeH264StdFlagsEXT::WEIGHTED_BIPRED_IDC_EXPLICIT.0,
"WEIGHTED_BIPRED_IDC_EXPLICIT",
),
(
VideoEncodeH264StdFlagsEXT::WEIGHTED_BIPRED_IDC_IMPLICIT.0,
"WEIGHTED_BIPRED_IDC_IMPLICIT",
),
(
VideoEncodeH264StdFlagsEXT::TRANSFORM_8X8_MODE_FLAG_SET.0,
"TRANSFORM_8X8_MODE_FLAG_SET",
),
(
VideoEncodeH264StdFlagsEXT::DIRECT_SPATIAL_MV_PRED_FLAG_UNSET.0,
"DIRECT_SPATIAL_MV_PRED_FLAG_UNSET",
),
(
VideoEncodeH264StdFlagsEXT::ENTROPY_CODING_MODE_FLAG_UNSET.0,
"ENTROPY_CODING_MODE_FLAG_UNSET",
),
(
VideoEncodeH264StdFlagsEXT::ENTROPY_CODING_MODE_FLAG_SET.0,
"ENTROPY_CODING_MODE_FLAG_SET",
),
(
VideoEncodeH264StdFlagsEXT::DIRECT_8X8_INFERENCE_FLAG_UNSET.0,
"DIRECT_8X8_INFERENCE_FLAG_UNSET",
),
(
VideoEncodeH264StdFlagsEXT::CONSTRAINED_INTRA_PRED_FLAG_SET.0,
"CONSTRAINED_INTRA_PRED_FLAG_SET",
),
(
VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_DISABLED.0,
"DEBLOCKING_FILTER_DISABLED",
),
(
VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_ENABLED.0,
"DEBLOCKING_FILTER_ENABLED",
),
(
VideoEncodeH264StdFlagsEXT::DEBLOCKING_FILTER_PARTIAL.0,
"DEBLOCKING_FILTER_PARTIAL",
),
];
debug_flags(f, KNOWN, self.0)
}
}
impl fmt::Debug for VideoEncodeH265CapabilityFlagsEXT {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
const KNOWN: &[(Flags, &str)] = &[
(
VideoEncodeH265CapabilityFlagsEXT::SEPARATE_COLOUR_PLANE.0,
"SEPARATE_COLOUR_PLANE",
),
(
VideoEncodeH265CapabilityFlagsEXT::SCALING_LISTS.0,
"SCALING_LISTS",
),
(
VideoEncodeH265CapabilityFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED.0,
"SAMPLE_ADAPTIVE_OFFSET_ENABLED",
),
(
VideoEncodeH265CapabilityFlagsEXT::PCM_ENABLE.0,
"PCM_ENABLE",
),
(
VideoEncodeH265CapabilityFlagsEXT::SPS_TEMPORAL_MVP_ENABLED.0,
"SPS_TEMPORAL_MVP_ENABLED",
),
(
VideoEncodeH265CapabilityFlagsEXT::HRD_COMPLIANCE.0,
"HRD_COMPLIANCE",
),
(
VideoEncodeH265CapabilityFlagsEXT::INIT_QP_MINUS26.0,
"INIT_QP_MINUS26",
),
(
VideoEncodeH265CapabilityFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0,
"LOG2_PARALLEL_MERGE_LEVEL_MINUS2",
),
(
VideoEncodeH265CapabilityFlagsEXT::SIGN_DATA_HIDING_ENABLED.0,
"SIGN_DATA_HIDING_ENABLED",
),
(
VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_ENABLED.0,
"TRANSFORM_SKIP_ENABLED",
),
(
VideoEncodeH265CapabilityFlagsEXT::TRANSFORM_SKIP_DISABLED.0,
"TRANSFORM_SKIP_DISABLED",
),
(
VideoEncodeH265CapabilityFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT.0,
"PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT",
),
(
VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED.0,
"WEIGHTED_PRED",
),
(
VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_BIPRED.0,
"WEIGHTED_BIPRED",
),
(
VideoEncodeH265CapabilityFlagsEXT::WEIGHTED_PRED_NO_TABLE.0,
"WEIGHTED_PRED_NO_TABLE",
),
(
VideoEncodeH265CapabilityFlagsEXT::TRANSQUANT_BYPASS_ENABLED.0,
"TRANSQUANT_BYPASS_ENABLED",
),
(
VideoEncodeH265CapabilityFlagsEXT::ENTROPY_CODING_SYNC_ENABLED.0,
"ENTROPY_CODING_SYNC_ENABLED",
),
(
VideoEncodeH265CapabilityFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED.0,
"DEBLOCKING_FILTER_OVERRIDE_ENABLED",
),
(
VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_FRAME.0,
"MULTIPLE_TILE_PER_FRAME",
),
(
VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_PER_TILE.0,
"MULTIPLE_SLICE_PER_TILE",
),
(
VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILE_PER_SLICE.0,
"MULTIPLE_TILE_PER_SLICE",
),
(
VideoEncodeH265CapabilityFlagsEXT::SLICE_SEGMENT_CTB_COUNT.0,
"SLICE_SEGMENT_CTB_COUNT",
VideoEncodeH265CapabilityFlagsEXT::PREDICTION_WEIGHT_TABLE_GENERATED.0,
"PREDICTION_WEIGHT_TABLE_GENERATED",
),
(
VideoEncodeH265CapabilityFlagsEXT::ROW_UNALIGNED_SLICE_SEGMENT.0,
"ROW_UNALIGNED_SLICE_SEGMENT",
),
(
VideoEncodeH265CapabilityFlagsEXT::DEPENDENT_SLICE_SEGMENT.0,
"DEPENDENT_SLICE_SEGMENT",
VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_SEGMENT_TYPE.0,
"DIFFERENT_SLICE_SEGMENT_TYPE",
),
(
VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_SLICE_TYPE.0,
"DIFFERENT_SLICE_TYPE",
VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L0_LIST.0,
"B_FRAME_IN_L0_LIST",
),
(
VideoEncodeH265CapabilityFlagsEXT::B_FRAME_IN_L1_LIST.0,
"B_FRAME_IN_L1_LIST",
),
(
VideoEncodeH265CapabilityFlagsEXT::DIFFERENT_REFERENCE_FINAL_LISTS.0,
"DIFFERENT_REFERENCE_FINAL_LISTS",
VideoEncodeH265CapabilityFlagsEXT::PER_PICTURE_TYPE_MIN_MAX_QP.0,
"PER_PICTURE_TYPE_MIN_MAX_QP",
),
(
VideoEncodeH265CapabilityFlagsEXT::PER_SLICE_SEGMENT_CONSTANT_QP.0,
"PER_SLICE_SEGMENT_CONSTANT_QP",
),
(
VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_TILES_PER_SLICE_SEGMENT.0,
"MULTIPLE_TILES_PER_SLICE_SEGMENT",
),
(
VideoEncodeH265CapabilityFlagsEXT::MULTIPLE_SLICE_SEGMENTS_PER_TILE.0,
"MULTIPLE_SLICE_SEGMENTS_PER_TILE",
),
];
debug_flags(f, KNOWN, self.0)
@ -7027,19 +7071,114 @@ impl fmt::Debug for VideoEncodeH265CtbSizeFlagsEXT {
debug_flags(f, KNOWN, self.0)
}
}
impl fmt::Debug for VideoEncodeH265RateControlStructureEXT {
impl fmt::Debug for VideoEncodeH265RateControlFlagsEXT {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let name = match *self {
Self::UNKNOWN => Some("UNKNOWN"),
Self::FLAT => Some("FLAT"),
Self::DYADIC => Some("DYADIC"),
_ => None,
};
if let Some(x) = name {
f.write_str(x)
} else {
self.0.fmt(f)
}
const KNOWN: &[(Flags, &str)] = &[
(
VideoEncodeH265RateControlFlagsEXT::ATTEMPT_HRD_COMPLIANCE.0,
"ATTEMPT_HRD_COMPLIANCE",
),
(
VideoEncodeH265RateControlFlagsEXT::REGULAR_GOP.0,
"REGULAR_GOP",
),
(
VideoEncodeH265RateControlFlagsEXT::REFERENCE_PATTERN_FLAT.0,
"REFERENCE_PATTERN_FLAT",
),
(
VideoEncodeH265RateControlFlagsEXT::REFERENCE_PATTERN_DYADIC.0,
"REFERENCE_PATTERN_DYADIC",
),
(
VideoEncodeH265RateControlFlagsEXT::TEMPORAL_SUB_LAYER_PATTERN_DYADIC.0,
"TEMPORAL_SUB_LAYER_PATTERN_DYADIC",
),
];
debug_flags(f, KNOWN, self.0)
}
}
impl fmt::Debug for VideoEncodeH265StdFlagsEXT {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
const KNOWN: &[(Flags, &str)] = &[
(
VideoEncodeH265StdFlagsEXT::SEPARATE_COLOR_PLANE_FLAG_SET.0,
"SEPARATE_COLOR_PLANE_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET.0,
"SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::SCALING_LIST_DATA_PRESENT_FLAG_SET.0,
"SCALING_LIST_DATA_PRESENT_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::PCM_ENABLED_FLAG_SET.0,
"PCM_ENABLED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::SPS_TEMPORAL_MVP_ENABLED_FLAG_SET.0,
"SPS_TEMPORAL_MVP_ENABLED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::INIT_QP_MINUS26.0,
"INIT_QP_MINUS26",
),
(
VideoEncodeH265StdFlagsEXT::WEIGHTED_PRED_FLAG_SET.0,
"WEIGHTED_PRED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::WEIGHTED_BIPRED_FLAG_SET.0,
"WEIGHTED_BIPRED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::LOG2_PARALLEL_MERGE_LEVEL_MINUS2.0,
"LOG2_PARALLEL_MERGE_LEVEL_MINUS2",
),
(
VideoEncodeH265StdFlagsEXT::SIGN_DATA_HIDING_ENABLED_FLAG_SET.0,
"SIGN_DATA_HIDING_ENABLED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::TRANSFORM_SKIP_ENABLED_FLAG_SET.0,
"TRANSFORM_SKIP_ENABLED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::TRANSFORM_SKIP_ENABLED_FLAG_UNSET.0,
"TRANSFORM_SKIP_ENABLED_FLAG_UNSET",
),
(
VideoEncodeH265StdFlagsEXT::PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET.0,
"PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::TRANSQUANT_BYPASS_ENABLED_FLAG_SET.0,
"TRANSQUANT_BYPASS_ENABLED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::CONSTRAINED_INTRA_PRED_FLAG_SET.0,
"CONSTRAINED_INTRA_PRED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::ENTROPY_CODING_SYNC_ENABLED_FLAG_SET.0,
"ENTROPY_CODING_SYNC_ENABLED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET.0,
"DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET.0,
"DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET",
),
(
VideoEncodeH265StdFlagsEXT::DEPENDENT_SLICE_SEGMENT_FLAG_SET.0,
"DEPENDENT_SLICE_SEGMENT_FLAG_SET",
),
];
debug_flags(f, KNOWN, self.0)
}
}
impl fmt::Debug for VideoEncodeH265TransformBlockSizeFlagsEXT {
@ -7119,10 +7258,16 @@ impl fmt::Debug for VideoEndCodingFlagsKHR {
}
impl fmt::Debug for VideoSessionCreateFlagsKHR {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
const KNOWN: &[(Flags, &str)] = &[(
VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0,
"PROTECTED_CONTENT",
)];
const KNOWN: &[(Flags, &str)] = &[
(
VideoSessionCreateFlagsKHR::PROTECTED_CONTENT.0,
"PROTECTED_CONTENT",
),
(
VideoSessionCreateFlagsKHR::ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS.0,
"ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS",
),
];
debug_flags(f, KNOWN, self.0)
}
}

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

File diff suppressed because it is too large Load diff

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

@ -2530,44 +2530,6 @@ impl VideoEncodeTuningModeKHR {
}
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH264RateControlStructureEXT.html>"]
pub struct VideoEncodeH264RateControlStructureEXT(pub(crate) i32);
impl VideoEncodeH264RateControlStructureEXT {
#[inline]
pub const fn from_raw(x: i32) -> Self {
Self(x)
}
#[inline]
pub const fn as_raw(self) -> i32 {
self.0
}
}
impl VideoEncodeH264RateControlStructureEXT {
pub const UNKNOWN: Self = Self(0);
pub const FLAT: Self = Self(1);
pub const DYADIC: Self = Self(2);
}
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkVideoEncodeH265RateControlStructureEXT.html>"]
pub struct VideoEncodeH265RateControlStructureEXT(pub(crate) i32);
impl VideoEncodeH265RateControlStructureEXT {
#[inline]
pub const fn from_raw(x: i32) -> Self {
Self(x)
}
#[inline]
pub const fn as_raw(self) -> i32 {
self.0
}
}
impl VideoEncodeH265RateControlStructureEXT {
pub const UNKNOWN: Self = Self(0);
pub const FLAT: Self = Self(1);
pub const DYADIC: Self = Self(2);
}
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkPipelineRobustnessBufferBehaviorEXT.html>"]
pub struct PipelineRobustnessBufferBehaviorEXT(pub(crate) i32);
impl PipelineRobustnessBufferBehaviorEXT {
@ -2745,6 +2707,25 @@ impl OpacityMicromapSpecialIndexEXT {
}
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDepthBiasRepresentationEXT.html>"]
pub struct DepthBiasRepresentationEXT(pub(crate) i32);
impl DepthBiasRepresentationEXT {
#[inline]
pub const fn from_raw(x: i32) -> Self {
Self(x)
}
#[inline]
pub const fn as_raw(self) -> i32 {
self.0
}
}
impl DepthBiasRepresentationEXT {
pub const LEAST_REPRESENTABLE_VALUE_FORMAT: Self = Self(0);
pub const LEAST_REPRESENTABLE_VALUE_FORCE_UNORM: Self = Self(1);
pub const FLOAT: Self = Self(2);
}
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
#[doc = "<https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkDeviceFaultAddressTypeEXT.html>"]
pub struct DeviceFaultAddressTypeEXT(pub(crate) i32);
impl DeviceFaultAddressTypeEXT {

218
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 = 10u32;
pub const SPEC_VERSION: u32 = 11u32;
}
#[derive(Clone)]
pub struct ExtVideoEncodeH264Fn;
@ -2761,12 +2761,17 @@ impl StructureType {
pub const VIDEO_ENCODE_H264_CAPABILITIES_EXT: Self = Self(1_000_038_000);
pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_001);
pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_002);
pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_003);
pub const VIDEO_ENCODE_H264_PICTURE_INFO_EXT: Self = Self(1_000_038_003);
pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_004);
pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: Self = Self(1_000_038_005);
pub const VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: Self = Self(1_000_038_006);
pub const VIDEO_ENCODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_038_007);
pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_008);
pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_009);
pub const VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: Self = Self(1_000_038_010);
pub const VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: Self = Self(1_000_038_011);
pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: Self = Self(1_000_038_012);
pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: Self = Self(1_000_038_013);
}
#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
impl VideoCodecOperationFlagsKHR {
@ -2775,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 = 10u32;
pub const SPEC_VERSION: u32 = 11u32;
}
#[derive(Clone)]
pub struct ExtVideoEncodeH265Fn;
@ -2784,12 +2789,17 @@ impl StructureType {
pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000);
pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_001);
pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_002);
pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_003);
pub const VIDEO_ENCODE_H265_PICTURE_INFO_EXT: Self = Self(1_000_039_003);
pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_004);
pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: Self = Self(1_000_039_005);
pub const VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: Self = Self(1_000_039_006);
pub const VIDEO_ENCODE_H265_PROFILE_INFO_EXT: Self = Self(1_000_039_007);
pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_009);
pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_010);
pub const VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: Self = Self(1_000_039_011);
pub const VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: Self = Self(1_000_039_012);
pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: Self = Self(1_000_039_013);
pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: Self = Self(1_000_039_014);
}
#[doc = "Generated from 'VK_EXT_video_encode_h265'"]
impl VideoCodecOperationFlagsKHR {
@ -13195,6 +13205,56 @@ impl StructureType {
Self(1_000_282_000);
pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001);
}
impl ExtDepthBiasControlFn {
pub const NAME: &'static ::std::ffi::CStr =
unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_bias_control\0") };
pub const SPEC_VERSION: u32 = 1u32;
}
#[allow(non_camel_case_types)]
pub type PFN_vkCmdSetDepthBias2EXT = unsafe extern "system" fn(
command_buffer: CommandBuffer,
p_depth_bias_info: *const DepthBiasInfoEXT,
);
#[derive(Clone)]
pub struct ExtDepthBiasControlFn {
pub cmd_set_depth_bias2_ext: PFN_vkCmdSetDepthBias2EXT,
}
unsafe impl Send for ExtDepthBiasControlFn {}
unsafe impl Sync for ExtDepthBiasControlFn {}
impl ExtDepthBiasControlFn {
pub fn load<F>(mut _f: F) -> Self
where
F: FnMut(&::std::ffi::CStr) -> *const c_void,
{
Self {
cmd_set_depth_bias2_ext: unsafe {
unsafe extern "system" fn cmd_set_depth_bias2_ext(
_command_buffer: CommandBuffer,
_p_depth_bias_info: *const DepthBiasInfoEXT,
) {
panic!(concat!(
"Unable to load ",
stringify!(cmd_set_depth_bias2_ext)
))
}
let cname =
::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias2EXT\0");
let val = _f(cname);
if val.is_null() {
cmd_set_depth_bias2_ext
} else {
::std::mem::transmute(val)
}
},
}
}
}
#[doc = "Generated from 'VK_EXT_depth_bias_control'"]
impl StructureType {
pub const PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: Self = Self(1_000_283_000);
pub const DEPTH_BIAS_INFO_EXT: Self = Self(1_000_283_001);
pub const DEPTH_BIAS_REPRESENTATION_INFO_EXT: Self = Self(1_000_283_002);
}
impl ExtDeviceMemoryReportFn {
pub const NAME: &'static ::std::ffi::CStr = unsafe {
::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_memory_report\0")
@ -13540,15 +13600,33 @@ 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 = 8u32;
pub const SPEC_VERSION: u32 = 9u32;
}
#[allow(non_camel_case_types)]
pub type PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR =
unsafe extern "system" fn(
physical_device: PhysicalDevice,
p_quality_level_info: *const PhysicalDeviceVideoEncodeQualityLevelInfoKHR,
p_quality_level_properties: *mut VideoEncodeQualityLevelPropertiesKHR,
) -> Result;
#[allow(non_camel_case_types)]
pub type PFN_vkGetEncodedVideoSessionParametersKHR = unsafe extern "system" fn(
device: Device,
p_video_session_parameters_info: *const VideoEncodeSessionParametersGetInfoKHR,
p_feedback_info: *mut VideoEncodeSessionParametersFeedbackInfoKHR,
p_data_size: *mut usize,
p_data: *mut c_void,
) -> Result;
#[allow(non_camel_case_types)]
pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn(
command_buffer: CommandBuffer,
p_encode_info: *const VideoEncodeInfoKHR,
);
#[derive(Clone)]
pub struct KhrVideoEncodeQueueFn {
pub get_physical_device_video_encode_quality_level_properties_khr:
PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR,
pub get_encoded_video_session_parameters_khr: PFN_vkGetEncodedVideoSessionParametersKHR,
pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR,
}
unsafe impl Send for KhrVideoEncodeQueueFn {}
@ -13559,6 +13637,50 @@ impl KhrVideoEncodeQueueFn {
F: FnMut(&::std::ffi::CStr) -> *const c_void,
{
Self {
get_physical_device_video_encode_quality_level_properties_khr: unsafe {
unsafe extern "system" fn get_physical_device_video_encode_quality_level_properties_khr(
_physical_device: PhysicalDevice,
_p_quality_level_info: *const PhysicalDeviceVideoEncodeQualityLevelInfoKHR,
_p_quality_level_properties: *mut VideoEncodeQualityLevelPropertiesKHR,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_physical_device_video_encode_quality_level_properties_khr)
))
}
let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
b"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_physical_device_video_encode_quality_level_properties_khr
} else {
::std::mem::transmute(val)
}
},
get_encoded_video_session_parameters_khr: unsafe {
unsafe extern "system" fn get_encoded_video_session_parameters_khr(
_device: Device,
_p_video_session_parameters_info: *const VideoEncodeSessionParametersGetInfoKHR,
_p_feedback_info: *mut VideoEncodeSessionParametersFeedbackInfoKHR,
_p_data_size: *mut usize,
_p_data: *mut c_void,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_encoded_video_session_parameters_khr)
))
}
let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
b"vkGetEncodedVideoSessionParametersKHR\0",
);
let val = _f(cname);
if val.is_null() {
get_encoded_video_session_parameters_khr
} else {
::std::mem::transmute(val)
}
},
cmd_encode_video_khr: unsafe {
unsafe extern "system" fn cmd_encode_video_khr(
_command_buffer: CommandBuffer,
@ -13635,11 +13757,20 @@ impl StructureType {
pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1_000_299_003);
pub const VIDEO_ENCODE_USAGE_INFO_KHR: Self = Self(1_000_299_004);
pub const QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: Self = Self(1_000_299_005);
pub const PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: Self = Self(1_000_299_006);
pub const VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: Self = Self(1_000_299_007);
pub const VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: Self = Self(1_000_299_008);
pub const VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: Self = Self(1_000_299_009);
pub const VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: Self = Self(1_000_299_010);
}
#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
impl VideoCodingControlFlagsKHR {
pub const ENCODE_RATE_CONTROL: Self = Self(0b10);
pub const ENCODE_RATE_CONTROL_LAYER: Self = Self(0b100);
pub const ENCODE_QUALITY_LEVEL: Self = Self(0b100);
}
#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
impl VideoSessionCreateFlagsKHR {
pub const ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS: Self = Self(0b10);
}
impl NvDeviceDiagnosticsConfigFn {
pub const NAME: &'static ::std::ffi::CStr = unsafe {
@ -17854,6 +17985,20 @@ 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 ExtExternalMemoryAcquireUnmodifiedFn {
pub const NAME: &'static ::std::ffi::CStr = unsafe {
::std::ffi::CStr::from_bytes_with_nul_unchecked(
b"VK_EXT_external_memory_acquire_unmodified\0",
)
};
pub const SPEC_VERSION: u32 = 1u32;
}
#[derive(Clone)]
pub struct ExtExternalMemoryAcquireUnmodifiedFn;
#[doc = "Generated from 'VK_EXT_external_memory_acquire_unmodified'"]
impl StructureType {
pub const EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: Self = Self(1_000_453_000);
}
impl ExtExtendedDynamicState3Fn {
pub const NAME: &'static ::std::ffi::CStr = unsafe {
::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state3\0")
@ -20571,3 +20716,64 @@ impl StructureType {
pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: Self =
Self(1_000_524_000);
}
impl QnxExternalMemoryScreenBufferFn {
pub const NAME: &'static ::std::ffi::CStr = unsafe {
::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_external_memory_screen_buffer\0")
};
pub const SPEC_VERSION: u32 = 1u32;
}
#[allow(non_camel_case_types)]
pub type PFN_vkGetScreenBufferPropertiesQNX = unsafe extern "system" fn(
device: Device,
buffer: *const _screen_buffer,
p_properties: *mut ScreenBufferPropertiesQNX,
) -> Result;
#[derive(Clone)]
pub struct QnxExternalMemoryScreenBufferFn {
pub get_screen_buffer_properties_qnx: PFN_vkGetScreenBufferPropertiesQNX,
}
unsafe impl Send for QnxExternalMemoryScreenBufferFn {}
unsafe impl Sync for QnxExternalMemoryScreenBufferFn {}
impl QnxExternalMemoryScreenBufferFn {
pub fn load<F>(mut _f: F) -> Self
where
F: FnMut(&::std::ffi::CStr) -> *const c_void,
{
Self {
get_screen_buffer_properties_qnx: unsafe {
unsafe extern "system" fn get_screen_buffer_properties_qnx(
_device: Device,
_buffer: *const _screen_buffer,
_p_properties: *mut ScreenBufferPropertiesQNX,
) -> Result {
panic!(concat!(
"Unable to load ",
stringify!(get_screen_buffer_properties_qnx)
))
}
let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
b"vkGetScreenBufferPropertiesQNX\0",
);
let val = _f(cname);
if val.is_null() {
get_screen_buffer_properties_qnx
} else {
::std::mem::transmute(val)
}
},
}
}
}
#[doc = "Generated from 'VK_QNX_external_memory_screen_buffer'"]
impl ExternalMemoryHandleTypeFlags {
pub const SCREEN_BUFFER_QNX: Self = Self(0b100_0000_0000_0000);
}
#[doc = "Generated from 'VK_QNX_external_memory_screen_buffer'"]
impl StructureType {
pub const SCREEN_BUFFER_PROPERTIES_QNX: Self = Self(1_000_529_000);
pub const SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: Self = Self(1_000_529_001);
pub const IMPORT_SCREEN_BUFFER_INFO_QNX: Self = Self(1_000_529_002);
pub const EXTERNAL_FORMAT_QNX: Self = Self(1_000_529_003);
pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: Self =
Self(1_000_529_004);
}

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

File diff suppressed because it is too large Load diff

1
ash/src/vk/platform_types.rs
View file

@ -19,6 +19,7 @@ pub type HMONITOR = HANDLE;
pub type DWORD = c_ulong;
pub type LPCWSTR = *const u16;
pub type zx_handle_t = u32;
pub type _screen_buffer = c_void;
pub type _screen_context = c_void;
pub type _screen_window = c_void;
pub type SECURITY_ATTRIBUTES = c_void;

2
generator/Vulkan-Headers

@ -1 +1 @@
Subproject commit 3df77fb3e4e0961f7f01de9a9ae20dfdcfc4910a
Subproject commit c1a8560c5cf5e7bd6dbc71fe69b1a317411c36b8