mirror/Vulkan-Hpp
1
0
Fork 0
mirror of https://github.com/KhronosGroup/Vulkan-Hpp.git synced 2024-10-14 16:32:17 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge pull request #1194 from KhronosGroup/update-vulkan-headers-pr

Browse Source 
Update Vulkan-Headers to v1.3.205
This commit is contained in:
Andreas Süßenbach 2022-02-07 13:56:40 +01:00 committed by GitHub
commit bc5b7fb5fe
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 147 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Vulkan-Headers

@ -1 +1 @@
Subproject commit 1dace16d8044758d32736eb59802d171970e9448
Subproject commit b32da5329b50e3cb96229aaecba9ded032fe29cc

8
vulkan/vulkan.hpp
View File

@ -119,7 +119,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# include <span>
#endif
static_assert( VK_HEADER_VERSION == 204, "Wrong VK_HEADER_VERSION!" );
static_assert( VK_HEADER_VERSION == 205, "Wrong VK_HEADER_VERSION!" );
// 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
@ -9094,7 +9094,7 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier2KHR>
struct StructExtends<SampleLocationsInfoEXT, ImageMemoryBarrier2>
{
enum
{
@ -10785,7 +10785,7 @@ namespace VULKAN_HPP_NAMESPACE
//=== VK_QCOM_rotated_copy_commands ===
template <>
struct StructExtends<CopyCommandTransformInfoQCOM, BufferImageCopy2KHR>
struct StructExtends<CopyCommandTransformInfoQCOM, BufferImageCopy2>
{
enum
{
@ -10793,7 +10793,7 @@ namespace VULKAN_HPP_NAMESPACE
};
};
template <>
struct StructExtends<CopyCommandTransformInfoQCOM, ImageBlit2KHR>
struct StructExtends<CopyCommandTransformInfoQCOM, ImageBlit2>
{
enum
{

41
vulkan/vulkan_enums.hpp
View File

@ -449,7 +449,7 @@ namespace VULKAN_HPP_NAMESPACE
eVideoEncodeH265SessionParametersAddInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT,
eVideoEncodeH265VclFrameInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT,
eVideoEncodeH265DpbSlotInfoEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT,
eVideoEncodeH265NaluSliceEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_EXT,
eVideoEncodeH265NaluSliceSegmentEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT,
eVideoEncodeH265EmitPictureParametersEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT,
eVideoEncodeH265ProfileEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT,
eVideoEncodeH265ReferenceListsEXT = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT,
@ -1445,7 +1445,7 @@ namespace VULKAN_HPP_NAMESPACE
return "VideoEncodeH265SessionParametersAddInfoEXT";
case StructureType::eVideoEncodeH265VclFrameInfoEXT: return "VideoEncodeH265VclFrameInfoEXT";
case StructureType::eVideoEncodeH265DpbSlotInfoEXT: return "VideoEncodeH265DpbSlotInfoEXT";
case StructureType::eVideoEncodeH265NaluSliceEXT: return "VideoEncodeH265NaluSliceEXT";
case StructureType::eVideoEncodeH265NaluSliceSegmentEXT: return "VideoEncodeH265NaluSliceSegmentEXT";
case StructureType::eVideoEncodeH265EmitPictureParametersEXT: return "VideoEncodeH265EmitPictureParametersEXT";
case StructureType::eVideoEncodeH265ProfileEXT: return "VideoEncodeH265ProfileEXT";
case StructureType::eVideoEncodeH265ReferenceListsEXT: return "VideoEncodeH265ReferenceListsEXT";
@ -3186,6 +3186,7 @@ namespace VULKAN_HPP_NAMESPACE
ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT,
ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT,
ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT,
eNone = VK_IMAGE_ASPECT_NONE,
eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT,
eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT,
eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT,
@ -3207,11 +3208,11 @@ namespace VULKAN_HPP_NAMESPACE
case ImageAspectFlagBits::ePlane0: return "Plane0";
case ImageAspectFlagBits::ePlane1: return "Plane1";
case ImageAspectFlagBits::ePlane2: return "Plane2";
case ImageAspectFlagBits::eNone: return "None";
case ImageAspectFlagBits::eMemoryPlane0EXT: return "MemoryPlane0EXT";
case ImageAspectFlagBits::eMemoryPlane1EXT: return "MemoryPlane1EXT";
case ImageAspectFlagBits::eMemoryPlane2EXT: return "MemoryPlane2EXT";
case ImageAspectFlagBits::eMemoryPlane3EXT: return "MemoryPlane3EXT";
case ImageAspectFlagBits::eNoneKHR: return "NoneKHR";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
}
@ -6620,9 +6621,9 @@ namespace VULKAN_HPP_NAMESPACE
enum class VideoEncodeH265InputModeFlagBitsEXT : VkVideoEncodeH265InputModeFlagsEXT
{
eFrame = VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT,
eSlice = VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_BIT_EXT,
eNonVcl = VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT
eFrame = VK_VIDEO_ENCODE_H265_INPUT_MODE_FRAME_BIT_EXT,
eSliceSegment = VK_VIDEO_ENCODE_H265_INPUT_MODE_SLICE_SEGMENT_BIT_EXT,
eNonVcl = VK_VIDEO_ENCODE_H265_INPUT_MODE_NON_VCL_BIT_EXT
};
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265InputModeFlagBitsEXT value )
@ -6630,7 +6631,7 @@ namespace VULKAN_HPP_NAMESPACE
switch ( value )
{
case VideoEncodeH265InputModeFlagBitsEXT::eFrame: return "Frame";
case VideoEncodeH265InputModeFlagBitsEXT::eSlice: return "Slice";
case VideoEncodeH265InputModeFlagBitsEXT::eSliceSegment: return "SliceSegment";
case VideoEncodeH265InputModeFlagBitsEXT::eNonVcl: return "NonVcl";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
@ -6638,9 +6639,9 @@ namespace VULKAN_HPP_NAMESPACE
enum class VideoEncodeH265OutputModeFlagBitsEXT : VkVideoEncodeH265OutputModeFlagsEXT
{
eFrame = VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT,
eSlice = VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_BIT_EXT,
eNonVcl = VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT
eFrame = VK_VIDEO_ENCODE_H265_OUTPUT_MODE_FRAME_BIT_EXT,
eSliceSegment = VK_VIDEO_ENCODE_H265_OUTPUT_MODE_SLICE_SEGMENT_BIT_EXT,
eNonVcl = VK_VIDEO_ENCODE_H265_OUTPUT_MODE_NON_VCL_BIT_EXT
};
VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265OutputModeFlagBitsEXT value )
@ -6648,7 +6649,7 @@ namespace VULKAN_HPP_NAMESPACE
switch ( value )
{
case VideoEncodeH265OutputModeFlagBitsEXT::eFrame: return "Frame";
case VideoEncodeH265OutputModeFlagBitsEXT::eSlice: return "Slice";
case VideoEncodeH265OutputModeFlagBitsEXT::eSliceSegment: return "SliceSegment";
case VideoEncodeH265OutputModeFlagBitsEXT::eNonVcl: return "NonVcl";
default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast<uint32_t>( value ) ) + " )";
}
@ -12563,9 +12564,9 @@ namespace VULKAN_HPP_NAMESPACE
allFlags = VkFlags( ImageAspectFlagBits::eColor ) | VkFlags( ImageAspectFlagBits::eDepth ) |
VkFlags( ImageAspectFlagBits::eStencil ) | VkFlags( ImageAspectFlagBits::eMetadata ) |
VkFlags( ImageAspectFlagBits::ePlane0 ) | VkFlags( ImageAspectFlagBits::ePlane1 ) |
VkFlags( ImageAspectFlagBits::ePlane2 ) | VkFlags( ImageAspectFlagBits::eMemoryPlane0EXT ) |
VkFlags( ImageAspectFlagBits::eMemoryPlane1EXT ) | VkFlags( ImageAspectFlagBits::eMemoryPlane2EXT ) |
VkFlags( ImageAspectFlagBits::eMemoryPlane3EXT ) | VkFlags( ImageAspectFlagBits::eNoneKHR )
VkFlags( ImageAspectFlagBits::ePlane2 ) | VkFlags( ImageAspectFlagBits::eNone ) |
VkFlags( ImageAspectFlagBits::eMemoryPlane0EXT ) | VkFlags( ImageAspectFlagBits::eMemoryPlane1EXT ) |
VkFlags( ImageAspectFlagBits::eMemoryPlane2EXT ) | VkFlags( ImageAspectFlagBits::eMemoryPlane3EXT )
};
};
@ -17261,7 +17262,7 @@ namespace VULKAN_HPP_NAMESPACE
enum : VkFlags
{
allFlags = VkFlags( VideoEncodeH265InputModeFlagBitsEXT::eFrame ) |
VkFlags( VideoEncodeH265InputModeFlagBitsEXT::eSlice ) |
VkFlags( VideoEncodeH265InputModeFlagBitsEXT::eSliceSegment ) |
VkFlags( VideoEncodeH265InputModeFlagBitsEXT::eNonVcl )
};
};
@ -17298,8 +17299,8 @@ namespace VULKAN_HPP_NAMESPACE
std::string result;
if ( value & VideoEncodeH265InputModeFlagBitsEXT::eFrame )
result += "Frame | ";
if ( value & VideoEncodeH265InputModeFlagBitsEXT::eSlice )
result += "Slice | ";
if ( value & VideoEncodeH265InputModeFlagBitsEXT::eSliceSegment )
result += "SliceSegment | ";
if ( value & VideoEncodeH265InputModeFlagBitsEXT::eNonVcl )
result += "NonVcl | ";
@ -17314,7 +17315,7 @@ namespace VULKAN_HPP_NAMESPACE
enum : VkFlags
{
allFlags = VkFlags( VideoEncodeH265OutputModeFlagBitsEXT::eFrame ) |
VkFlags( VideoEncodeH265OutputModeFlagBitsEXT::eSlice ) |
VkFlags( VideoEncodeH265OutputModeFlagBitsEXT::eSliceSegment ) |
VkFlags( VideoEncodeH265OutputModeFlagBitsEXT::eNonVcl )
};
};
@ -17351,8 +17352,8 @@ namespace VULKAN_HPP_NAMESPACE
std::string result;
if ( value & VideoEncodeH265OutputModeFlagBitsEXT::eFrame )
result += "Frame | ";
if ( value & VideoEncodeH265OutputModeFlagBitsEXT::eSlice )
result += "Slice | ";
if ( value & VideoEncodeH265OutputModeFlagBitsEXT::eSliceSegment )
result += "SliceSegment | ";
if ( value & VideoEncodeH265OutputModeFlagBitsEXT::eNonVcl )
result += "NonVcl | ";

2
vulkan/vulkan_handles.hpp
View File

@ -602,7 +602,7 @@ namespace VULKAN_HPP_NAMESPACE
struct VideoEncodeH265VclFrameInfoEXT;
struct VideoEncodeH265EmitPictureParametersEXT;
struct VideoEncodeH265DpbSlotInfoEXT;
struct VideoEncodeH265NaluSliceEXT;
struct VideoEncodeH265NaluSliceSegmentEXT;
struct VideoEncodeH265ProfileEXT;
struct VideoEncodeH265ReferenceListsEXT;
struct VideoEncodeH265RateControlInfoEXT;

20
vulkan/vulkan_hash.hpp
View File

@ -12646,17 +12646,17 @@ namespace std
# if defined( VK_ENABLE_BETA_EXTENSIONS )
template <>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT>
{
std::size_t operator()(
VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT const & videoEncodeH265NaluSliceEXT ) const VULKAN_HPP_NOEXCEPT
std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT const &
videoEncodeH265NaluSliceSegmentEXT ) const VULKAN_HPP_NOEXCEPT
{
std::size_t seed = 0;
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceEXT.ctbCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceEXT.pReferenceFinalLists );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceEXT.pSliceHeaderStd );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentEXT.ctbCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentEXT.pReferenceFinalLists );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentEXT.pSliceSegmentHeaderStd );
return seed;
}
};
@ -12807,8 +12807,8 @@ namespace std
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.sType );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pNext );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pReferenceFinalLists );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.naluSliceEntryCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pNaluSliceEntries );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.naluSliceSegmentEntryCount );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pNaluSliceSegmentEntries );
VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265VclFrameInfoEXT.pCurrentPictureInfo );
return seed;
}

186
vulkan/vulkan_structs.hpp
View File

@ -36614,7 +36614,24 @@ namespace VULKAN_HPP_NAMESPACE
ImageFormatConstraintsInfoFUCHSIA( VkImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT
: ImageFormatConstraintsInfoFUCHSIA( *reinterpret_cast<ImageFormatConstraintsInfoFUCHSIA const *>( &rhs ) )
{}
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
ImageFormatConstraintsInfoFUCHSIA(
VULKAN_HPP_NAMESPACE::ImageCreateInfo imageCreateInfo_,
VULKAN_HPP_NAMESPACE::FormatFeatureFlags requiredFormatFeatures_,
VULKAN_HPP_NAMESPACE::ImageFormatConstraintsFlagsFUCHSIA flags_,
uint64_t sysmemPixelFormat_,
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA> const &
colorSpaces_ )
: imageCreateInfo( imageCreateInfo_ )
, requiredFormatFeatures( requiredFormatFeatures_ )
, flags( flags_ )
, sysmemPixelFormat( sysmemPixelFormat_ )
, colorSpaceCount( static_cast<uint32_t>( colorSpaces_.size() ) )
, pColorSpaces( colorSpaces_.data() )
{}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
ImageFormatConstraintsInfoFUCHSIA &
operator=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default;
@ -36673,7 +36690,18 @@ namespace VULKAN_HPP_NAMESPACE
pColorSpaces = pColorSpaces_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
ImageFormatConstraintsInfoFUCHSIA & setColorSpaces(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA> const &
colorSpaces_ ) VULKAN_HPP_NOEXCEPT
{
colorSpaceCount = static_cast<uint32_t>( colorSpaces_.size() );
pColorSpaces = colorSpaces_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
explicit operator VkImageFormatConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT
{
@ -61198,7 +61226,7 @@ namespace VULKAN_HPP_NAMESPACE
#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM &
setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
@ -61244,7 +61272,7 @@ namespace VULKAN_HPP_NAMESPACE
auto
# else
std::tuple<VULKAN_HPP_NAMESPACE::StructureType const &,
const void * const &,
void * const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &,
VULKAN_HPP_NAMESPACE::Bool32 const &>
@ -61283,7 +61311,7 @@ namespace VULKAN_HPP_NAMESPACE
public:
VULKAN_HPP_NAMESPACE::StructureType sType =
StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;
const void * pNext = {};
void * pNext = {};
VULKAN_HPP_NAMESPACE::Bool32 rasterizationOrderColorAttachmentAccess = {};
VULKAN_HPP_NAMESPACE::Bool32 rasterizationOrderDepthAttachmentAccess = {};
VULKAN_HPP_NAMESPACE::Bool32 rasterizationOrderStencilAttachmentAccess = {};
@ -97538,75 +97566,78 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
#if defined( VK_ENABLE_BETA_EXTENSIONS )
struct VideoEncodeH265NaluSliceEXT
struct VideoEncodeH265NaluSliceSegmentEXT
{
using NativeType = VkVideoEncodeH265NaluSliceEXT;
using NativeType = VkVideoEncodeH265NaluSliceSegmentEXT;
static const bool allowDuplicate = false;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265NaluSliceEXT;
static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType =
StructureType::eVideoEncodeH265NaluSliceSegmentEXT;
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceEXT(
uint32_t ctbCount_ = {},
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists_ = {},
const StdVideoEncodeH265SliceHeader * pSliceHeaderStd_ = {} ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentEXT(
uint32_t ctbCount_ = {},
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists_ = {},
const StdVideoEncodeH265SliceSegmentHeader * pSliceSegmentHeaderStd_ = {} ) VULKAN_HPP_NOEXCEPT
: ctbCount( ctbCount_ )
, pReferenceFinalLists( pReferenceFinalLists_ )
, pSliceHeaderStd( pSliceHeaderStd_ )
, pSliceSegmentHeaderStd( pSliceSegmentHeaderStd_ )
{}
VULKAN_HPP_CONSTEXPR
VideoEncodeH265NaluSliceEXT( VideoEncodeH265NaluSliceEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentEXT( VideoEncodeH265NaluSliceSegmentEXT const & rhs )
VULKAN_HPP_NOEXCEPT = default;
VideoEncodeH265NaluSliceEXT( VkVideoEncodeH265NaluSliceEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: VideoEncodeH265NaluSliceEXT( *reinterpret_cast<VideoEncodeH265NaluSliceEXT const *>( &rhs ) )
VideoEncodeH265NaluSliceSegmentEXT( VkVideoEncodeH265NaluSliceSegmentEXT const & rhs ) VULKAN_HPP_NOEXCEPT
: VideoEncodeH265NaluSliceSegmentEXT( *reinterpret_cast<VideoEncodeH265NaluSliceSegmentEXT const *>( &rhs ) )
{}
# endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/
VideoEncodeH265NaluSliceEXT & operator=( VideoEncodeH265NaluSliceEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VideoEncodeH265NaluSliceSegmentEXT &
operator=( VideoEncodeH265NaluSliceSegmentEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default;
VideoEncodeH265NaluSliceEXT & operator=( VkVideoEncodeH265NaluSliceEXT const & rhs ) VULKAN_HPP_NOEXCEPT
VideoEncodeH265NaluSliceSegmentEXT &
operator=( VkVideoEncodeH265NaluSliceSegmentEXT const & rhs ) VULKAN_HPP_NOEXCEPT
{
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT const *>( &rhs );
*this = *reinterpret_cast<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT const *>( &rhs );
return *this;
}
# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS )
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT
{
pNext = pNext_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceEXT & setCtbCount( uint32_t ctbCount_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentEXT & setCtbCount( uint32_t ctbCount_ ) VULKAN_HPP_NOEXCEPT
{
ctbCount = ctbCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceEXT & setPReferenceFinalLists(
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentEXT & setPReferenceFinalLists(
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists_ ) VULKAN_HPP_NOEXCEPT
{
pReferenceFinalLists = pReferenceFinalLists_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceEXT &
setPSliceHeaderStd( const StdVideoEncodeH265SliceHeader * pSliceHeaderStd_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentEXT & setPSliceSegmentHeaderStd(
const StdVideoEncodeH265SliceSegmentHeader * pSliceSegmentHeaderStd_ ) VULKAN_HPP_NOEXCEPT
{
pSliceHeaderStd = pSliceHeaderStd_;
pSliceSegmentHeaderStd = pSliceSegmentHeaderStd_;
return *this;
}
# endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/
explicit operator VkVideoEncodeH265NaluSliceEXT const &() const VULKAN_HPP_NOEXCEPT
explicit operator VkVideoEncodeH265NaluSliceSegmentEXT const &() const VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<const VkVideoEncodeH265NaluSliceEXT *>( this );
return *reinterpret_cast<const VkVideoEncodeH265NaluSliceSegmentEXT *>( this );
}
explicit operator VkVideoEncodeH265NaluSliceEXT &() VULKAN_HPP_NOEXCEPT
explicit operator VkVideoEncodeH265NaluSliceSegmentEXT &() VULKAN_HPP_NOEXCEPT
{
return *reinterpret_cast<VkVideoEncodeH265NaluSliceEXT *>( this );
return *reinterpret_cast<VkVideoEncodeH265NaluSliceSegmentEXT *>( this );
}
# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
@ -97617,53 +97648,54 @@ namespace VULKAN_HPP_NAMESPACE
const void * const &,
uint32_t const &,
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * const &,
const StdVideoEncodeH265SliceHeader * const &>
const StdVideoEncodeH265SliceSegmentHeader * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie( sType, pNext, ctbCount, pReferenceFinalLists, pSliceHeaderStd );
return std::tie( sType, pNext, ctbCount, pReferenceFinalLists, pSliceSegmentHeaderStd );
}
# endif
# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR )
auto operator<=>( VideoEncodeH265NaluSliceEXT const & ) const = default;
auto operator<=>( VideoEncodeH265NaluSliceSegmentEXT const & ) const = default;
# else
bool operator==( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator==( VideoEncodeH265NaluSliceSegmentEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
# if !defined( __GNUC__ ) || ( 70500 < GCC_VERSION )
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ctbCount == rhs.ctbCount ) &&
( pReferenceFinalLists == rhs.pReferenceFinalLists ) && ( pSliceHeaderStd == rhs.pSliceHeaderStd );
( pReferenceFinalLists == rhs.pReferenceFinalLists ) &&
( pSliceSegmentHeaderStd == rhs.pSliceSegmentHeaderStd );
# endif
}
bool operator!=( VideoEncodeH265NaluSliceEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
bool operator!=( VideoEncodeH265NaluSliceSegmentEXT const & rhs ) const VULKAN_HPP_NOEXCEPT
{
return !operator==( rhs );
}
# endif
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265NaluSliceEXT;
const void * pNext = {};
uint32_t ctbCount = {};
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists = {};
const StdVideoEncodeH265SliceHeader * pSliceHeaderStd = {};
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265NaluSliceSegmentEXT;
const void * pNext = {};
uint32_t ctbCount = {};
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists = {};
const StdVideoEncodeH265SliceSegmentHeader * pSliceSegmentHeaderStd = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT ) ==
sizeof( VkVideoEncodeH265NaluSliceEXT ),
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT ) ==
sizeof( VkVideoEncodeH265NaluSliceSegmentEXT ),
"struct and wrapper have different size!" );
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT>::value,
VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT>::value,
"struct wrapper is not a standard layout!" );
VULKAN_HPP_STATIC_ASSERT(
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT>::value,
"VideoEncodeH265NaluSliceEXT is not nothrow_move_constructible!" );
std::is_nothrow_move_constructible<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT>::value,
"VideoEncodeH265NaluSliceSegmentEXT is not nothrow_move_constructible!" );
template <>
struct CppType<StructureType, StructureType::eVideoEncodeH265NaluSliceEXT>
struct CppType<StructureType, StructureType::eVideoEncodeH265NaluSliceSegmentEXT>
{
using Type = VideoEncodeH265NaluSliceEXT;
using Type = VideoEncodeH265NaluSliceSegmentEXT;
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/
@ -98755,13 +98787,13 @@ namespace VULKAN_HPP_NAMESPACE
# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS )
VULKAN_HPP_CONSTEXPR VideoEncodeH265VclFrameInfoEXT(
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists_ = {},
uint32_t naluSliceEntryCount_ = {},
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT * pNaluSliceEntries_ = {},
const StdVideoEncodeH265PictureInfo * pCurrentPictureInfo_ = {} ) VULKAN_HPP_NOEXCEPT
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists_ = {},
uint32_t naluSliceSegmentEntryCount_ = {},
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT * pNaluSliceSegmentEntries_ = {},
const StdVideoEncodeH265PictureInfo * pCurrentPictureInfo_ = {} ) VULKAN_HPP_NOEXCEPT
: pReferenceFinalLists( pReferenceFinalLists_ )
, naluSliceEntryCount( naluSliceEntryCount_ )
, pNaluSliceEntries( pNaluSliceEntries_ )
, naluSliceSegmentEntryCount( naluSliceSegmentEntryCount_ )
, pNaluSliceSegmentEntries( pNaluSliceSegmentEntries_ )
, pCurrentPictureInfo( pCurrentPictureInfo_ )
{}
@ -98775,12 +98807,12 @@ namespace VULKAN_HPP_NAMESPACE
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
VideoEncodeH265VclFrameInfoEXT(
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists_,
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT> const &
naluSliceEntries_,
const StdVideoEncodeH265PictureInfo * pCurrentPictureInfo_ = {} )
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT> const & naluSliceSegmentEntries_,
const StdVideoEncodeH265PictureInfo * pCurrentPictureInfo_ = {} )
: pReferenceFinalLists( pReferenceFinalLists_ )
, naluSliceEntryCount( static_cast<uint32_t>( naluSliceEntries_.size() ) )
, pNaluSliceEntries( naluSliceEntries_.data() )
, naluSliceSegmentEntryCount( static_cast<uint32_t>( naluSliceSegmentEntries_.size() ) )
, pNaluSliceSegmentEntries( naluSliceSegmentEntries_.data() )
, pCurrentPictureInfo( pCurrentPictureInfo_ )
{}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -98810,26 +98842,27 @@ namespace VULKAN_HPP_NAMESPACE
}
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT &
setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) VULKAN_HPP_NOEXCEPT
setNaluSliceSegmentEntryCount( uint32_t naluSliceSegmentEntryCount_ ) VULKAN_HPP_NOEXCEPT
{
naluSliceEntryCount = naluSliceEntryCount_;
naluSliceSegmentEntryCount = naluSliceSegmentEntryCount_;
return *this;
}
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & setPNaluSliceEntries(
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT * pNaluSliceEntries_ ) VULKAN_HPP_NOEXCEPT
VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265VclFrameInfoEXT & setPNaluSliceSegmentEntries(
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT * pNaluSliceSegmentEntries_ ) VULKAN_HPP_NOEXCEPT
{
pNaluSliceEntries = pNaluSliceEntries_;
pNaluSliceSegmentEntries = pNaluSliceSegmentEntries_;
return *this;
}
# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE )
VideoEncodeH265VclFrameInfoEXT & setNaluSliceEntries(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT> const &
naluSliceEntries_ ) VULKAN_HPP_NOEXCEPT
VideoEncodeH265VclFrameInfoEXT & setNaluSliceSegmentEntries(
VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries<
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT> const & naluSliceSegmentEntries_ )
VULKAN_HPP_NOEXCEPT
{
naluSliceEntryCount = static_cast<uint32_t>( naluSliceEntries_.size() );
pNaluSliceEntries = naluSliceEntries_.data();
naluSliceSegmentEntryCount = static_cast<uint32_t>( naluSliceSegmentEntries_.size() );
pNaluSliceSegmentEntries = naluSliceSegmentEntries_.data();
return *this;
}
# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -98860,13 +98893,13 @@ namespace VULKAN_HPP_NAMESPACE
const void * const &,
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * const &,
uint32_t const &,
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT * const &,
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT * const &,
const StdVideoEncodeH265PictureInfo * const &>
# endif
reflect() const VULKAN_HPP_NOEXCEPT
{
return std::tie(
sType, pNext, pReferenceFinalLists, naluSliceEntryCount, pNaluSliceEntries, pCurrentPictureInfo );
sType, pNext, pReferenceFinalLists, naluSliceSegmentEntryCount, pNaluSliceSegmentEntries, pCurrentPictureInfo );
}
# endif
@ -98879,7 +98912,8 @@ namespace VULKAN_HPP_NAMESPACE
return this->reflect() == rhs.reflect();
# else
return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pReferenceFinalLists == rhs.pReferenceFinalLists ) &&
( naluSliceEntryCount == rhs.naluSliceEntryCount ) && ( pNaluSliceEntries == rhs.pNaluSliceEntries ) &&
( naluSliceSegmentEntryCount == rhs.naluSliceSegmentEntryCount ) &&
( pNaluSliceSegmentEntries == rhs.pNaluSliceSegmentEntries ) &&
( pCurrentPictureInfo == rhs.pCurrentPictureInfo );
# endif
}
@ -98893,10 +98927,10 @@ namespace VULKAN_HPP_NAMESPACE
public:
VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eVideoEncodeH265VclFrameInfoEXT;
const void * pNext = {};
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists = {};
uint32_t naluSliceEntryCount = {};
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceEXT * pNaluSliceEntries = {};
const StdVideoEncodeH265PictureInfo * pCurrentPictureInfo = {};
const VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT * pReferenceFinalLists = {};
uint32_t naluSliceSegmentEntryCount = {};
const VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT * pNaluSliceSegmentEntries = {};
const StdVideoEncodeH265PictureInfo * pCurrentPictureInfo = {};
};
VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT ) ==
sizeof( VkVideoEncodeH265VclFrameInfoEXT ),