AuroraMiddleware/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp synced 2025-01-10 17:00:10 +00:00
Code Issues Releases Wiki Activity

Update to VK_HEADER_VERSION 187

Browse Source
This commit is contained in:
asuessenbach 2021-08-04 10:45:53 +02:00
parent 15c7d606af
commit 6e1a3de4d2
5 changed files with 175 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit b8c57b0a09f7324fec5a7c363f5e26ff4d5a3222 Subproject commit 9fe958cdabcaf87650a4517b27df1ec2034d051f

2
VulkanHppGenerator.cpp
View File

@ -13003,7 +13003,7 @@ void VulkanHppGenerator::readEnum( tinyxml2::XMLElement const * el
} }
std::string prefix = generateEnumSuffixes( enumIt->first, enumIt->second.isBitmask, m_tags ).first; std::string prefix = generateEnumSuffixes( enumIt->first, enumIt->second.isBitmask, m_tags ).first;
warn( beginsWith( name, prefix ), check( beginsWith( name, prefix ),
line, line,
"encountered enum value <" + name + "> that does not begin with expected prefix <" + prefix + ">" ); "encountered enum value <" + name + "> that does not begin with expected prefix <" + prefix + ">" );

2
vulkan/vulkan.hpp
View File

@ -111,7 +111,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <compare> # include <compare>
#endif #endif
static_assert( VK_HEADER_VERSION == 186, "Wrong VK_HEADER_VERSION!" ); static_assert( VK_HEADER_VERSION == 187, "Wrong VK_HEADER_VERSION!" );
// 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default. // 32-bit vulkan is not typesafe for handles, so don't allow copy constructors on this platform by default.
// To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION

271
vulkan/vulkan_enums.hpp
View File

@ -5704,18 +5704,18 @@ namespace VULKAN_HPP_NAMESPACE
} }
} }
enum class VideoCapabilitiesFlagBitsKHR : VkVideoCapabilitiesFlagsKHR enum class VideoCapabilityFlagBitsKHR : VkVideoCapabilityFlagsKHR
{ {
eProtectedContent = VK_VIDEO_CAPABILITIES_PROTECTED_CONTENT_BIT_KHR, eProtectedContent = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR,
eSeparateReferenceImages = VK_VIDEO_CAPABILITIES_SEPARATE_REFERENCE_IMAGES_BIT_KHR eSeparateReferenceImages = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR
}; };
VULKAN_HPP_INLINE std::string to_string( VideoCapabilitiesFlagBitsKHR value ) VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagBitsKHR value )
{ {
switch ( value ) switch ( value )
{ {
case VideoCapabilitiesFlagBitsKHR::eProtectedContent: return "ProtectedContent"; case VideoCapabilityFlagBitsKHR::eProtectedContent: return "ProtectedContent";
case VideoCapabilitiesFlagBitsKHR::eSeparateReferenceImages: return "SeparateReferenceImages"; case VideoCapabilityFlagBitsKHR::eSeparateReferenceImages: return "SeparateReferenceImages";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@ -5843,53 +5843,36 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h264 === //=== VK_EXT_video_encode_h264 ===
enum class VideoEncodeH264CapabilitiesFlagBitsEXT : VkVideoEncodeH264CapabilitiesFlagsEXT enum class VideoEncodeH264CapabilityFlagBitsEXT : VkVideoEncodeH264CapabilityFlagsEXT
{ {
eVkVideoEncodeH264CapabilityCabac = VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT, eCabac = VK_VIDEO_ENCODE_H264_CAPABILITY_CABAC_BIT_EXT,
eVkVideoEncodeH264CapabilityCavlc = VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT, eCavlc = VK_VIDEO_ENCODE_H264_CAPABILITY_CAVLC_BIT_EXT,
eVkVideoEncodeH264CapabilityWeightedBiPredImplicit = eWeightedBiPredImplicit = VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT,
VK_VIDEO_ENCODE_H264_CAPABILITY_WEIGHTED_BI_PRED_IMPLICIT_BIT_EXT, eTransform8X8 = VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT,
eVkVideoEncodeH264CapabilityTransform8X8 = VK_VIDEO_ENCODE_H264_CAPABILITY_TRANSFORM_8X8_BIT_EXT, eChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT,
eVkVideoEncodeH264CapabilityChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_CHROMA_QP_OFFSET_BIT_EXT, eSecondChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT,
eVkVideoEncodeH264CapabilitySecondChromaQpOffset = VK_VIDEO_ENCODE_H264_CAPABILITY_SECOND_CHROMA_QP_OFFSET_BIT_EXT, eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT,
eVkVideoEncodeH264CapabilityDeblockingFilterDisabled = eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT,
VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_DISABLED_BIT_EXT, eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT,
eVkVideoEncodeH264CapabilityDeblockingFilterEnabled = eMultipleSlicePerFrame = VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT,
VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_ENABLED_BIT_EXT, eEvenlyDistributedSliceSize = VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT
eVkVideoEncodeH264CapabilityDeblockingFilterPartial =
VK_VIDEO_ENCODE_H264_CAPABILITY_DEBLOCKING_FILTER_PARTIAL_BIT_EXT,
eVkVideoEncodeH264CapabilityMultipleSlicePerFrame =
VK_VIDEO_ENCODE_H264_CAPABILITY_MULTIPLE_SLICE_PER_FRAME_BIT_EXT,
eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize =
VK_VIDEO_ENCODE_H264_CAPABILITY_EVENLY_DISTRIBUTED_SLICE_SIZE_BIT_EXT
}; };
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilitiesFlagBitsEXT value ) VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagBitsEXT value )
{ {
switch ( value ) switch ( value )
{ {
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCabac: case VideoEncodeH264CapabilityFlagBitsEXT::eCabac: return "Cabac";
return "VkVideoEncodeH264CapabilityCabac"; case VideoEncodeH264CapabilityFlagBitsEXT::eCavlc: return "Cavlc";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCavlc: case VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit: return "WeightedBiPredImplicit";
return "VkVideoEncodeH264CapabilityCavlc"; case VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8: return "Transform8X8";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityWeightedBiPredImplicit: case VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset: return "ChromaQpOffset";
return "VkVideoEncodeH264CapabilityWeightedBiPredImplicit"; case VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset: return "SecondChromaQpOffset";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityTransform8X8: case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled: return "DeblockingFilterDisabled";
return "VkVideoEncodeH264CapabilityTransform8X8"; case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled: return "DeblockingFilterEnabled";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityChromaQpOffset: case VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial: return "DeblockingFilterPartial";
return "VkVideoEncodeH264CapabilityChromaQpOffset"; case VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame: return "MultipleSlicePerFrame";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilitySecondChromaQpOffset: case VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize: return "EvenlyDistributedSliceSize";
return "VkVideoEncodeH264CapabilitySecondChromaQpOffset";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterDisabled:
return "VkVideoEncodeH264CapabilityDeblockingFilterDisabled";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterEnabled:
return "VkVideoEncodeH264CapabilityDeblockingFilterEnabled";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterPartial:
return "VkVideoEncodeH264CapabilityDeblockingFilterPartial";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityMultipleSlicePerFrame:
return "VkVideoEncodeH264CapabilityMultipleSlicePerFrame";
case VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize:
return "VkVideoEncodeH264CapabilityEvenlyDistributedSliceSize";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@ -5950,21 +5933,20 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_decode_h264 === //=== VK_EXT_video_decode_h264 ===
enum class VideoDecodeH264FieldLayoutFlagBitsEXT : VkVideoDecodeH264FieldLayoutFlagsEXT enum class VideoDecodeH264PictureLayoutFlagBitsEXT : VkVideoDecodeH264PictureLayoutFlagsEXT
{ {
eVkVideoDecodeH264ProgressivePicturesOnly = VK_VIDEO_DECODE_H264_PROGRESSIVE_PICTURES_ONLY_EXT, eProgressive = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT,
eLineInterlacedPlane = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_LINE_INTERLACED_PLANE_BIT_EXT, eInterlacedInterleavedLines = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_EXT,
eSeparateInterlacedPlane = VK_VIDEO_DECODE_H264_FIELD_LAYOUT_SEPARATE_INTERLACED_PLANE_BIT_EXT eInterlacedSeparatePlanes = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_EXT
}; };
VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264FieldLayoutFlagBitsEXT value ) VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagBitsEXT value )
{ {
switch ( value ) switch ( value )
{ {
case VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly: case VideoDecodeH264PictureLayoutFlagBitsEXT::eProgressive: return "Progressive";
return "VkVideoDecodeH264ProgressivePicturesOnly"; case VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines: return "InterlacedInterleavedLines";
case VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane: return "LineInterlacedPlane"; case VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes: return "InterlacedSeparatePlanes";
case VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane: return "SeparateInterlacedPlane";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }
@ -11943,51 +11925,51 @@ namespace VULKAN_HPP_NAMESPACE
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
using VideoCapabilitiesFlagsKHR = Flags<VideoCapabilitiesFlagBitsKHR>; using VideoCapabilityFlagsKHR = Flags<VideoCapabilityFlagBitsKHR>;
template <> template <>
struct FlagTraits<VideoCapabilitiesFlagBitsKHR> struct FlagTraits<VideoCapabilityFlagBitsKHR>
{ {
enum : VkFlags enum : VkFlags
{ {
allFlags = VkFlags( VideoCapabilitiesFlagBitsKHR::eProtectedContent ) | allFlags = VkFlags( VideoCapabilityFlagBitsKHR::eProtectedContent ) |
VkFlags( VideoCapabilitiesFlagBitsKHR::eSeparateReferenceImages ) VkFlags( VideoCapabilityFlagBitsKHR::eSeparateReferenceImages )
}; };
}; };
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR
operator|( VideoCapabilitiesFlagBitsKHR bit0, VideoCapabilitiesFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT operator|( VideoCapabilityFlagBitsKHR bit0, VideoCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return VideoCapabilitiesFlagsKHR( bit0 ) | bit1; return VideoCapabilityFlagsKHR( bit0 ) | bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR
operator&( VideoCapabilitiesFlagBitsKHR bit0, VideoCapabilitiesFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT operator&( VideoCapabilityFlagBitsKHR bit0, VideoCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return VideoCapabilitiesFlagsKHR( bit0 ) & bit1; return VideoCapabilityFlagsKHR( bit0 ) & bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR
operator^( VideoCapabilitiesFlagBitsKHR bit0, VideoCapabilitiesFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT operator^( VideoCapabilityFlagBitsKHR bit0, VideoCapabilityFlagBitsKHR bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return VideoCapabilitiesFlagsKHR( bit0 ) ^ bit1; return VideoCapabilityFlagsKHR( bit0 ) ^ bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilitiesFlagsKHR operator~( VideoCapabilitiesFlagBitsKHR bits ) VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoCapabilityFlagsKHR operator~( VideoCapabilityFlagBitsKHR bits )
VULKAN_HPP_NOEXCEPT VULKAN_HPP_NOEXCEPT
{ {
return ~( VideoCapabilitiesFlagsKHR( bits ) ); return ~( VideoCapabilityFlagsKHR( bits ) );
} }
VULKAN_HPP_INLINE std::string to_string( VideoCapabilitiesFlagsKHR value ) VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagsKHR value )
{ {
if ( !value ) if ( !value )
return "{}"; return "{}";
std::string result; std::string result;
if ( value & VideoCapabilitiesFlagBitsKHR::eProtectedContent ) if ( value & VideoCapabilityFlagBitsKHR::eProtectedContent )
result += "ProtectedContent | "; result += "ProtectedContent | ";
if ( value & VideoCapabilitiesFlagBitsKHR::eSeparateReferenceImages ) if ( value & VideoCapabilityFlagBitsKHR::eSeparateReferenceImages )
result += "SeparateReferenceImages | "; result += "SeparateReferenceImages | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@ -12215,80 +12197,79 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_encode_h264 === //=== VK_EXT_video_encode_h264 ===
using VideoEncodeH264CapabilitiesFlagsEXT = Flags<VideoEncodeH264CapabilitiesFlagBitsEXT>; using VideoEncodeH264CapabilityFlagsEXT = Flags<VideoEncodeH264CapabilityFlagBitsEXT>;
template <> template <>
struct FlagTraits<VideoEncodeH264CapabilitiesFlagBitsEXT> struct FlagTraits<VideoEncodeH264CapabilityFlagBitsEXT>
{ {
enum : VkFlags enum : VkFlags
{ {
allFlags = allFlags = VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCabac ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCabac ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eCavlc ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCavlc ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityWeightedBiPredImplicit ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityTransform8X8 ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityChromaQpOffset ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilitySecondChromaQpOffset ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterDisabled ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterEnabled ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterPartial ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame ) |
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityMultipleSlicePerFrame ) | VkFlags( VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize )
VkFlags( VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize )
}; };
}; };
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT operator|( VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT operator|(
VideoEncodeH264CapabilitiesFlagBitsEXT bit0, VideoEncodeH264CapabilitiesFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT VideoEncodeH264CapabilityFlagBitsEXT bit0, VideoEncodeH264CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return VideoEncodeH264CapabilitiesFlagsEXT( bit0 ) | bit1; return VideoEncodeH264CapabilityFlagsEXT( bit0 ) | bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT operator&( VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT operator&(
VideoEncodeH264CapabilitiesFlagBitsEXT bit0, VideoEncodeH264CapabilitiesFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT VideoEncodeH264CapabilityFlagBitsEXT bit0, VideoEncodeH264CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return VideoEncodeH264CapabilitiesFlagsEXT( bit0 ) & bit1; return VideoEncodeH264CapabilityFlagsEXT( bit0 ) & bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT operator^( VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT operator^(
VideoEncodeH264CapabilitiesFlagBitsEXT bit0, VideoEncodeH264CapabilitiesFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT VideoEncodeH264CapabilityFlagBitsEXT bit0, VideoEncodeH264CapabilityFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return VideoEncodeH264CapabilitiesFlagsEXT( bit0 ) ^ bit1; return VideoEncodeH264CapabilityFlagsEXT( bit0 ) ^ bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesFlagsEXT VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilityFlagsEXT
operator~( VideoEncodeH264CapabilitiesFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT operator~( VideoEncodeH264CapabilityFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
{ {
return ~( VideoEncodeH264CapabilitiesFlagsEXT( bits ) ); return ~( VideoEncodeH264CapabilityFlagsEXT( bits ) );
} }
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilitiesFlagsEXT value ) VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagsEXT value )
{ {
if ( !value ) if ( !value )
return "{}"; return "{}";
std::string result; std::string result;
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCabac ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCabac )
result += "VkVideoEncodeH264CapabilityCabac | "; result += "Cabac | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityCavlc ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eCavlc )
result += "VkVideoEncodeH264CapabilityCavlc | "; result += "Cavlc | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityWeightedBiPredImplicit ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eWeightedBiPredImplicit )
result += "VkVideoEncodeH264CapabilityWeightedBiPredImplicit | "; result += "WeightedBiPredImplicit | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityTransform8X8 ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eTransform8X8 )
result += "VkVideoEncodeH264CapabilityTransform8X8 | "; result += "Transform8X8 | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityChromaQpOffset ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eChromaQpOffset )
result += "VkVideoEncodeH264CapabilityChromaQpOffset | "; result += "ChromaQpOffset | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilitySecondChromaQpOffset ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eSecondChromaQpOffset )
result += "VkVideoEncodeH264CapabilitySecondChromaQpOffset | "; result += "SecondChromaQpOffset | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterDisabled ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterDisabled )
result += "VkVideoEncodeH264CapabilityDeblockingFilterDisabled | "; result += "DeblockingFilterDisabled | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterEnabled ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterEnabled )
result += "VkVideoEncodeH264CapabilityDeblockingFilterEnabled | "; result += "DeblockingFilterEnabled | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityDeblockingFilterPartial ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eDeblockingFilterPartial )
result += "VkVideoEncodeH264CapabilityDeblockingFilterPartial | "; result += "DeblockingFilterPartial | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityMultipleSlicePerFrame ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eMultipleSlicePerFrame )
result += "VkVideoEncodeH264CapabilityMultipleSlicePerFrame | "; result += "MultipleSlicePerFrame | ";
if ( value & VideoEncodeH264CapabilitiesFlagBitsEXT::eVkVideoEncodeH264CapabilityEvenlyDistributedSliceSize ) if ( value & VideoEncodeH264CapabilityFlagBitsEXT::eEvenlyDistributedSliceSize )
result += "VkVideoEncodeH264CapabilityEvenlyDistributedSliceSize | "; result += "EvenlyDistributedSliceSize | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }
@ -12447,53 +12428,53 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
//=== VK_EXT_video_decode_h264 === //=== VK_EXT_video_decode_h264 ===
using VideoDecodeH264FieldLayoutFlagsEXT = Flags<VideoDecodeH264FieldLayoutFlagBitsEXT>; using VideoDecodeH264PictureLayoutFlagsEXT = Flags<VideoDecodeH264PictureLayoutFlagBitsEXT>;
template <> template <>
struct FlagTraits<VideoDecodeH264FieldLayoutFlagBitsEXT> struct FlagTraits<VideoDecodeH264PictureLayoutFlagBitsEXT>
{ {
enum : VkFlags enum : VkFlags
{ {
allFlags = VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eVkVideoDecodeH264ProgressivePicturesOnly ) | allFlags = VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eProgressive ) |
VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane ) | VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines ) |
VkFlags( VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane ) VkFlags( VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes )
}; };
}; };
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT operator|( VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT operator|(
VideoDecodeH264FieldLayoutFlagBitsEXT bit0, VideoDecodeH264FieldLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT VideoDecodeH264PictureLayoutFlagBitsEXT bit0, VideoDecodeH264PictureLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return VideoDecodeH264FieldLayoutFlagsEXT( bit0 ) | bit1; return VideoDecodeH264PictureLayoutFlagsEXT( bit0 ) | bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT operator&( VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT operator&(
VideoDecodeH264FieldLayoutFlagBitsEXT bit0, VideoDecodeH264FieldLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT VideoDecodeH264PictureLayoutFlagBitsEXT bit0, VideoDecodeH264PictureLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return VideoDecodeH264FieldLayoutFlagsEXT( bit0 ) & bit1; return VideoDecodeH264PictureLayoutFlagsEXT( bit0 ) & bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT operator^( VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT operator^(
VideoDecodeH264FieldLayoutFlagBitsEXT bit0, VideoDecodeH264FieldLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT VideoDecodeH264PictureLayoutFlagBitsEXT bit0, VideoDecodeH264PictureLayoutFlagBitsEXT bit1 ) VULKAN_HPP_NOEXCEPT
{ {
return VideoDecodeH264FieldLayoutFlagsEXT( bit0 ) ^ bit1; return VideoDecodeH264PictureLayoutFlagsEXT( bit0 ) ^ bit1;
} }
VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264FieldLayoutFlagsEXT VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureLayoutFlagsEXT
operator~( VideoDecodeH264FieldLayoutFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT operator~( VideoDecodeH264PictureLayoutFlagBitsEXT bits ) VULKAN_HPP_NOEXCEPT
{ {
return ~( VideoDecodeH264FieldLayoutFlagsEXT( bits ) ); return ~( VideoDecodeH264PictureLayoutFlagsEXT( bits ) );
} }
VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264FieldLayoutFlagsEXT value ) VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagsEXT value )
{ {
if ( !value ) if ( !value )
return "{}"; return "{}";
std::string result; std::string result;
if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eLineInterlacedPlane ) if ( value & VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedInterleavedLines )
result += "LineInterlacedPlane | "; result += "InterlacedInterleavedLines | ";
if ( value & VideoDecodeH264FieldLayoutFlagBitsEXT::eSeparateInterlacedPlane ) if ( value & VideoDecodeH264PictureLayoutFlagBitsEXT::eInterlacedSeparatePlanes )
result += "SeparateInterlacedPlane | "; result += "InterlacedSeparatePlanes | ";
return "{ " + result.substr( 0, result.size() - 3 ) + " }"; return "{ " + result.substr( 0, result.size() - 3 ) + " }";
} }

92
vulkan/vulkan_structs.hpp
View File

@ -67259,7 +67259,7 @@ namespace VULKAN_HPP_NAMESPACE
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoCapabilitiesKHR; static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoCapabilitiesKHR;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoCapabilitiesFlagsKHR capabilityFlags_ = {}, VULKAN_HPP_CONSTEXPR VideoCapabilitiesKHR( VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR capabilityFlags_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferOffsetAlignment_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferOffsetAlignment_ = {},
VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferSizeAlignment_ = {}, VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferSizeAlignment_ = {},
VULKAN_HPP_NAMESPACE::Extent2D videoPictureExtentGranularity_ = {}, VULKAN_HPP_NAMESPACE::Extent2D videoPictureExtentGranularity_ = {},
@ -67324,16 +67324,16 @@ namespace VULKAN_HPP_NAMESPACE
# endif # endif
public: public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoCapabilitiesKHR; VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoCapabilitiesKHR;
void * pNext = {}; void * pNext = {};
VULKAN_HPP_NAMESPACE::VideoCapabilitiesFlagsKHR capabilityFlags = {}; VULKAN_HPP_NAMESPACE::VideoCapabilityFlagsKHR capabilityFlags = {};
VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferOffsetAlignment = {}; VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferOffsetAlignment = {};
VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferSizeAlignment = {}; VULKAN_HPP_NAMESPACE::DeviceSize minBitstreamBufferSizeAlignment = {};
VULKAN_HPP_NAMESPACE::Extent2D videoPictureExtentGranularity = {}; VULKAN_HPP_NAMESPACE::Extent2D videoPictureExtentGranularity = {};
VULKAN_HPP_NAMESPACE::Extent2D minExtent = {}; VULKAN_HPP_NAMESPACE::Extent2D minExtent = {};
VULKAN_HPP_NAMESPACE::Extent2D maxExtent = {}; VULKAN_HPP_NAMESPACE::Extent2D maxExtent = {};
uint32_t maxReferencePicturesSlotsCount = {}; uint32_t maxReferencePicturesSlotsCount = {};
uint32_t maxReferencePicturesActiveCount = {}; uint32_t maxReferencePicturesActiveCount = {};
}; };
static_assert( sizeof( VideoCapabilitiesKHR ) == sizeof( VkVideoCapabilitiesKHR ), static_assert( sizeof( VideoCapabilitiesKHR ) == sizeof( VkVideoCapabilitiesKHR ),
"struct and wrapper have different size!" ); "struct and wrapper have different size!" );
@ -67805,10 +67805,10 @@ namespace VULKAN_HPP_NAMESPACE
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoDecodeH264ProfileEXT( VULKAN_HPP_CONSTEXPR VideoDecodeH264ProfileEXT(
StdVideoH264ProfileIdc stdProfileIdc_ = {}, StdVideoH264ProfileIdc stdProfileIdc_ = {},
VULKAN_HPP_NAMESPACE::VideoDecodeH264FieldLayoutFlagsEXT fieldLayout_ = {} ) VULKAN_HPP_NOEXCEPT VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT pictureLayout_ = {} ) VULKAN_HPP_NOEXCEPT
: stdProfileIdc( stdProfileIdc_ ) : stdProfileIdc( stdProfileIdc_ )
, fieldLayout( fieldLayout_ ) , pictureLayout( pictureLayout_ )
{} {}
VULKAN_HPP_CONSTEXPR VULKAN_HPP_CONSTEXPR
@ -67842,9 +67842,9 @@ namespace VULKAN_HPP_NAMESPACE
} }
VideoDecodeH264ProfileEXT & VideoDecodeH264ProfileEXT &
setFieldLayout( VULKAN_HPP_NAMESPACE::VideoDecodeH264FieldLayoutFlagsEXT fieldLayout_ ) VULKAN_HPP_NOEXCEPT setPictureLayout( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT pictureLayout_ ) VULKAN_HPP_NOEXCEPT
{ {
fieldLayout = fieldLayout_; pictureLayout = pictureLayout_;
return *this; return *this;
} }
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ # endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
@ -67866,7 +67866,7 @@ namespace VULKAN_HPP_NAMESPACE
{ {
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) &&
( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) &&
( fieldLayout == rhs.fieldLayout ); ( pictureLayout == rhs.pictureLayout );
} }
bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT bool operator!=( VideoDecodeH264ProfileEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
@ -67876,10 +67876,10 @@ namespace VULKAN_HPP_NAMESPACE
# endif # endif
public: public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeH264ProfileEXT; VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoDecodeH264ProfileEXT;
const void * pNext = {}; const void * pNext = {};
StdVideoH264ProfileIdc stdProfileIdc = {}; StdVideoH264ProfileIdc stdProfileIdc = {};
VULKAN_HPP_NAMESPACE::VideoDecodeH264FieldLayoutFlagsEXT fieldLayout = {}; VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureLayoutFlagsEXT pictureLayout = {};
}; };
static_assert( sizeof( VideoDecodeH264ProfileEXT ) == sizeof( VkVideoDecodeH264ProfileEXT ), static_assert( sizeof( VideoDecodeH264ProfileEXT ) == sizeof( VkVideoDecodeH264ProfileEXT ),
"struct and wrapper have different size!" ); "struct and wrapper have different size!" );
@ -69193,17 +69193,17 @@ namespace VULKAN_HPP_NAMESPACE
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) # if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT( VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264CapabilitiesEXT(
VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesFlagsEXT flags_ = {}, VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ = {},
VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags_ = {}, VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags_ = {},
VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags_ = {}, VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags_ = {},
VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs_ = {}, VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs_ = {},
VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs_ = {}, VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs_ = {},
VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment_ = {}, VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment_ = {},
uint8_t maxNumL0ReferenceForP_ = {}, uint8_t maxNumL0ReferenceForP_ = {},
uint8_t maxNumL0ReferenceForB_ = {}, uint8_t maxNumL0ReferenceForB_ = {},
uint8_t maxNumL1Reference_ = {}, uint8_t maxNumL1Reference_ = {},
uint8_t qualityLevelCount_ = {}, uint8_t qualityLevelCount_ = {},
VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion_ = {} ) VULKAN_HPP_NOEXCEPT VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion_ = {} ) VULKAN_HPP_NOEXCEPT
: flags( flags_ ) : flags( flags_ )
, inputModeFlags( inputModeFlags_ ) , inputModeFlags( inputModeFlags_ )
, outputModeFlags( outputModeFlags_ ) , outputModeFlags( outputModeFlags_ )
@ -69242,7 +69242,7 @@ namespace VULKAN_HPP_NAMESPACE
} }
VideoEncodeH264CapabilitiesEXT & VideoEncodeH264CapabilitiesEXT &
setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT setFlags( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT
{ {
flags = flags_; flags = flags_;
return *this; return *this;
@ -69346,19 +69346,19 @@ namespace VULKAN_HPP_NAMESPACE
# endif # endif
public: public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264CapabilitiesEXT; VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH264CapabilitiesEXT;
const void * pNext = {}; const void * pNext = {};
VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesFlagsEXT flags = {}; VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsEXT flags = {};
VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags = {}; VULKAN_HPP_NAMESPACE::VideoEncodeH264InputModeFlagsEXT inputModeFlags = {};
VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags = {}; VULKAN_HPP_NAMESPACE::VideoEncodeH264OutputModeFlagsEXT outputModeFlags = {};
VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs = {}; VULKAN_HPP_NAMESPACE::Extent2D minPictureSizeInMbs = {};
VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs = {}; VULKAN_HPP_NAMESPACE::Extent2D maxPictureSizeInMbs = {};
VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment = {}; VULKAN_HPP_NAMESPACE::Extent2D inputImageDataAlignment = {};
uint8_t maxNumL0ReferenceForP = {}; uint8_t maxNumL0ReferenceForP = {};
uint8_t maxNumL0ReferenceForB = {}; uint8_t maxNumL0ReferenceForB = {};
uint8_t maxNumL1Reference = {}; uint8_t maxNumL1Reference = {};
uint8_t qualityLevelCount = {}; uint8_t qualityLevelCount = {};
VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion = {}; VULKAN_HPP_NAMESPACE::ExtensionProperties stdExtensionVersion = {};
}; };
static_assert( sizeof( VideoEncodeH264CapabilitiesEXT ) == sizeof( VkVideoEncodeH264CapabilitiesEXT ), static_assert( sizeof( VideoEncodeH264CapabilitiesEXT ) == sizeof( VkVideoEncodeH264CapabilitiesEXT ),
"struct and wrapper have different size!" ); "struct and wrapper have different size!" );