BeeEngine/vulkan-headers
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update for Vulkan-Docs 1.4.323

Browse source
This commit is contained in:
Jon Leech 2025-07-18 12:10:59 +01:00 • committed by Jon Leech
parent 00a752019b
commit 088a00d81d
20 changed files with 5592 additions and 6971 deletions
Download patch file Download diff file Expand all files Collapse all files

42
include/vk_video/vulkan_video_codec_av1std.h
View file

@ -22,27 +22,27 @@ extern "C" {
// vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls. // vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls.
#define vulkan_video_codec_av1std 1 #define vulkan_video_codec_av1std 1
#include "vulkan_video_codecs_common.h" #include "vulkan_video_codecs_common.h"
#define STD_VIDEO_AV1_NUM_REF_FRAMES 8 #define STD_VIDEO_AV1_NUM_REF_FRAMES 8U
#define STD_VIDEO_AV1_REFS_PER_FRAME 7 #define STD_VIDEO_AV1_REFS_PER_FRAME 7U
#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8 #define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8U
#define STD_VIDEO_AV1_MAX_TILE_COLS 64 #define STD_VIDEO_AV1_MAX_TILE_COLS 64U
#define STD_VIDEO_AV1_MAX_TILE_ROWS 64 #define STD_VIDEO_AV1_MAX_TILE_ROWS 64U
#define STD_VIDEO_AV1_MAX_SEGMENTS 8 #define STD_VIDEO_AV1_MAX_SEGMENTS 8U
#define STD_VIDEO_AV1_SEG_LVL_MAX 8 #define STD_VIDEO_AV1_SEG_LVL_MAX 8U
#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7 #define STD_VIDEO_AV1_PRIMARY_REF_NONE 7U
#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2 #define STD_VIDEO_AV1_SELECT_INTEGER_MV 2U
#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2 #define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2U
#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2 #define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2U
#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4 #define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4U
#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2 #define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2U
#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8 #define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8U
#define STD_VIDEO_AV1_MAX_NUM_PLANES 3 #define STD_VIDEO_AV1_MAX_NUM_PLANES 3U
#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6 #define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6U
#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14 #define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14U
#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10 #define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10U
#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10 #define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10U
#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24 #define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24U
#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25 #define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25U
typedef enum StdVideoAV1Profile { typedef enum StdVideoAV1Profile {
STD_VIDEO_AV1_PROFILE_MAIN = 0, STD_VIDEO_AV1_PROFILE_MAIN = 0,

16
include/vk_video/vulkan_video_codec_h264std.h
View file

@ -22,14 +22,14 @@ extern "C" {
// vulkan_video_codec_h264std is a preprocessor guard. Do not pass it to API calls. // vulkan_video_codec_h264std is a preprocessor guard. Do not pass it to API calls.
#define vulkan_video_codec_h264std 1 #define vulkan_video_codec_h264std 1
#include "vulkan_video_codecs_common.h" #include "vulkan_video_codecs_common.h"
#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32 #define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32U
#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6U
#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16 #define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16U
#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6 #define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6U
#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64 #define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64U
#define STD_VIDEO_H264_MAX_NUM_LIST_REF 32 #define STD_VIDEO_H264_MAX_NUM_LIST_REF 32U
#define STD_VIDEO_H264_MAX_CHROMA_PLANES 2 #define STD_VIDEO_H264_MAX_CHROMA_PLANES 2U
#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFF #define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFFU
typedef enum StdVideoH264ChromaFormatIdc { typedef enum StdVideoH264ChromaFormatIdc {
STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0,

2
include/vk_video/vulkan_video_codec_h264std_decode.h
View file

@ -27,7 +27,7 @@ extern "C" {
#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 #define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0
#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode" #define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode"
#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2 #define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2U
typedef enum StdVideoDecodeH264FieldOrderCount { typedef enum StdVideoDecodeH264FieldOrderCount {
STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0,

46
include/vk_video/vulkan_video_codec_h265std.h
View file

@ -22,29 +22,29 @@ extern "C" {
// vulkan_video_codec_h265std is a preprocessor guard. Do not pass it to API calls. // vulkan_video_codec_h265std is a preprocessor guard. Do not pass it to API calls.
#define vulkan_video_codec_h265std 1 #define vulkan_video_codec_h265std 1
#include "vulkan_video_codecs_common.h" #include "vulkan_video_codecs_common.h"
#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32 #define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32U
#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7 #define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7U
#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6 #define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6U
#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16 #define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16U
#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6 #define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6U
#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64 #define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64U
#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6 #define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6U
#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64 #define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64U
#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2 #define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2U
#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64 #define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64U
#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6 #define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6U
#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19 #define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19U
#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21 #define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21U
#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3 #define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3U
#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128 #define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128U
#define STD_VIDEO_H265_MAX_NUM_LIST_REF 15 #define STD_VIDEO_H265_MAX_NUM_LIST_REF 15U
#define STD_VIDEO_H265_MAX_CHROMA_PLANES 2 #define STD_VIDEO_H265_MAX_CHROMA_PLANES 2U
#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64 #define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64U
#define STD_VIDEO_H265_MAX_DPB_SIZE 16 #define STD_VIDEO_H265_MAX_DPB_SIZE 16U
#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32 #define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32U
#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16 #define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16U
#define STD_VIDEO_H265_MAX_DELTA_POC 48 #define STD_VIDEO_H265_MAX_DELTA_POC 48U
#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFF #define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFFU
typedef enum StdVideoH265ChromaFormatIdc { typedef enum StdVideoH265ChromaFormatIdc {
STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0,

2
include/vk_video/vulkan_video_codec_h265std_decode.h
View file

@ -27,7 +27,7 @@ extern "C" {
#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0
#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode" #define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode"
#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8 #define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8U
typedef struct StdVideoDecodeH265PictureInfoFlags { typedef struct StdVideoDecodeH265PictureInfoFlags {
uint32_t IrapPicFlag : 1; uint32_t IrapPicFlag : 1;
uint32_t IdrPicFlag : 1; uint32_t IdrPicFlag : 1;

16
include/vk_video/vulkan_video_codec_vp9std.h
View file

@ -22,14 +22,14 @@ extern "C" {
// vulkan_video_codec_vp9std is a preprocessor guard. Do not pass it to API calls. // vulkan_video_codec_vp9std is a preprocessor guard. Do not pass it to API calls.
#define vulkan_video_codec_vp9std 1 #define vulkan_video_codec_vp9std 1
#include "vulkan_video_codecs_common.h" #include "vulkan_video_codecs_common.h"
#define STD_VIDEO_VP9_NUM_REF_FRAMES 8 #define STD_VIDEO_VP9_NUM_REF_FRAMES 8U
#define STD_VIDEO_VP9_REFS_PER_FRAME 3 #define STD_VIDEO_VP9_REFS_PER_FRAME 3U
#define STD_VIDEO_VP9_MAX_REF_FRAMES 4 #define STD_VIDEO_VP9_MAX_REF_FRAMES 4U
#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2 #define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2U
#define STD_VIDEO_VP9_MAX_SEGMENTS 8 #define STD_VIDEO_VP9_MAX_SEGMENTS 8U
#define STD_VIDEO_VP9_SEG_LVL_MAX 4 #define STD_VIDEO_VP9_SEG_LVL_MAX 4U
#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7 #define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7U
#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3 #define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3U
typedef enum StdVideoVP9Profile { typedef enum StdVideoVP9Profile {
STD_VIDEO_VP9_PROFILE_0 = 0, STD_VIDEO_VP9_PROFILE_0 = 0,

2
include/vulkan/vulkan.cppm
View file

@ -1046,7 +1046,7 @@ export namespace VULKAN_HPP_NAMESPACE
using VULKAN_HPP_NAMESPACE::SystemError; using VULKAN_HPP_NAMESPACE::SystemError;
using VULKAN_HPP_NAMESPACE::TooManyObjectsError; using VULKAN_HPP_NAMESPACE::TooManyObjectsError;
using VULKAN_HPP_NAMESPACE::UnknownError; using VULKAN_HPP_NAMESPACE::UnknownError;
using VULKAN_HPP_NAMESPACE::ValidationFailedEXTError; using VULKAN_HPP_NAMESPACE::ValidationFailedError;
using VULKAN_HPP_NAMESPACE::VideoPictureLayoutNotSupportedKHRError; using VULKAN_HPP_NAMESPACE::VideoPictureLayoutNotSupportedKHRError;
using VULKAN_HPP_NAMESPACE::VideoProfileCodecNotSupportedKHRError; using VULKAN_HPP_NAMESPACE::VideoProfileCodecNotSupportedKHRError;
using VULKAN_HPP_NAMESPACE::VideoProfileFormatNotSupportedKHRError; using VULKAN_HPP_NAMESPACE::VideoProfileFormatNotSupportedKHRError;

20
include/vulkan/vulkan.hpp
View file

@ -56,7 +56,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h
# endif # endif
#endif #endif
static_assert( VK_HEADER_VERSION == 322, "Wrong VK_HEADER_VERSION!" ); static_assert( VK_HEADER_VERSION == 323, "Wrong VK_HEADER_VERSION!" );
// <tuple> includes <sys/sysmacros.h> through some other header // <tuple> includes <sys/sysmacros.h> through some other header
// this results in major(x) being resolved to gnu_dev_major(x) // this results in major(x) being resolved to gnu_dev_major(x)
@ -6959,6 +6959,14 @@ namespace VULKAN_HPP_NAMESPACE
UnknownError( char const * message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {} UnknownError( char const * message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {}
}; };
class ValidationFailedError : public SystemError
{
public:
ValidationFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {}
ValidationFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {}
};
class OutOfPoolMemoryError : public SystemError class OutOfPoolMemoryError : public SystemError
{ {
public: public:
@ -7031,14 +7039,6 @@ namespace VULKAN_HPP_NAMESPACE
IncompatibleDisplayKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} IncompatibleDisplayKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {}
}; };
class ValidationFailedEXTError : public SystemError
{
public:
ValidationFailedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
ValidationFailedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorValidationFailedEXT ), message ) {}
};
class InvalidShaderNVError : public SystemError class InvalidShaderNVError : public SystemError
{ {
public: public:
@ -7185,6 +7185,7 @@ namespace VULKAN_HPP_NAMESPACE
case Result::eErrorFormatNotSupported : throw FormatNotSupportedError( message ); case Result::eErrorFormatNotSupported : throw FormatNotSupportedError( message );
case Result::eErrorFragmentedPool : throw FragmentedPoolError( message ); case Result::eErrorFragmentedPool : throw FragmentedPoolError( message );
case Result::eErrorUnknown : throw UnknownError( message ); case Result::eErrorUnknown : throw UnknownError( message );
case Result::eErrorValidationFailed : throw ValidationFailedError( message );
case Result::eErrorOutOfPoolMemory : throw OutOfPoolMemoryError( message ); case Result::eErrorOutOfPoolMemory : throw OutOfPoolMemoryError( message );
case Result::eErrorInvalidExternalHandle : throw InvalidExternalHandleError( message ); case Result::eErrorInvalidExternalHandle : throw InvalidExternalHandleError( message );
case Result::eErrorFragmentation : throw FragmentationError( message ); case Result::eErrorFragmentation : throw FragmentationError( message );
@ -7194,7 +7195,6 @@ namespace VULKAN_HPP_NAMESPACE
case Result::eErrorNativeWindowInUseKHR : throw NativeWindowInUseKHRError( message ); case Result::eErrorNativeWindowInUseKHR : throw NativeWindowInUseKHRError( message );
case Result::eErrorOutOfDateKHR : throw OutOfDateKHRError( message ); case Result::eErrorOutOfDateKHR : throw OutOfDateKHRError( message );
case Result::eErrorIncompatibleDisplayKHR : throw IncompatibleDisplayKHRError( message ); case Result::eErrorIncompatibleDisplayKHR : throw IncompatibleDisplayKHRError( message );
case Result::eErrorValidationFailedEXT : throw ValidationFailedEXTError( message );
case Result::eErrorInvalidShaderNV : throw InvalidShaderNVError( message ); case Result::eErrorInvalidShaderNV : throw InvalidShaderNVError( message );
case Result::eErrorImageUsageNotSupportedKHR : throw ImageUsageNotSupportedKHRError( message ); case Result::eErrorImageUsageNotSupportedKHR : throw ImageUsageNotSupportedKHRError( message );
case Result::eErrorVideoPictureLayoutNotSupportedKHR : throw VideoPictureLayoutNotSupportedKHRError( message ); case Result::eErrorVideoPictureLayoutNotSupportedKHR : throw VideoPictureLayoutNotSupportedKHRError( message );

8
include/vulkan/vulkan_core.h
View file

@ -69,7 +69,7 @@ extern "C" {
#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0
// Version of this file // Version of this file
#define VK_HEADER_VERSION 322 #define VK_HEADER_VERSION 323
// Complete version of this file // Complete version of this file
#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
@ -157,6 +157,7 @@ typedef enum VkResult {
VK_ERROR_FORMAT_NOT_SUPPORTED = -11, VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
VK_ERROR_FRAGMENTED_POOL = -12, VK_ERROR_FRAGMENTED_POOL = -12,
VK_ERROR_UNKNOWN = -13, VK_ERROR_UNKNOWN = -13,
VK_ERROR_VALIDATION_FAILED = -1000011001,
VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,
VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
VK_ERROR_FRAGMENTATION = -1000161000, VK_ERROR_FRAGMENTATION = -1000161000,
@ -168,7 +169,6 @@ typedef enum VkResult {
VK_SUBOPTIMAL_KHR = 1000001003, VK_SUBOPTIMAL_KHR = 1000001003,
VK_ERROR_OUT_OF_DATE_KHR = -1000001004, VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
VK_ERROR_INVALID_SHADER_NV = -1000012000, VK_ERROR_INVALID_SHADER_NV = -1000012000,
VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000,
VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001,
@ -187,6 +187,7 @@ typedef enum VkResult {
VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000,
VK_PIPELINE_BINARY_MISSING_KHR = 1000483000, VK_PIPELINE_BINARY_MISSING_KHR = 1000483000,
VK_ERROR_NOT_ENOUGH_SPACE_KHR = -1000483000, VK_ERROR_NOT_ENOUGH_SPACE_KHR = -1000483000,
VK_ERROR_VALIDATION_FAILED_EXT = VK_ERROR_VALIDATION_FAILED,
VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,
VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,
VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION,
@ -15815,6 +15816,7 @@ typedef enum VkBuildAccelerationStructureFlagBitsKHR {
VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV = 0x00000200, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV = 0x00000200,
#endif #endif
VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800,
VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 0x00001000,
VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,
VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR,
VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,
@ -22603,7 +22605,7 @@ typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
// VK_NV_cluster_acceleration_structure is a preprocessor guard. Do not pass it to API calls. // VK_NV_cluster_acceleration_structure is a preprocessor guard. Do not pass it to API calls.
#define VK_NV_cluster_acceleration_structure 1 #define VK_NV_cluster_acceleration_structure 1
#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION 3 #define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION 4
#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_cluster_acceleration_structure" #define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_cluster_acceleration_structure"
typedef enum VkClusterAccelerationStructureTypeNV { typedef enum VkClusterAccelerationStructureTypeNV {

8
include/vulkan/vulkan_enums.hpp
View file

@ -250,6 +250,8 @@ namespace VULKAN_HPP_NAMESPACE
eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED, eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED,
eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL, eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL,
eErrorUnknown = VK_ERROR_UNKNOWN, eErrorUnknown = VK_ERROR_UNKNOWN,
eErrorValidationFailed = VK_ERROR_VALIDATION_FAILED,
eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY, eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY,
eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR,
eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE, eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE,
@ -270,7 +272,6 @@ namespace VULKAN_HPP_NAMESPACE
eSuboptimalKHR = VK_SUBOPTIMAL_KHR, eSuboptimalKHR = VK_SUBOPTIMAL_KHR,
eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR, eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR,
eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR,
eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT,
eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV, eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV,
eErrorImageUsageNotSupportedKHR = VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR, eErrorImageUsageNotSupportedKHR = VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR,
eErrorVideoPictureLayoutNotSupportedKHR = VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR, eErrorVideoPictureLayoutNotSupportedKHR = VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR,
@ -6859,7 +6860,8 @@ namespace VULKAN_HPP_NAMESPACE
eAllowDisplacementMicromapUpdateNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV, eAllowDisplacementMicromapUpdateNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV,
eAllowDisplacementMicromapUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV, eAllowDisplacementMicromapUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV,
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
eAllowDataAccess = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR eAllowDataAccess = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR,
eAllowClusterOpacityMicromapsNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV
}; };
using BuildAccelerationStructureFlagBitsNV = BuildAccelerationStructureFlagBitsKHR; using BuildAccelerationStructureFlagBitsNV = BuildAccelerationStructureFlagBitsKHR;
@ -6883,7 +6885,7 @@ namespace VULKAN_HPP_NAMESPACE
#if defined( VK_ENABLE_BETA_EXTENSIONS ) #if defined( VK_ENABLE_BETA_EXTENSIONS )
| BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV | BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
| BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess; | BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess | BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV;
}; };
// wrapper class for enum VkCopyAccelerationStructureModeKHR, see // wrapper class for enum VkCopyAccelerationStructureModeKHR, see

145
include/vulkan/vulkan_funcs.hpp
View file

@ -1665,7 +1665,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetFences( ArrayProxy<const Fence> const & fences, Dispatch const & d ) const VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetFences( ArrayProxy<const Fence> const & fences,
Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -2002,7 +2003,7 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetEvent( Event event, Dispatch const & d ) const VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::resetEvent( Event event, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -3847,7 +3848,7 @@ namespace VULKAN_HPP_NAMESPACE
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool,
DescriptorPoolResetFlags flags, DescriptorPoolResetFlags flags,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
@ -3858,15 +3859,19 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkResetDescriptorPool && "Function <vkResetDescriptorPool> requires <VK_VERSION_1_0>" ); VULKAN_HPP_ASSERT( d.vkResetDescriptorPool && "Function <vkResetDescriptorPool> requires <VK_VERSION_1_0>" );
# endif # endif
d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ); Result result = static_cast<Result>(
d.vkResetDescriptorPool( m_device, static_cast<VkDescriptorPool>( descriptorPool ), static_cast<VkDescriptorPoolResetFlags>( flags ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetDescriptorPool" );
return detail::createResultValueType( result );
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -3982,7 +3987,7 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool,
uint32_t descriptorSetCount, uint32_t descriptorSetCount,
const DescriptorSet * pDescriptorSets, const DescriptorSet * pDescriptorSets,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
@ -3997,23 +4002,25 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void Device::freeDescriptorSets( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
ArrayProxy<const DescriptorSet> const & descriptorSets, Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy<const DescriptorSet> const & descriptorSets, Dispatch const & d ) const
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" ); VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" );
# endif # endif
d.vkFreeDescriptorSets( Result result = static_cast<Result>( d.vkFreeDescriptorSets(
m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ); m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::freeDescriptorSets" );
return detail::createResultValueType( result );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE Result( Device::free )( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result( Device::free )( DescriptorPool descriptorPool,
uint32_t descriptorSetCount, uint32_t descriptorSetCount,
const DescriptorSet * pDescriptorSets, const DescriptorSet * pDescriptorSets,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
@ -4028,17 +4035,21 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void( Device::free )( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE
typename ResultValueType<void>::type( Device::free )( DescriptorPool descriptorPool,
ArrayProxy<const DescriptorSet> const & descriptorSets, ArrayProxy<const DescriptorSet> const & descriptorSets,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" ); VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function <vkFreeDescriptorSets> requires <VK_VERSION_1_0>" );
# endif # endif
d.vkFreeDescriptorSets( Result result = static_cast<Result>( d.vkFreeDescriptorSets(
m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ); m_device, static_cast<VkDescriptorPool>( descriptorPool ), descriptorSets.size(), reinterpret_cast<const VkDescriptorSet *>( descriptorSets.data() ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::( Device::free )" );
return detail::createResultValueType( result );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -4438,7 +4449,7 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const & d ) const Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -4688,7 +4699,8 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const & d ) const VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type CommandBuffer::reset( CommandBufferResetFlags flags,
Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -7638,7 +7650,7 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::setPrivateData( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const Device::setPrivateData( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -8438,7 +8450,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d ) const VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo,
Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -11479,13 +11492,13 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) ); reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) );
} }
} while ( result == Result::eIncomplete ); } while ( result == Result::eIncomplete );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" );
VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() );
if ( memoryRequirementsCount < memoryRequirements.size() ) if ( memoryRequirementsCount < memoryRequirements.size() )
{ {
memoryRequirements.resize( memoryRequirementsCount ); memoryRequirements.resize( memoryRequirementsCount );
} }
return memoryRequirements; return detail::createResultValueType( result, std::move( memoryRequirements ) );
} }
// wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see
@ -11522,13 +11535,13 @@ namespace VULKAN_HPP_NAMESPACE
reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) ); reinterpret_cast<VkVideoSessionMemoryRequirementsKHR *>( memoryRequirements.data() ) ) );
} }
} while ( result == Result::eIncomplete ); } while ( result == Result::eIncomplete );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" );
VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() );
if ( memoryRequirementsCount < memoryRequirements.size() ) if ( memoryRequirementsCount < memoryRequirements.size() )
{ {
memoryRequirements.resize( memoryRequirementsCount ); memoryRequirements.resize( memoryRequirementsCount );
} }
return memoryRequirements; return detail::createResultValueType( result, std::move( memoryRequirements ) );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -14019,7 +14032,7 @@ namespace VULKAN_HPP_NAMESPACE
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( display ) ) ); return static_cast<Result>( d.vkReleaseDisplayEXT( static_cast<VkPhysicalDevice>( m_physicalDevice ), static_cast<VkDisplayKHR>( display ) ) );
@ -14027,14 +14040,18 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display,
Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkReleaseDisplayEXT && "Function <vkReleaseDisplayEXT> requires <VK_EXT_direct_mode_display>" ); VULKAN_HPP_ASSERT( d.vkReleaseDisplayEXT && "Function <vkReleaseDisplayEXT> requires <VK_EXT_direct_mode_display>" );
# endif # endif
d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ); Result result = static_cast<Result>( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast<VkDisplayKHR>( display ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::releaseDisplayEXT" );
return detail::createResultValueType( result );
} }
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -14171,7 +14188,7 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d ) const Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -21672,8 +21689,7 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkGetDeferredOperationResultKHR, see // wrapper function for command vkGetDeferredOperationResultKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( DeferredOperationKHR operation, VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( DeferredOperationKHR operation, Dispatch const & d ) const
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -21681,6 +21697,7 @@ namespace VULKAN_HPP_NAMESPACE
# endif # endif
Result result = static_cast<Result>( d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) ); Result result = static_cast<Result>( d.vkGetDeferredOperationResultKHR( m_device, static_cast<VkDeferredOperationKHR>( operation ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDeferredOperationResultKHR", { Result::eSuccess, Result::eNotReady } );
return static_cast<Result>( result ); return static_cast<Result>( result );
} }
@ -22243,7 +22260,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d ) const VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -22272,8 +22290,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Dispatch const & d ) const Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -22581,7 +22599,8 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -22744,7 +22763,7 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::setPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const Device::setPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -28478,7 +28497,7 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkReleaseCapturedPipelineDataKHR, see // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE Result Device::releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo, VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo,
const AllocationCallbacks * pAllocator, const AllocationCallbacks * pAllocator,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
@ -28492,17 +28511,19 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkReleaseCapturedPipelineDataKHR, see // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void Device::releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::releaseCapturedPipelineDataKHR(
Optional<const AllocationCallbacks> allocator, const ReleaseCapturedPipelineDataInfoKHR & info, Optional<const AllocationCallbacks> allocator, Dispatch const & d ) const
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkReleaseCapturedPipelineDataKHR && "Function <vkReleaseCapturedPipelineDataKHR> requires <VK_KHR_pipeline_binary>" ); VULKAN_HPP_ASSERT( d.vkReleaseCapturedPipelineDataKHR && "Function <vkReleaseCapturedPipelineDataKHR> requires <VK_KHR_pipeline_binary>" );
# endif # endif
d.vkReleaseCapturedPipelineDataKHR( Result result = static_cast<Result>( d.vkReleaseCapturedPipelineDataKHR(
m_device, reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR *>( &info ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) ); m_device, reinterpret_cast<const VkReleaseCapturedPipelineDataInfoKHR *>( &info ), reinterpret_cast<const VkAllocationCallbacks *>( allocator.get() ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseCapturedPipelineDataKHR" );
return detail::createResultValueType( result );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -28550,13 +28571,13 @@ namespace VULKAN_HPP_NAMESPACE
m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) ); m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) );
} }
} while ( result == Result::eIncomplete ); } while ( result == Result::eIncomplete );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFramebufferTilePropertiesQCOM" );
VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); VULKAN_HPP_ASSERT( propertiesCount <= properties.size() );
if ( propertiesCount < properties.size() ) if ( propertiesCount < properties.size() )
{ {
properties.resize( propertiesCount ); properties.resize( propertiesCount );
} }
return properties; return detail::createResultValueType( result, std::move( properties ) );
} }
// wrapper function for command vkGetFramebufferTilePropertiesQCOM, see // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see
@ -28585,20 +28606,20 @@ namespace VULKAN_HPP_NAMESPACE
m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) ); m_device, static_cast<VkFramebuffer>( framebuffer ), &propertiesCount, reinterpret_cast<VkTilePropertiesQCOM *>( properties.data() ) ) );
} }
} while ( result == Result::eIncomplete ); } while ( result == Result::eIncomplete );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFramebufferTilePropertiesQCOM" );
VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); VULKAN_HPP_ASSERT( propertiesCount <= properties.size() );
if ( propertiesCount < properties.size() ) if ( propertiesCount < properties.size() )
{ {
properties.resize( propertiesCount ); properties.resize( propertiesCount );
} }
return properties; return detail::createResultValueType( result, std::move( properties ) );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE Result Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo, VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo,
TilePropertiesQCOM * pProperties, TilePropertiesQCOM * pProperties,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
@ -28612,8 +28633,8 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE TilePropertiesQCOM Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType<TilePropertiesQCOM>::type
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -28621,10 +28642,11 @@ namespace VULKAN_HPP_NAMESPACE
# endif # endif
TilePropertiesQCOM properties; TilePropertiesQCOM properties;
d.vkGetDynamicRenderingTilePropertiesQCOM( Result result = static_cast<Result>( d.vkGetDynamicRenderingTilePropertiesQCOM(
m_device, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ), reinterpret_cast<VkTilePropertiesQCOM *>( &properties ) ); m_device, reinterpret_cast<const VkRenderingInfo *>( &renderingInfo ), reinterpret_cast<VkTilePropertiesQCOM *>( &properties ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDynamicRenderingTilePropertiesQCOM" );
return properties; return detail::createResultValueType( result, std::move( properties ) );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
@ -28643,8 +28665,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Dispatch const & d ) const Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
@ -28823,7 +28845,7 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE typename ResultValueType<void>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::setLatencySleepModeNV( SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d ) const Device::setLatencySleepModeNV( SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
@ -28841,7 +28863,9 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE Result Device::latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV * pSleepInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::latencySleepNV( SwapchainKHR swapchain,
const LatencySleepInfoNV * pSleepInfo,
Dispatch const & d ) const VULKAN_HPP_NOEXCEPT
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
return static_cast<Result>( d.vkLatencySleepNV( return static_cast<Result>( d.vkLatencySleepNV(
@ -28851,14 +28875,19 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
template <typename Dispatch> template <typename Dispatch>
VULKAN_HPP_INLINE void Device::latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType<void>::type
Device::latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d ) const
{ {
VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION );
# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) # if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 )
VULKAN_HPP_ASSERT( d.vkLatencySleepNV && "Function <vkLatencySleepNV> requires <VK_NV_low_latency2>" ); VULKAN_HPP_ASSERT( d.vkLatencySleepNV && "Function <vkLatencySleepNV> requires <VK_NV_low_latency2>" );
# endif # endif
d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( &sleepInfo ) ); Result result = static_cast<Result>(
d.vkLatencySleepNV( m_device, static_cast<VkSwapchainKHR>( swapchain ), reinterpret_cast<const VkLatencySleepInfoNV *>( &sleepInfo ) ) );
detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::latencySleepNV" );
return detail::createResultValueType( result );
} }
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */

93
include/vulkan/vulkan_handles.hpp
View file

@ -5134,7 +5134,7 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type reset( CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type reset( CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -11471,8 +11471,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type resetFences( ArrayProxy<const Fence> const & fences, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; resetFences( ArrayProxy<const Fence> const & fences, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
@ -11625,7 +11625,8 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
// wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html
@ -12408,15 +12409,16 @@ namespace VULKAN_HPP_NAMESPACE
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result resetDescriptorPool( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD Result resetDescriptorPool( DescriptorPool descriptorPool,
DescriptorPoolResetFlags flags, DescriptorPoolResetFlags flags,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else #else
// wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void resetDescriptorPool( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
resetDescriptorPool( DescriptorPool descriptorPool,
DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
// wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html
@ -12459,30 +12461,31 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result freeDescriptorSets( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD Result freeDescriptorSets( DescriptorPool descriptorPool,
uint32_t descriptorSetCount, uint32_t descriptorSetCount,
const DescriptorSet * pDescriptorSets, const DescriptorSet * pDescriptorSets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void freeDescriptorSets( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
freeDescriptorSets( DescriptorPool descriptorPool,
ArrayProxy<const DescriptorSet> const & descriptorSets, ArrayProxy<const DescriptorSet> const & descriptorSets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result( free )( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD Result( free )( DescriptorPool descriptorPool,
uint32_t descriptorSetCount, uint32_t descriptorSetCount,
const DescriptorSet * pDescriptorSets, const DescriptorSet * pDescriptorSets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void( free )( DescriptorPool descriptorPool, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type( free )( DescriptorPool descriptorPool,
ArrayProxy<const DescriptorSet> const & descriptorSets, ArrayProxy<const DescriptorSet> const & descriptorSets,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html
@ -12668,7 +12671,8 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type resetCommandPool( CommandPool commandPool, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
resetCommandPool( CommandPool commandPool,
CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT, CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ARGUMENT_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
@ -13185,7 +13189,8 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type setPrivateData( ObjectType objectType, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setPrivateData( ObjectType objectType,
uint64_t objectHandle, uint64_t objectHandle,
PrivateDataSlot privateDataSlot, PrivateDataSlot privateDataSlot,
uint64_t data, uint64_t data,
@ -13297,8 +13302,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkGetRenderingAreaGranularity, see // wrapper function for command vkGetRenderingAreaGranularity, see
@ -14182,9 +14187,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type displayPowerControlEXT( DisplayKHR display, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type displayPowerControlEXT(
const DisplayPowerInfoEXT & displayPowerInfo, DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html
@ -15796,7 +15800,7 @@ namespace VULKAN_HPP_NAMESPACE
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation, VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
@ -15992,8 +15996,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_EXT_swapchain_maintenance1 === //=== VK_EXT_swapchain_maintenance1 ===
@ -16005,8 +16009,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_NV_device_generated_commands === //=== VK_NV_device_generated_commands ===
@ -16136,7 +16140,8 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type setPrivateDataEXT( ObjectType objectType, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setPrivateDataEXT( ObjectType objectType,
uint64_t objectHandle, uint64_t objectHandle,
PrivateDataSlot privateDataSlot, PrivateDataSlot privateDataSlot,
uint64_t data, uint64_t data,
@ -17598,16 +17603,17 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkReleaseCapturedPipelineDataKHR, see // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo, VULKAN_HPP_NODISCARD Result releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo,
const AllocationCallbacks * pAllocator, const AllocationCallbacks * pAllocator,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkReleaseCapturedPipelineDataKHR, see // wrapper function for command vkReleaseCapturedPipelineDataKHR, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info,
Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, Optional<const AllocationCallbacks> allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_QCOM_tile_properties === //=== VK_QCOM_tile_properties ===
@ -17639,15 +17645,15 @@ namespace VULKAN_HPP_NAMESPACE
// wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo, VULKAN_HPP_NODISCARD Result getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo,
TilePropertiesQCOM * pProperties, TilePropertiesQCOM * pProperties,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see
// https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
VULKAN_HPP_NODISCARD TilePropertiesQCOM getDynamicRenderingTilePropertiesQCOM( VULKAN_HPP_NODISCARD typename ResultValueType<TilePropertiesQCOM>::type
const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_KHR_swapchain_maintenance1 === //=== VK_KHR_swapchain_maintenance1 ===
@ -17659,8 +17665,8 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
//=== VK_NV_cooperative_vector === //=== VK_NV_cooperative_vector ===
@ -17688,22 +17694,20 @@ namespace VULKAN_HPP_NAMESPACE
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type setLatencySleepModeNV( SwapchainKHR swapchain, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setLatencySleepModeNV(
const LatencySleepModeInfoNV & sleepModeInfo, SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result latencySleepNV( SwapchainKHR swapchain, VULKAN_HPP_NODISCARD Result latencySleepNV( SwapchainKHR swapchain,
const LatencySleepInfoNV * pSleepInfo, const LatencySleepInfoNV * pSleepInfo,
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void latencySleepNV( SwapchainKHR swapchain, VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
const LatencySleepInfoNV & sleepInfo, latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */
// wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html
@ -19566,11 +19570,12 @@ namespace VULKAN_HPP_NAMESPACE
#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE #ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE
// wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
Result releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NODISCARD Result releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT;
#else #else
// wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
void releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/
#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) #if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT )
@ -20064,7 +20069,7 @@ namespace VULKAN_HPP_NAMESPACE
#else #else
// wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html
template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> template <typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
typename ResultValueType<void>::type VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const;
#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/

7725
include/vulkan/vulkan_raii.hpp
View file

File diff suppressed because it is too large Load diff

5
include/vulkan/vulkan_to_string.hpp
View file

@ -3115,6 +3115,8 @@ namespace VULKAN_HPP_NAMESPACE
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess ) if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess )
result += " AllowDataAccess |"; result += " AllowDataAccess |";
if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV )
result += " AllowClusterOpacityMicromapsNV |";
if ( result.size() > 1 ) if ( result.size() > 1 )
result.back() = '}'; result.back() = '}';
@ -4171,6 +4173,7 @@ namespace VULKAN_HPP_NAMESPACE
case Result::eErrorFormatNotSupported : return "ErrorFormatNotSupported"; case Result::eErrorFormatNotSupported : return "ErrorFormatNotSupported";
case Result::eErrorFragmentedPool : return "ErrorFragmentedPool"; case Result::eErrorFragmentedPool : return "ErrorFragmentedPool";
case Result::eErrorUnknown : return "ErrorUnknown"; case Result::eErrorUnknown : return "ErrorUnknown";
case Result::eErrorValidationFailed : return "ErrorValidationFailed";
case Result::eErrorOutOfPoolMemory : return "ErrorOutOfPoolMemory"; case Result::eErrorOutOfPoolMemory : return "ErrorOutOfPoolMemory";
case Result::eErrorInvalidExternalHandle : return "ErrorInvalidExternalHandle"; case Result::eErrorInvalidExternalHandle : return "ErrorInvalidExternalHandle";
case Result::eErrorFragmentation : return "ErrorFragmentation"; case Result::eErrorFragmentation : return "ErrorFragmentation";
@ -4182,7 +4185,6 @@ namespace VULKAN_HPP_NAMESPACE
case Result::eSuboptimalKHR : return "SuboptimalKHR"; case Result::eSuboptimalKHR : return "SuboptimalKHR";
case Result::eErrorOutOfDateKHR : return "ErrorOutOfDateKHR"; case Result::eErrorOutOfDateKHR : return "ErrorOutOfDateKHR";
case Result::eErrorIncompatibleDisplayKHR : return "ErrorIncompatibleDisplayKHR"; case Result::eErrorIncompatibleDisplayKHR : return "ErrorIncompatibleDisplayKHR";
case Result::eErrorValidationFailedEXT : return "ErrorValidationFailedEXT";
case Result::eErrorInvalidShaderNV : return "ErrorInvalidShaderNV"; case Result::eErrorInvalidShaderNV : return "ErrorInvalidShaderNV";
case Result::eErrorImageUsageNotSupportedKHR : return "ErrorImageUsageNotSupportedKHR"; case Result::eErrorImageUsageNotSupportedKHR : return "ErrorImageUsageNotSupportedKHR";
case Result::eErrorVideoPictureLayoutNotSupportedKHR : return "ErrorVideoPictureLayoutNotSupportedKHR"; case Result::eErrorVideoPictureLayoutNotSupportedKHR : return "ErrorVideoPictureLayoutNotSupportedKHR";
@ -8757,6 +8759,7 @@ namespace VULKAN_HPP_NAMESPACE
case BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV: return "AllowDisplacementMicromapUpdateNV"; case BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV: return "AllowDisplacementMicromapUpdateNV";
#endif /*VK_ENABLE_BETA_EXTENSIONS*/ #endif /*VK_ENABLE_BETA_EXTENSIONS*/
case BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess : return "AllowDataAccess"; case BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess : return "AllowDataAccess";
case BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV: return "AllowClusterOpacityMicromapsNV";
default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )"; default : return "invalid ( " + toHexString( static_cast<uint32_t>( value ) ) + " )";
} }
} }

271
include/vulkan/vulkan_video.hpp
View file

@ -7,22 +7,52 @@
#ifndef VULKAN_VIDEO_HPP #ifndef VULKAN_VIDEO_HPP
#define VULKAN_VIDEO_HPP #define VULKAN_VIDEO_HPP
// here, we consider include files to be available when __has_include is not defined
#if !defined( __has_include )
# define __has_include( x ) true
# define has_include_was_not_defined
#endif
// clang-format off // clang-format off
#include <vulkan/vulkan.hpp> #include <vulkan/vulkan.hpp>
// clang-format on // clang-format on
#include <vk_video/vulkan_video_codec_av1std.h> #if __has_include( <vk_video/vulkan_video_codecs_common.h> )
#include <vk_video/vulkan_video_codec_av1std_decode.h>
#include <vk_video/vulkan_video_codec_av1std_encode.h>
#include <vk_video/vulkan_video_codec_h264std.h>
#include <vk_video/vulkan_video_codec_h264std_decode.h>
#include <vk_video/vulkan_video_codec_h264std_encode.h>
#include <vk_video/vulkan_video_codec_h265std.h>
#include <vk_video/vulkan_video_codec_h265std_decode.h>
#include <vk_video/vulkan_video_codec_h265std_encode.h>
#include <vk_video/vulkan_video_codec_vp9std.h>
#include <vk_video/vulkan_video_codec_vp9std_decode.h>
# include <vk_video/vulkan_video_codecs_common.h> # include <vk_video/vulkan_video_codecs_common.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_h264std.h> )
# include <vk_video/vulkan_video_codec_h264std.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_h264std_decode.h> )
# include <vk_video/vulkan_video_codec_h264std_decode.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_h264std_encode.h> )
# include <vk_video/vulkan_video_codec_h264std_encode.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_h265std.h> )
# include <vk_video/vulkan_video_codec_h265std.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_h265std_decode.h> )
# include <vk_video/vulkan_video_codec_h265std_decode.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_h265std_encode.h> )
# include <vk_video/vulkan_video_codec_h265std_encode.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_vp9std.h> )
# include <vk_video/vulkan_video_codec_vp9std.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_vp9std_decode.h> )
# include <vk_video/vulkan_video_codec_vp9std_decode.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_av1std.h> )
# include <vk_video/vulkan_video_codec_av1std.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_av1std_decode.h> )
# include <vk_video/vulkan_video_codec_av1std_decode.h>
#endif
#if __has_include( <vk_video/vulkan_video_codec_av1std_encode.h> )
# include <vk_video/vulkan_video_codec_av1std_encode.h>
#endif
#if !defined( VULKAN_HPP_VIDEO_NAMESPACE ) #if !defined( VULKAN_HPP_VIDEO_NAMESPACE )
# define VULKAN_HPP_VIDEO_NAMESPACE video # define VULKAN_HPP_VIDEO_NAMESPACE video
@ -619,9 +649,9 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t bit_rate_scale = {}; uint8_t bit_rate_scale = {};
uint8_t cpb_size_scale = {}; uint8_t cpb_size_scale = {};
uint8_t reserved1 = {}; uint8_t reserved1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cbr_flag = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H264_CPB_CNT_LIST_SIZE> cbr_flag = {};
uint32_t initial_cpb_removal_delay_length_minus1 = {}; uint32_t initial_cpb_removal_delay_length_minus1 = {};
uint32_t cpb_removal_delay_length_minus1 = {}; uint32_t cpb_removal_delay_length_minus1 = {};
uint32_t dpb_output_delay_length_minus1 = {}; uint32_t dpb_output_delay_length_minus1 = {};
@ -787,10 +817,8 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
uint16_t scaling_list_present_mask = {}; uint16_t scaling_list_present_mask = {};
uint16_t use_default_scaling_matrix_mask = {}; uint16_t use_default_scaling_matrix_mask = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS> ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS> ScalingList4x4 = {};
ScalingList4x4 = {}; ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS> ScalingList8x8 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS>
ScalingList8x8 = {};
}; };
struct H264SequenceParameterSet struct H264SequenceParameterSet
@ -1065,7 +1093,7 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t reserved2 = {}; uint8_t reserved2 = {};
uint16_t frame_num = {}; uint16_t frame_num = {};
uint16_t idr_pic_id = {}; uint16_t idr_pic_id = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {}; ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {};
}; };
struct DecodeH264ReferenceInfoFlags struct DecodeH264ReferenceInfoFlags
@ -1148,7 +1176,7 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags flags = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags flags = {};
uint16_t FrameNum = {}; uint16_t FrameNum = {};
uint16_t reserved = {}; uint16_t reserved = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {}; ArrayWrapper1D<int32_t, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE> PicOrderCnt = {};
}; };
#endif #endif
@ -1239,14 +1267,14 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags flags = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags flags = {};
uint8_t luma_log2_weight_denom = {}; uint8_t luma_log2_weight_denom = {};
uint8_t chroma_log2_weight_denom = {}; uint8_t chroma_log2_weight_denom = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l0 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l0 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l0 = {}; ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l0 = {}; ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l1 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_weight_l1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l1 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> luma_offset_l1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l1 = {}; ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_weight_l1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l1 = {}; ArrayWrapper2D<int8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES> chroma_offset_l1 = {};
}; };
struct EncodeH264SliceHeaderFlags struct EncodeH264SliceHeaderFlags
@ -1545,12 +1573,12 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags flags = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags flags = {};
uint8_t num_ref_idx_l0_active_minus1 = {}; uint8_t num_ref_idx_l0_active_minus1 = {};
uint8_t num_ref_idx_l1_active_minus1 = {}; uint8_t num_ref_idx_l1_active_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList0 = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList1 = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H264_MAX_NUM_LIST_REF> RefPicList1 = {};
uint8_t refList0ModOpCount = {}; uint8_t refList0ModOpCount = {};
uint8_t refList1ModOpCount = {}; uint8_t refList1ModOpCount = {};
uint8_t refPicMarkingOpCount = {}; uint8_t refPicMarkingOpCount = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; ArrayWrapper1D<uint8_t, 7> reserved1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList0ModOperations = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList0ModOperations = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList1ModOperations = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList1ModOperations = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry * pRefPicMarkingOperations = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry * pRefPicMarkingOperations = {};
@ -1602,7 +1630,7 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t frame_num = {}; uint32_t frame_num = {};
int32_t PicOrderCnt = {}; int32_t PicOrderCnt = {};
uint8_t temporal_id = {}; uint8_t temporal_id = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {}; ArrayWrapper1D<uint8_t, 3> reserved1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo * pRefLists = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo * pRefLists = {};
}; };
@ -1744,9 +1772,9 @@ namespace VULKAN_HPP_NAMESPACE
} }
public: public:
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_latency_increase_plus1 = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_latency_increase_plus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_dec_pic_buffering_minus1 = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_dec_pic_buffering_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_num_reorder_pics = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> max_num_reorder_pics = {};
}; };
struct H265SubLayerHrdParameters struct H265SubLayerHrdParameters
@ -1786,10 +1814,10 @@ namespace VULKAN_HPP_NAMESPACE
} }
public: public:
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_value_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_value_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_du_value_minus1 = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> cpb_size_du_value_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_du_value_minus1 = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_H265_CPB_CNT_LIST_SIZE> bit_rate_du_value_minus1 = {};
uint32_t cbr_flag = {}; uint32_t cbr_flag = {};
}; };
@ -1895,9 +1923,9 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t initial_cpb_removal_delay_length_minus1 = {}; uint8_t initial_cpb_removal_delay_length_minus1 = {};
uint8_t au_cpb_removal_delay_length_minus1 = {}; uint8_t au_cpb_removal_delay_length_minus1 = {};
uint8_t dpb_output_delay_length_minus1 = {}; uint8_t dpb_output_delay_length_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> cpb_cnt_minus1 = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> cpb_cnt_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> elemental_duration_in_tc_minus1 = {}; ArrayWrapper1D<uint16_t, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE> elemental_duration_in_tc_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, 3> reserved = {}; ArrayWrapper1D<uint16_t, 3> reserved = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersNal = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersNal = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersVcl = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersVcl = {};
}; };
@ -2122,16 +2150,12 @@ namespace VULKAN_HPP_NAMESPACE
} }
public: public:
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS> ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS> ScalingList4x4 = {};
ScalingList4x4 = {}; ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS> ScalingList8x8 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS> ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS> ScalingList16x16 = {};
ScalingList8x8 = {}; ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS> ScalingList32x32 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS> ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS> ScalingListDCCoef16x16 = {};
ScalingList16x16 = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS> ScalingListDCCoef32x32 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS>
ScalingList32x32 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS> ScalingListDCCoef16x16 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS> ScalingListDCCoef32x32 = {};
}; };
struct H265SpsVuiFlags struct H265SpsVuiFlags
@ -2311,7 +2335,6 @@ namespace VULKAN_HPP_NAMESPACE
} }
public: public:
VULKAN_HPP_NAMESPACE::
ArrayWrapper2D<uint16_t, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE> ArrayWrapper2D<uint16_t, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE>
PredictorPaletteEntries = {}; PredictorPaletteEntries = {};
}; };
@ -2496,8 +2519,8 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t reserved3 = {}; uint8_t reserved3 = {};
uint8_t num_negative_pics = {}; uint8_t num_negative_pics = {};
uint8_t num_positive_pics = {}; uint8_t num_positive_pics = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s0_minus1 = {}; ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s0_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s1_minus1 = {}; ArrayWrapper1D<uint16_t, STD_VIDEO_H265_MAX_DPB_SIZE> delta_poc_s1_minus1 = {};
}; };
struct H265LongTermRefPicsSps struct H265LongTermRefPicsSps
@ -2536,7 +2559,7 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
uint32_t used_by_curr_pic_lt_sps_flag = {}; uint32_t used_by_curr_pic_lt_sps_flag = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_ref_pic_poc_lsb_sps = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_ref_pic_poc_lsb_sps = {};
}; };
struct H265SequenceParameterSet struct H265SequenceParameterSet
@ -2802,8 +2825,8 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t log2_max_transform_skip_block_size_minus2 = {}; uint8_t log2_max_transform_skip_block_size_minus2 = {};
uint8_t diff_cu_chroma_qp_offset_depth = {}; uint8_t diff_cu_chroma_qp_offset_depth = {};
uint8_t chroma_qp_offset_list_len_minus1 = {}; uint8_t chroma_qp_offset_list_len_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cb_qp_offset_list = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cb_qp_offset_list = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cr_qp_offset_list = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE> cr_qp_offset_list = {};
uint8_t log2_sao_offset_scale_luma = {}; uint8_t log2_sao_offset_scale_luma = {};
uint8_t log2_sao_offset_scale_chroma = {}; uint8_t log2_sao_offset_scale_chroma = {};
int8_t pps_act_y_qp_offset_plus5 = {}; int8_t pps_act_y_qp_offset_plus5 = {};
@ -2816,8 +2839,8 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t num_tile_rows_minus1 = {}; uint8_t num_tile_rows_minus1 = {};
uint8_t reserved1 = {}; uint8_t reserved1 = {};
uint8_t reserved2 = {}; uint8_t reserved2 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE> column_width_minus1 = {}; ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE> column_width_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE> row_height_minus1 = {}; ArrayWrapper1D<uint16_t, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE> row_height_minus1 = {};
uint32_t reserved3 = {}; uint32_t reserved3 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {};
@ -2917,9 +2940,9 @@ namespace VULKAN_HPP_NAMESPACE
int32_t PicOrderCntVal = {}; int32_t PicOrderCntVal = {};
uint16_t NumBitsForSTRefPicSetInSlice = {}; uint16_t NumBitsForSTRefPicSetInSlice = {};
uint16_t reserved = {}; uint16_t reserved = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrBefore = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrBefore = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrAfter = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetStCurrAfter = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetLtCurr = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE> RefPicSetLtCurr = {};
}; };
struct DecodeH265ReferenceInfoFlags struct DecodeH265ReferenceInfoFlags
@ -3089,14 +3112,14 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags flags = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags flags = {};
uint8_t luma_log2_weight_denom = {}; uint8_t luma_log2_weight_denom = {};
int8_t delta_chroma_log2_weight_denom = {}; int8_t delta_chroma_log2_weight_denom = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l0 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l0 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l0 = {}; ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l0 = {}; ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l1 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> delta_luma_weight_l1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l1 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> luma_offset_l1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l1 = {}; ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_weight_l1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l1 = {}; ArrayWrapper2D<int8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES> delta_chroma_offset_l1 = {};
}; };
struct EncodeH265SliceSegmentHeaderFlags struct EncodeH265SliceSegmentHeaderFlags
@ -3296,10 +3319,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags flags = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags flags = {};
uint8_t num_ref_idx_l0_active_minus1 = {}; uint8_t num_ref_idx_l0_active_minus1 = {};
uint8_t num_ref_idx_l1_active_minus1 = {}; uint8_t num_ref_idx_l1_active_minus1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList0 = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList1 = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> RefPicList1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l0 = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l0 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l1 = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_NUM_LIST_REF> list_entry_l1 = {};
}; };
struct EncodeH265PictureInfoFlags struct EncodeH265PictureInfoFlags
@ -3393,11 +3416,11 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
uint8_t num_long_term_sps = {}; uint8_t num_long_term_sps = {};
uint8_t num_long_term_pics = {}; uint8_t num_long_term_pics = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_idx_sps = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS> lt_idx_sps = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_PICS> poc_lsb_lt = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_LONG_TERM_PICS> poc_lsb_lt = {};
uint16_t used_by_curr_pic_lt_flag = {}; uint16_t used_by_curr_pic_lt_flag = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_present_flag = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_present_flag = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_cycle_lt = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_H265_MAX_DELTA_POC> delta_poc_msb_cycle_lt = {};
}; };
struct EncodeH265PictureInfo struct EncodeH265PictureInfo
@ -3447,7 +3470,7 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t short_term_ref_pic_set_idx = {}; uint8_t short_term_ref_pic_set_idx = {};
int32_t PicOrderCntVal = {}; int32_t PicOrderCntVal = {};
uint8_t TemporalId = {}; uint8_t TemporalId = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; ArrayWrapper1D<uint8_t, 7> reserved1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics * pLongTermRefPics = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics * pLongTermRefPics = {};
@ -3704,9 +3727,9 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t loop_filter_level = {}; uint8_t loop_filter_level = {};
uint8_t loop_filter_sharpness = {}; uint8_t loop_filter_sharpness = {};
uint8_t update_ref_delta = {}; uint8_t update_ref_delta = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_VP9_MAX_REF_FRAMES> loop_filter_ref_deltas = {}; ArrayWrapper1D<int8_t, STD_VIDEO_VP9_MAX_REF_FRAMES> loop_filter_ref_deltas = {};
uint8_t update_mode_delta = {}; uint8_t update_mode_delta = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS> loop_filter_mode_deltas = {}; ArrayWrapper1D<int8_t, STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS> loop_filter_mode_deltas = {};
}; };
struct VP9SegmentationFlags struct VP9SegmentationFlags
@ -3790,10 +3813,10 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags flags = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags flags = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS> segmentation_tree_probs = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS> segmentation_tree_probs = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB> segmentation_pred_prob = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB> segmentation_pred_prob = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTS> FeatureEnabled = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_VP9_MAX_SEGMENTS> FeatureEnabled = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int16_t, STD_VIDEO_VP9_MAX_SEGMENTS, STD_VIDEO_VP9_SEG_LVL_MAX> FeatureData = {}; ArrayWrapper2D<int16_t, STD_VIDEO_VP9_MAX_SEGMENTS, STD_VIDEO_VP9_SEG_LVL_MAX> FeatureData = {};
}; };
#endif #endif
@ -3905,7 +3928,7 @@ namespace VULKAN_HPP_NAMESPACE
int8_t delta_q_uv_ac = {}; int8_t delta_q_uv_ac = {};
uint8_t tile_cols_log2 = {}; uint8_t tile_cols_log2 = {};
uint8_t tile_rows_log2 = {}; uint8_t tile_rows_log2 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, 3> reserved1 = {}; ArrayWrapper1D<uint16_t, 3> reserved1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig * pColorConfig = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig * pColorConfig = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter * pLoopFilter = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter * pLoopFilter = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation * pSegmentation = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation * pSegmentation = {};
@ -4170,12 +4193,12 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags flags = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags flags = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS> loop_filter_level = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS> loop_filter_level = {};
uint8_t loop_filter_sharpness = {}; uint8_t loop_filter_sharpness = {};
uint8_t update_ref_delta = {}; uint8_t update_ref_delta = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME> loop_filter_ref_deltas = {}; ArrayWrapper1D<int8_t, STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME> loop_filter_ref_deltas = {};
uint8_t update_mode_delta = {}; uint8_t update_mode_delta = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS> loop_filter_mode_deltas = {}; ArrayWrapper1D<int8_t, STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS> loop_filter_mode_deltas = {};
}; };
struct AV1QuantizationFlags struct AV1QuantizationFlags
@ -4302,8 +4325,8 @@ namespace VULKAN_HPP_NAMESPACE
} }
public: public:
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_SEGMENTS> FeatureEnabled = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_SEGMENTS> FeatureEnabled = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int16_t, STD_VIDEO_AV1_MAX_SEGMENTS, STD_VIDEO_AV1_SEG_LVL_MAX> FeatureData = {}; ArrayWrapper2D<int16_t, STD_VIDEO_AV1_MAX_SEGMENTS, STD_VIDEO_AV1_SEG_LVL_MAX> FeatureData = {};
}; };
struct AV1TileInfoFlags struct AV1TileInfoFlags
@ -4388,7 +4411,7 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t TileRows = {}; uint8_t TileRows = {};
uint16_t context_update_tile_id = {}; uint16_t context_update_tile_id = {};
uint8_t tile_size_bytes_minus_1 = {}; uint8_t tile_size_bytes_minus_1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 7> reserved1 = {}; ArrayWrapper1D<uint8_t, 7> reserved1 = {};
const uint16_t * pMiColStarts = {}; const uint16_t * pMiColStarts = {};
const uint16_t * pMiRowStarts = {}; const uint16_t * pMiRowStarts = {};
const uint16_t * pWidthInSbsMinus1 = {}; const uint16_t * pWidthInSbsMinus1 = {};
@ -4434,10 +4457,10 @@ namespace VULKAN_HPP_NAMESPACE
public: public:
uint8_t cdef_damping_minus_3 = {}; uint8_t cdef_damping_minus_3 = {};
uint8_t cdef_bits = {}; uint8_t cdef_bits = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_y_pri_strength = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_y_pri_strength = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_y_sec_strength = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_y_sec_strength = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_uv_pri_strength = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_uv_pri_strength = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_uv_sec_strength = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS> cdef_uv_sec_strength = {};
}; };
struct AV1LoopRestoration struct AV1LoopRestoration
@ -4475,8 +4498,8 @@ namespace VULKAN_HPP_NAMESPACE
} }
public: public:
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<StdVideoAV1FrameRestorationType, STD_VIDEO_AV1_MAX_NUM_PLANES> FrameRestorationType = {}; ArrayWrapper1D<StdVideoAV1FrameRestorationType, STD_VIDEO_AV1_MAX_NUM_PLANES> FrameRestorationType = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint16_t, STD_VIDEO_AV1_MAX_NUM_PLANES> LoopRestorationSize = {}; ArrayWrapper1D<uint16_t, STD_VIDEO_AV1_MAX_NUM_PLANES> LoopRestorationSize = {};
}; };
struct AV1GlobalMotion struct AV1GlobalMotion
@ -4514,8 +4537,8 @@ namespace VULKAN_HPP_NAMESPACE
} }
public: public:
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> GmType = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> GmType = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper2D<int32_t, STD_VIDEO_AV1_NUM_REF_FRAMES, STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS> gm_params = {}; ArrayWrapper2D<int32_t, STD_VIDEO_AV1_NUM_REF_FRAMES, STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS> gm_params = {};
}; };
struct AV1FilmGrainFlags struct AV1FilmGrainFlags
@ -4612,17 +4635,17 @@ namespace VULKAN_HPP_NAMESPACE
uint16_t grain_seed = {}; uint16_t grain_seed = {};
uint8_t film_grain_params_ref_idx = {}; uint8_t film_grain_params_ref_idx = {};
uint8_t num_y_points = {}; uint8_t num_y_points = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_Y_POINTS> point_y_value = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_Y_POINTS> point_y_value = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_Y_POINTS> point_y_scaling = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_Y_POINTS> point_y_scaling = {};
uint8_t num_cb_points = {}; uint8_t num_cb_points = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CB_POINTS> point_cb_value = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CB_POINTS> point_cb_value = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CB_POINTS> point_cb_scaling = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CB_POINTS> point_cb_scaling = {};
uint8_t num_cr_points = {}; uint8_t num_cr_points = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CR_POINTS> point_cr_value = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CR_POINTS> point_cr_value = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CR_POINTS> point_cr_scaling = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_MAX_NUM_CR_POINTS> point_cr_scaling = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_LUMA> ar_coeffs_y_plus_128 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_LUMA> ar_coeffs_y_plus_128 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA> ar_coeffs_cb_plus_128 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA> ar_coeffs_cb_plus_128 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA> ar_coeffs_cr_plus_128 = {}; ArrayWrapper1D<int8_t, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA> ar_coeffs_cr_plus_128 = {};
uint8_t cb_mult = {}; uint8_t cb_mult = {};
uint8_t cb_luma_mult = {}; uint8_t cb_luma_mult = {};
uint16_t cb_offset = {}; uint16_t cb_offset = {};
@ -4748,7 +4771,7 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t order_hint_bits_minus_1 = {}; uint8_t order_hint_bits_minus_1 = {};
uint8_t seq_force_integer_mv = {}; uint8_t seq_force_integer_mv = {};
uint8_t seq_force_screen_content_tools = {}; uint8_t seq_force_screen_content_tools = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 5> reserved1 = {}; ArrayWrapper1D<uint8_t, 5> reserved1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig * pColorConfig = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig * pColorConfig = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo * pTimingInfo = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo * pTimingInfo = {};
}; };
@ -4890,11 +4913,11 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4;
uint8_t delta_q_res = {}; uint8_t delta_q_res = {};
uint8_t delta_lf_res = {}; uint8_t delta_lf_res = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_SKIP_MODE_FRAMES> SkipModeFrame = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_SKIP_MODE_FRAMES> SkipModeFrame = {};
uint8_t coded_denom = {}; uint8_t coded_denom = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved2 = {}; ArrayWrapper1D<uint8_t, 3> reserved2 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> OrderHints = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> OrderHints = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_NUM_REF_FRAMES> expectedFrameId = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_NUM_REF_FRAMES> expectedFrameId = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {};
@ -4986,7 +5009,7 @@ namespace VULKAN_HPP_NAMESPACE
uint8_t frame_type = {}; uint8_t frame_type = {};
uint8_t RefFrameSignBias = {}; uint8_t RefFrameSignBias = {};
uint8_t OrderHint = {}; uint8_t OrderHint = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> SavedOrderHints = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> SavedOrderHints = {};
}; };
#endif #endif
@ -5304,10 +5327,10 @@ namespace VULKAN_HPP_NAMESPACE
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4;
uint8_t delta_q_res = {}; uint8_t delta_q_res = {};
uint8_t delta_lf_res = {}; uint8_t delta_lf_res = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> ref_order_hint = {}; ArrayWrapper1D<uint8_t, STD_VIDEO_AV1_NUM_REF_FRAMES> ref_order_hint = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<int8_t, STD_VIDEO_AV1_REFS_PER_FRAME> ref_frame_idx = {}; ArrayWrapper1D<int8_t, STD_VIDEO_AV1_REFS_PER_FRAME> ref_frame_idx = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {}; ArrayWrapper1D<uint8_t, 3> reserved1 = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_REFS_PER_FRAME> delta_frame_id_minus_1 = {}; ArrayWrapper1D<uint32_t, STD_VIDEO_AV1_REFS_PER_FRAME> delta_frame_id_minus_1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {};
@ -5400,11 +5423,17 @@ namespace VULKAN_HPP_NAMESPACE
uint32_t RefFrameId = {}; uint32_t RefFrameId = {};
VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey; VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey;
uint8_t OrderHint = {}; uint8_t OrderHint = {};
VULKAN_HPP_NAMESPACE::ArrayWrapper1D<uint8_t, 3> reserved1 = {}; ArrayWrapper1D<uint8_t, 3> reserved1 = {};
const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {}; const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {};
}; };
#endif #endif
} // namespace VULKAN_HPP_VIDEO_NAMESPACE } // namespace VULKAN_HPP_VIDEO_NAMESPACE
} // namespace VULKAN_HPP_NAMESPACE } // namespace VULKAN_HPP_NAMESPACE
#if defined( has_include_was_not_defined )
# undef has_include_was_not_defined
# undef __has_include
#endif
#endif #endif

228
registry/base_generator.py
View file

@ -7,17 +7,22 @@
import pickle import pickle
import os import os
import tempfile import tempfile
import copy
from vulkan_object import (VulkanObject, from vulkan_object import (VulkanObject,
Extension, Version, Deprecate, Handle, Param, Queues, CommandScope, Command, Extension, Version, Deprecate, Handle, Param, Queues, CommandScope, Command,
EnumField, Enum, Flag, Bitmask, ExternSync, Flags, Member, Struct, EnumField, Enum, Flag, Bitmask, ExternSync, Flags, Member, Struct,
Constant, FormatComponent, FormatPlane, Format, Constant, FormatComponent, FormatPlane, Format,
SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline, SyncSupport, SyncEquivalent, SyncStage, SyncAccess, SyncPipelineStage, SyncPipeline,
SpirvEnables, Spirv) SpirvEnables, Spirv,
VideoCodec, VideoFormat, VideoProfiles, VideoProfileMember, VideoRequiredCapabilities,
VideoStd, VideoStdHeader)
# These live in the Vulkan-Docs repo, but are pulled in via the # These live in the Vulkan-Docs repo, but are pulled in via the
# Vulkan-Headers/registry folder # Vulkan-Headers/registry folder
from generator import OutputGenerator, GeneratorOptions, write from generator import OutputGenerator, GeneratorOptions, write
from vkconventions import VulkanConventions from vkconventions import VulkanConventions
from reg import Registry
from xml.etree import ElementTree
# An API style convention object # An API style convention object
vulkanConventions = VulkanConventions() vulkanConventions = VulkanConventions()
@ -146,7 +151,8 @@ class BaseGeneratorOptions(GeneratorOptions):
def __init__(self, def __init__(self,
customFileName = None, customFileName = None,
customDirectory = None, customDirectory = None,
customApiName = None): customApiName = None,
videoXmlPath = None):
GeneratorOptions.__init__(self, GeneratorOptions.__init__(self,
conventions = vulkanConventions, conventions = vulkanConventions,
filename = customFileName if customFileName else globalFileName, filename = customFileName if customFileName else globalFileName,
@ -163,6 +169,9 @@ class BaseGeneratorOptions(GeneratorOptions):
self.apientryp = 'VKAPI_PTR *' self.apientryp = 'VKAPI_PTR *'
self.alignFuncParam = 48 self.alignFuncParam = 48
# This is used to provide the video.xml to the private video XML generator
self.videoXmlPath = videoXmlPath
# #
# This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers # This object handles all the parsing from reg.py generator scripts in the Vulkan-Headers
# It will grab all the data and form it into a single object the rest of the generators will use # It will grab all the data and form it into a single object the rest of the generators will use
@ -235,6 +244,15 @@ class BaseGenerator(OutputGenerator):
self.vk.queueBits[Queues.DECODE] = 'VK_QUEUE_VIDEO_DECODE_BIT_KHR' self.vk.queueBits[Queues.DECODE] = 'VK_QUEUE_VIDEO_DECODE_BIT_KHR'
self.vk.queueBits[Queues.ENCODE] = 'VK_QUEUE_VIDEO_ENCODE_BIT_KHR' self.vk.queueBits[Queues.ENCODE] = 'VK_QUEUE_VIDEO_ENCODE_BIT_KHR'
# If the video.xml path is provided then we need to load and parse it using
# the private video std generator
if genOpts.videoXmlPath is not None:
videoStdGenerator = _VideoStdGenerator()
videoRegistry = Registry(videoStdGenerator, genOpts)
videoRegistry.loadElementTree(ElementTree.parse(genOpts.videoXmlPath))
videoRegistry.apiGen()
self.vk.videoStd = videoStdGenerator.vk.videoStd
# This function should be overloaded # This function should be overloaded
def generate(self): def generate(self):
print("WARNING: This should not be called from the child class") print("WARNING: This should not be called from the child class")
@ -404,31 +422,96 @@ class BaseGenerator(OutputGenerator):
for key, value in self.handleAliasMap.items(): for key, value in self.handleAliasMap.items():
self.vk.handles[self.dealias(value, self.handleAliasMap)].aliases.append(key) self.vk.handles[self.dealias(value, self.handleAliasMap)].aliases.append(key)
def addConstants(self, constantNames: list[str]):
def addConstants(self): for constantName in constantNames:
for constantName in [k for k,v in self.registry.enumvaluedict.items() if v == 'API Constants']:
enumInfo = self.registry.enumdict[constantName] enumInfo = self.registry.enumdict[constantName]
typeName = enumInfo.type typeName = enumInfo.type
valueStr = enumInfo.elem.get('value') valueStr = enumInfo.elem.get('value')
# These values are represented in c-style # These values are represented in c-style
if valueStr.upper().endswith('F'): isHex = valueStr.upper().startswith('0X')
intBase = 16 if isHex else 10
if valueStr.upper().endswith('F') and not isHex:
value = float(valueStr[:-1]) value = float(valueStr[:-1])
elif valueStr.upper().endswith('U)'): elif valueStr.upper().endswith('U)'):
inner_number = int(valueStr.removeprefix("(~").removesuffix(")")[:-1]) inner_number = int(valueStr.removeprefix("(~").removesuffix(")")[:-1], intBase)
value = (~inner_number) & ((1 << 32) - 1) value = (~inner_number) & ((1 << 32) - 1)
elif valueStr.upper().endswith('ULL)'): elif valueStr.upper().endswith('ULL)'):
inner_number = int(valueStr.removeprefix("(~").removesuffix(")")[:-3]) inner_number = int(valueStr.removeprefix("(~").removesuffix(")")[:-3], intBase)
value = (~0) & ((1 << 64) - 1) value = (~0) & ((1 << 64) - 1)
else: else:
value = int(valueStr) value = int(valueStr, intBase)
self.vk.constants[constantName] = Constant(constantName, typeName, value, valueStr) self.vk.constants[constantName] = Constant(constantName, typeName, value, valueStr)
def addVideoCodecs(self):
for xmlVideoCodec in self.registry.tree.findall('videocodecs/videocodec'):
name = xmlVideoCodec.get('name')
extend = xmlVideoCodec.get('extend')
value = xmlVideoCodec.get('value')
profiles: dict[str, VideoProfiles] = {}
capabilities: dict[str, str] = {}
formats: dict[str, VideoFormat] = {}
if extend is not None:
# Inherit base profiles, capabilities, and formats
profiles = copy.deepcopy(self.vk.videoCodecs[extend].profiles)
capabilities = copy.deepcopy(self.vk.videoCodecs[extend].capabilities)
formats = copy.deepcopy(self.vk.videoCodecs[extend].formats)
for xmlVideoProfiles in xmlVideoCodec.findall('videoprofiles'):
videoProfileStructName = xmlVideoProfiles.get('struct')
videoProfileStructMembers : dict[str, VideoProfileMember] = {}
for xmlVideoProfileMember in xmlVideoProfiles.findall('videoprofilemember'):
memberName = xmlVideoProfileMember.get('name')
memberValues: dict[str, str] = {}
for xmlVideoProfile in xmlVideoProfileMember.findall('videoprofile'):
memberValues[xmlVideoProfile.get('value')] = xmlVideoProfile.get('name')
videoProfileStructMembers[memberName] = VideoProfileMember(memberName, memberValues)
profiles[videoProfileStructName] = VideoProfiles(videoProfileStructName, videoProfileStructMembers)
for xmlVideoCapabilities in xmlVideoCodec.findall('videocapabilities'):
capabilities[xmlVideoCapabilities.get('struct')] = xmlVideoCapabilities.get('struct')
for xmlVideoFormat in xmlVideoCodec.findall('videoformat'):
videoFormatName = xmlVideoFormat.get('name')
videoFormatExtend = xmlVideoFormat.get('extend')
videoFormatRequiredCaps: list[VideoRequiredCapabilities] = []
videoFormatProps: dict[str, str] = {}
if videoFormatName is not None:
# This is a new video format category
videoFormatUsage = xmlVideoFormat.get('usage')
videoFormat = VideoFormat(videoFormatName, videoFormatUsage, videoFormatRequiredCaps, videoFormatProps)
formats[videoFormatName] = videoFormat
else:
# This is an extension to an already defined video format category
videoFormat = formats[videoFormatExtend]
videoFormatRequiredCaps = videoFormat.requiredCaps
videoFormatProps = videoFormat.properties
for xmlVideoFormatRequiredCap in xmlVideoFormat.findall('videorequirecapabilities'):
requiredCap = VideoRequiredCapabilities(xmlVideoFormatRequiredCap.get('struct'),
xmlVideoFormatRequiredCap.get('member'),
xmlVideoFormatRequiredCap.get('value'))
videoFormatRequiredCaps.append(requiredCap)
for xmlVideoFormatProperties in xmlVideoFormat.findall('videoformatproperties'):
videoFormatProps[xmlVideoFormatProperties.get('struct')] = xmlVideoFormatProperties.get('struct')
self.vk.videoCodecs[name] = VideoCodec(name, value, profiles, capabilities, formats)
def endFile(self): def endFile(self):
# This is the point were reg.py has ran, everything is collected # This is the point were reg.py has ran, everything is collected
# We do some post processing now # We do some post processing now
self.applyExtensionDependency() self.applyExtensionDependency()
self.addConstants() self.addConstants([k for k,v in self.registry.enumvaluedict.items() if v == 'API Constants'])
self.addVideoCodecs()
self.vk.headerVersionComplete = APISpecific.createHeaderVersion(self.targetApiName, self.vk) self.vk.headerVersionComplete = APISpecific.createHeaderVersion(self.targetApiName, self.vk)
@ -463,10 +546,6 @@ class BaseGenerator(OutputGenerator):
handle.device = next_parent.name == 'VkDevice' handle.device = next_parent.name == 'VkDevice'
next_parent = next_parent.parent next_parent = next_parent.parent
# This use to be Queues.ALL, but there is no real concept of "all"
# Found this just needs to be something non-None
maxSyncSupport.queues = Queues.TRANSFER
maxSyncSupport.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags maxSyncSupport.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
maxSyncEquivalent.accesses = self.vk.bitmasks['VkAccessFlagBits2'].flags maxSyncEquivalent.accesses = self.vk.bitmasks['VkAccessFlagBits2'].flags
maxSyncEquivalent.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags maxSyncEquivalent.stages = self.vk.bitmasks['VkPipelineStageFlagBits2'].flags
@ -789,6 +868,9 @@ class BaseGenerator(OutputGenerator):
if fixedSizeArray and not length: if fixedSizeArray and not length:
length = ','.join(fixedSizeArray) length = ','.join(fixedSizeArray)
# Handle C bit field members
bitFieldWidth = int(cdecl.split(':')[1]) if ':' in cdecl else None
# if a pointer, this can be a something like: # if a pointer, this can be a something like:
# optional="true,false" for ppGeometries # optional="true,false" for ppGeometries
# optional="false,true" for pPhysicalDeviceCount # optional="false,true" for pPhysicalDeviceCount
@ -801,7 +883,7 @@ class BaseGenerator(OutputGenerator):
members.append(Member(name, type, fullType, noautovalidity, limittype, members.append(Member(name, type, fullType, noautovalidity, limittype,
const, length, nullTerminated, pointer, fixedSizeArray, const, length, nullTerminated, pointer, fixedSizeArray,
optional, optionalPointer, optional, optionalPointer,
externSync, cdecl)) externSync, cdecl, bitFieldWidth))
self.vk.structs[typeName] = Struct(typeName, [], extension, self.currentVersion, protect, members, self.vk.structs[typeName] = Struct(typeName, [], extension, self.currentVersion, protect, members,
union, returnedOnly, sType, allowDuplicate, extends, extendedBy) union, returnedOnly, sType, allowDuplicate, extends, extendedBy)
@ -975,3 +1057,119 @@ class BaseGenerator(OutputGenerator):
stages.append(SyncPipelineStage(order, before, after, value)) stages.append(SyncPipelineStage(order, before, after, value))
self.vk.syncPipeline.append(SyncPipeline(name, depends, stages)) self.vk.syncPipeline.append(SyncPipeline(name, depends, stages))
#
# This object handles all the parsing from the video.xml (i.e. Video Std header definitions)
# It will fill in video standard definitions into the VulkanObject
class _VideoStdGenerator(BaseGenerator):
def __init__(self):
BaseGenerator.__init__(self)
self.vk.videoStd = VideoStd()
# Track the current Video Std header we are processing
self.currentVideoStdHeader = None
def write(self, data):
# We do not write anything here
return
def beginFile(self, genOpts):
# We intentionally skip default BaseGenerator behavior
OutputGenerator.beginFile(self, genOpts)
def endFile(self):
# Move parsed definitions to the Video Std definitions
self.vk.videoStd.enums = self.vk.enums
self.vk.videoStd.structs = self.vk.structs
self.vk.videoStd.constants = self.vk.constants
# We intentionally skip default BaseGenerator behavior
OutputGenerator.endFile(self)
def beginFeature(self, interface, emit):
# We intentionally skip default BaseGenerator behavior
OutputGenerator.beginFeature(self, interface, emit)
# Only "extension" is possible in the video.xml, identifying the Video Std header
assert interface.tag == 'extension'
name = interface.get('name')
version: (str | None) = None
depends: list[str] = []
# Handle Video Std header version constant
for enum in interface.findall('require/enum[@value]'):
enumName = enum.get('name')
if enumName.endswith('_SPEC_VERSION'):
version = enum.get('value')
# Handle dependencies on other Video Std headers
for type in interface.findall('require/type[@name]'):
typeName = type.get('name')
if typeName.startswith('vk_video/'):
depends.append(typeName[len('vk_video/'):-len('.h')])
headerFile = f'vk_video/{name}.h'
self.vk.videoStd.headers[name] = VideoStdHeader(name, version, headerFile, depends)
self.currentVideoStdHeader = self.vk.videoStd.headers[name]
# Handle constants here as that seems the most straightforward
constantNames = []
for enum in interface.findall('require/enum[@type]'):
constantNames.append(enum.get('name'))
self.addConstants(constantNames)
for constantName in constantNames:
self.vk.constants[constantName].videoStdHeader = self.currentVideoStdHeader.name
def endFeature(self):
self.currentVideoStdHeader = None
# We intentionally skip default BaseGenerator behavior
OutputGenerator.endFeature(self)
def genCmd(self, cmdinfo, name, alias):
# video.xml should not contain any commands
assert False
def genGroup(self, groupinfo, groupName, alias):
BaseGenerator.genGroup(self, groupinfo, groupName, alias)
# We are supposed to be inside a video std header
assert self.currentVideoStdHeader is not None
# Mark the enum with the Video Std header it comes from
if groupinfo.elem.get('type') == 'enum':
assert alias is None
self.vk.enums[groupName].videoStdHeader = self.currentVideoStdHeader.name
def genType(self, typeInfo, typeName, alias):
BaseGenerator.genType(self, typeInfo, typeName, alias)
# We are supposed to be inside a video std header
assert self.currentVideoStdHeader is not None
# Mark the struct with the Video Std header it comes from
if typeInfo.elem.get('category') == 'struct':
assert alias is None
self.vk.structs[typeName].videoStdHeader = self.currentVideoStdHeader.name
def genSpirv(self, spirvinfo, spirvName, alias):
# video.xml should not contain any SPIR-V info
assert False
def genFormat(self, format, formatinfo, alias):
# video.xml should not contain any format info
assert False
def genSyncStage(self, sync):
# video.xml should not contain any sync stage info
assert False
def genSyncAccess(self, sync):
# video.xml should not contain any sync access info
assert False
def genSyncPipeline(self, sync):
# video.xml should not contain any sync pipeline info
assert False

928
registry/validusage.json
View file

File diff suppressed because it is too large Load diff

217
registry/video.xml
View file

@ -123,7 +123,7 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint8_t</type> <name>chroma_sample_loc_type_top_field</name></member> <member><type>uint8_t</type> <name>chroma_sample_loc_type_top_field</name></member>
<member><type>uint8_t</type> <name>chroma_sample_loc_type_bottom_field</name></member> <member><type>uint8_t</type> <name>chroma_sample_loc_type_bottom_field</name></member>
<member><type>uint32_t</type> <name>reserved1</name><comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint32_t</type> <name>reserved1</name><comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoH264HrdParameters</type>* <name>pHrdParameters</name><comment>must be a valid ptr to hrd_parameters, if nal_hrd_parameters_present_flag or vcl_hrd_parameters_present_flag are set</comment></member> <member optional="true">const <type>StdVideoH264HrdParameters</type>* <name>pHrdParameters</name><comment>must be a valid ptr to hrd_parameters, if nal_hrd_parameters_present_flag or vcl_hrd_parameters_present_flag are set</comment></member>
</type> </type>
<type category="struct" name="StdVideoH264SpsFlags"> <type category="struct" name="StdVideoH264SpsFlags">
<member><type>uint32_t</type> <name>constraint_set0_flag</name> : 1</member> <member><type>uint32_t</type> <name>constraint_set0_flag</name> : 1</member>
@ -190,9 +190,9 @@ The current public version of video.xml is maintained in the default branch
pOffsetForRefFrame is a pointer representing the offset_for_ref_frame array with num_ref_frames_in_pic_order_cnt_cycle number of elements. pOffsetForRefFrame is a pointer representing the offset_for_ref_frame array with num_ref_frames_in_pic_order_cnt_cycle number of elements.
If pOffsetForRefFrame has nullptr value, then num_ref_frames_in_pic_order_cnt_cycle must also be "0". If pOffsetForRefFrame has nullptr value, then num_ref_frames_in_pic_order_cnt_cycle must also be "0".
</comment> </comment>
<member>const <type>int32_t</type>* <name>pOffsetForRefFrame</name></member> <member len="num_ref_frames_in_pic_order_cnt_cycle">const <type>int32_t</type>* <name>pOffsetForRefFrame</name></member>
<member>const <type>StdVideoH264ScalingLists</type>* <name>pScalingLists</name><comment>Must be a valid pointer if seq_scaling_matrix_present_flag is set</comment></member> <member optional="true">const <type>StdVideoH264ScalingLists</type>* <name>pScalingLists</name><comment>Must be a valid pointer if seq_scaling_matrix_present_flag is set</comment></member>
<member>const <type>StdVideoH264SequenceParameterSetVui</type>* <name>pSequenceParameterSetVui</name><comment>Must be a valid pointer if StdVideoH264SpsFlags:vui_parameters_present_flag is set</comment></member> <member optional="true">const <type>StdVideoH264SequenceParameterSetVui</type>* <name>pSequenceParameterSetVui</name><comment>Must be a valid pointer if StdVideoH264SpsFlags:vui_parameters_present_flag is set</comment></member>
</type> </type>
<type category="struct" name="StdVideoH264PpsFlags"> <type category="struct" name="StdVideoH264PpsFlags">
<member><type>uint32_t</type> <name>transform_8x8_mode_flag</name> : 1</member> <member><type>uint32_t</type> <name>transform_8x8_mode_flag</name> : 1</member>
@ -215,7 +215,7 @@ The current public version of video.xml is maintained in the default branch
<member><type>int8_t</type> <name>pic_init_qs_minus26</name></member> <member><type>int8_t</type> <name>pic_init_qs_minus26</name></member>
<member><type>int8_t</type> <name>chroma_qp_index_offset</name></member> <member><type>int8_t</type> <name>chroma_qp_index_offset</name></member>
<member><type>int8_t</type> <name>second_chroma_qp_index_offset</name></member> <member><type>int8_t</type> <name>second_chroma_qp_index_offset</name></member>
<member>const <type>StdVideoH264ScalingLists</type>* <name>pScalingLists</name><comment>Must be a valid pointer if StdVideoH264PpsFlags::pic_scaling_matrix_present_flag is set.</comment></member> <member optional="true">const <type>StdVideoH264ScalingLists</type>* <name>pScalingLists</name><comment>Must be a valid pointer if StdVideoH264PpsFlags::pic_scaling_matrix_present_flag is set.</comment></member>
</type> </type>
<!-- vulkan_video_codec_h264std_decode.h enumerated types --> <!-- vulkan_video_codec_h264std_decode.h enumerated types -->
@ -329,9 +329,9 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint8_t</type> <name>refList1ModOpCount</name></member> <member><type>uint8_t</type> <name>refList1ModOpCount</name></member>
<member><type>uint8_t</type> <name>refPicMarkingOpCount</name></member> <member><type>uint8_t</type> <name>refPicMarkingOpCount</name></member>
<member><type>uint8_t</type> <name>reserved1</name>[7]<comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint8_t</type> <name>reserved1</name>[7]<comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoEncodeH264RefListModEntry</type>* <name>pRefList0ModOperations</name><comment>Must be a valid pointer to an array with size refList0ModOpCount if ref_pic_list_modification_flag_l0 is set and contains the RefList0 modification parameters as defined in section 7.4.3.1</comment></member> <member len="refList0ModOpCount">const <type>StdVideoEncodeH264RefListModEntry</type>* <name>pRefList0ModOperations</name><comment>Must be a valid pointer to an array with size refList0ModOpCount if ref_pic_list_modification_flag_l0 is set and contains the RefList0 modification parameters as defined in section 7.4.3.1</comment></member>
<member>const <type>StdVideoEncodeH264RefListModEntry</type>* <name>pRefList1ModOperations</name><comment>Must be a valid pointer to an array with size refList1ModOpCount if ref_pic_list_modification_flag_l1 is set and contains the RefList1 modification parameters as defined in section 7.4.3.1</comment></member> <member len="refList1ModOpCount">const <type>StdVideoEncodeH264RefListModEntry</type>* <name>pRefList1ModOperations</name><comment>Must be a valid pointer to an array with size refList1ModOpCount if ref_pic_list_modification_flag_l1 is set and contains the RefList1 modification parameters as defined in section 7.4.3.1</comment></member>
<member>const <type>StdVideoEncodeH264RefPicMarkingEntry</type>* <name>pRefPicMarkingOperations</name><comment>Must be a valid pointer to an array with size refPicMarkingOpCount and contains the reference picture markings as defined in section 7.4.3.3</comment></member> <member len="refPicMarkingOpCount">const <type>StdVideoEncodeH264RefPicMarkingEntry</type>* <name>pRefPicMarkingOperations</name><comment>Must be a valid pointer to an array with size refPicMarkingOpCount and contains the reference picture markings as defined in section 7.4.3.3</comment></member>
</type> </type>
<type category="struct" name="StdVideoEncodeH264PictureInfo"> <type category="struct" name="StdVideoEncodeH264PictureInfo">
<member><type>StdVideoEncodeH264PictureInfoFlags</type> <name>flags</name></member> <member><type>StdVideoEncodeH264PictureInfoFlags</type> <name>flags</name></member>
@ -343,7 +343,7 @@ The current public version of video.xml is maintained in the default branch
<member><type>int32_t</type> <name>PicOrderCnt</name><comment>Picture order count, as defined in 8.2</comment></member> <member><type>int32_t</type> <name>PicOrderCnt</name><comment>Picture order count, as defined in 8.2</comment></member>
<member><type>uint8_t</type> <name>temporal_id</name><comment>Temporal identifier of the picture, as defined in G.7.3.1.1 / G.7.4.1.1</comment></member> <member><type>uint8_t</type> <name>temporal_id</name><comment>Temporal identifier of the picture, as defined in G.7.3.1.1 / G.7.4.1.1</comment></member>
<member><type>uint8_t</type> <name>reserved1</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint8_t</type> <name>reserved1</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoEncodeH264ReferenceListsInfo</type>* <name>pRefLists</name></member> <member optional="true">const <type>StdVideoEncodeH264ReferenceListsInfo</type>* <name>pRefLists</name></member>
</type> </type>
<type category="struct" name="StdVideoEncodeH264ReferenceInfo"> <type category="struct" name="StdVideoEncodeH264ReferenceInfo">
<member><type>StdVideoEncodeH264ReferenceInfoFlags</type> <name>flags</name></member> <member><type>StdVideoEncodeH264ReferenceInfoFlags</type> <name>flags</name></member>
@ -364,7 +364,7 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint8_t</type> <name>reserved1</name><comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint8_t</type> <name>reserved1</name><comment>Reserved for future use and must be initialized with 0.</comment></member>
<member><type>StdVideoH264CabacInitIdc</type> <name>cabac_init_idc</name></member> <member><type>StdVideoH264CabacInitIdc</type> <name>cabac_init_idc</name></member>
<member><type>StdVideoH264DisableDeblockingFilterIdc</type> <name>disable_deblocking_filter_idc</name></member> <member><type>StdVideoH264DisableDeblockingFilterIdc</type> <name>disable_deblocking_filter_idc</name></member>
<member>const <type>StdVideoEncodeH264WeightTable</type>* <name>pWeightTable</name><comment></comment></member> <member optional="true">const <type>StdVideoEncodeH264WeightTable</type>* <name>pWeightTable</name><comment></comment></member>
</type> </type>
<!-- vulkan_video_codec_h265std.h enumerated types --> <!-- vulkan_video_codec_h265std.h enumerated types -->
@ -423,8 +423,9 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint8_t</type> <name>cpb_cnt_minus1</name>[<enum>STD_VIDEO_H265_SUBLAYERS_LIST_SIZE</enum>]</member> <member><type>uint8_t</type> <name>cpb_cnt_minus1</name>[<enum>STD_VIDEO_H265_SUBLAYERS_LIST_SIZE</enum>]</member>
<member><type>uint16_t</type> <name>elemental_duration_in_tc_minus1</name>[<enum>STD_VIDEO_H265_SUBLAYERS_LIST_SIZE</enum>]</member> <member><type>uint16_t</type> <name>elemental_duration_in_tc_minus1</name>[<enum>STD_VIDEO_H265_SUBLAYERS_LIST_SIZE</enum>]</member>
<member><type>uint16_t</type> <name>reserved</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint16_t</type> <name>reserved</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoH265SubLayerHrdParameters</type>* <name>pSubLayerHrdParametersNal</name><comment>if flags.nal_hrd_parameters_present_flag is set, then this must be a ptr to an array of StdVideoH265SubLayerHrdParameters with a size specified by sps_max_sub_layers_minus1 + 1 or vps_max_sub_layers_minus1 + 1, depending on whether the HRD parameters are part of the SPS or VPS, respectively.</comment></member> <!-- NOTE: These arrays are sized according to parameters coming from their encompassing structures -->
<member>const <type>StdVideoH265SubLayerHrdParameters</type>* <name>pSubLayerHrdParametersVcl</name><comment>if flags.vcl_hrd_parameters_present_flag is set, then this must be a ptr to an array of StdVideoH265SubLayerHrdParameters with a size specified by sps_max_sub_layers_minus1 + 1 or vps_max_sub_layers_minus1 + 1, depending on whether the HRD parameters are part of the SPS or VPS, respectively.</comment></member> <member optional="true" len="sps_max_sub_layers_minus1 + 1,vps_max_sub_layers_minus1 + 1">const <type>StdVideoH265SubLayerHrdParameters</type>* <name>pSubLayerHrdParametersNal</name><comment>if flags.nal_hrd_parameters_present_flag is set, then this must be a ptr to an array of StdVideoH265SubLayerHrdParameters with a size specified by sps_max_sub_layers_minus1 + 1 or vps_max_sub_layers_minus1 + 1, depending on whether the HRD parameters are part of the SPS or VPS, respectively.</comment></member>
<member optional="true" len="sps_max_sub_layers_minus1 + 1,vps_max_sub_layers_minus1 + 1">const <type>StdVideoH265SubLayerHrdParameters</type>* <name>pSubLayerHrdParametersVcl</name><comment>if flags.vcl_hrd_parameters_present_flag is set, then this must be a ptr to an array of StdVideoH265SubLayerHrdParameters with a size specified by sps_max_sub_layers_minus1 + 1 or vps_max_sub_layers_minus1 + 1, depending on whether the HRD parameters are part of the SPS or VPS, respectively.</comment></member>
</type> </type>
<type category="struct" name="StdVideoH265VpsFlags"> <type category="struct" name="StdVideoH265VpsFlags">
<member><type>uint32_t</type> <name>vps_temporal_id_nesting_flag</name> : 1</member> <member><type>uint32_t</type> <name>vps_temporal_id_nesting_flag</name> : 1</member>
@ -442,9 +443,9 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint32_t</type> <name>vps_time_scale</name></member> <member><type>uint32_t</type> <name>vps_time_scale</name></member>
<member><type>uint32_t</type> <name>vps_num_ticks_poc_diff_one_minus1</name></member> <member><type>uint32_t</type> <name>vps_num_ticks_poc_diff_one_minus1</name></member>
<member><type>uint32_t</type> <name>reserved3</name><comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint32_t</type> <name>reserved3</name><comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoH265DecPicBufMgr</type>* <name>pDecPicBufMgr</name></member> <member optional="true">const <type>StdVideoH265DecPicBufMgr</type>* <name>pDecPicBufMgr</name></member>
<member>const <type>StdVideoH265HrdParameters</type>* <name>pHrdParameters</name></member> <member optional="true">const <type>StdVideoH265HrdParameters</type>* <name>pHrdParameters</name></member>
<member>const <type>StdVideoH265ProfileTierLevel</type>* <name>pProfileTierLevel</name></member> <member optional="true">const <type>StdVideoH265ProfileTierLevel</type>* <name>pProfileTierLevel</name></member>
</type> </type>
<type category="struct" name="StdVideoH265ScalingLists"> <type category="struct" name="StdVideoH265ScalingLists">
<member><type>uint8_t</type> <name>ScalingList4x4</name>[<enum>STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS</enum>][<enum>STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS</enum>]<comment>ScalingList[ 0 ][ MatrixID ][ i ] (sizeID = 0)</comment></member> <member><type>uint8_t</type> <name>ScalingList4x4</name>[<enum>STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS</enum>][<enum>STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS</enum>]<comment>ScalingList[ 0 ][ MatrixID ][ i ] (sizeID = 0)</comment></member>
@ -524,7 +525,7 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint8_t</type> <name>max_bits_per_min_cu_denom</name></member> <member><type>uint8_t</type> <name>max_bits_per_min_cu_denom</name></member>
<member><type>uint8_t</type> <name>log2_max_mv_length_horizontal</name></member> <member><type>uint8_t</type> <name>log2_max_mv_length_horizontal</name></member>
<member><type>uint8_t</type> <name>log2_max_mv_length_vertical</name></member> <member><type>uint8_t</type> <name>log2_max_mv_length_vertical</name></member>
<member>const <type>StdVideoH265HrdParameters</type>* <name>pHrdParameters</name></member> <member optional="true">const <type>StdVideoH265HrdParameters</type>* <name>pHrdParameters</name></member>
</type> </type>
<type category="struct" name="StdVideoH265PredictorPaletteEntries"> <type category="struct" name="StdVideoH265PredictorPaletteEntries">
<member><type>uint16_t</type> <name>PredictorPaletteEntries</name>[<enum>STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE</enum>][<enum>STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE</enum>]</member> <member><type>uint16_t</type> <name>PredictorPaletteEntries</name>[<enum>STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE</enum>][<enum>STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE</enum>]</member>
@ -606,13 +607,13 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint32_t</type> <name>conf_win_right_offset</name></member> <member><type>uint32_t</type> <name>conf_win_right_offset</name></member>
<member><type>uint32_t</type> <name>conf_win_top_offset</name></member> <member><type>uint32_t</type> <name>conf_win_top_offset</name></member>
<member><type>uint32_t</type> <name>conf_win_bottom_offset</name></member> <member><type>uint32_t</type> <name>conf_win_bottom_offset</name></member>
<member>const <type>StdVideoH265ProfileTierLevel</type>* <name>pProfileTierLevel</name></member> <member optional="true">const <type>StdVideoH265ProfileTierLevel</type>* <name>pProfileTierLevel</name></member>
<member>const <type>StdVideoH265DecPicBufMgr</type>* <name>pDecPicBufMgr</name></member> <member optional="true">const <type>StdVideoH265DecPicBufMgr</type>* <name>pDecPicBufMgr</name></member>
<member>const <type>StdVideoH265ScalingLists</type>* <name>pScalingLists</name><comment>Must be a valid pointer if sps_scaling_list_data_present_flag is set</comment></member> <member optional="true">const <type>StdVideoH265ScalingLists</type>* <name>pScalingLists</name><comment>Must be a valid pointer if sps_scaling_list_data_present_flag is set</comment></member>
<member>const <type>StdVideoH265ShortTermRefPicSet</type>* <name>pShortTermRefPicSet</name><comment>Must be a valid pointer to an array with size num_short_term_ref_pic_sets if num_short_term_ref_pic_sets is not 0.</comment></member> <member len="num_short_term_ref_pic_sets">const <type>StdVideoH265ShortTermRefPicSet</type>* <name>pShortTermRefPicSet</name><comment>Must be a valid pointer to an array with size num_short_term_ref_pic_sets if num_short_term_ref_pic_sets is not 0.</comment></member>
<member>const <type>StdVideoH265LongTermRefPicsSps</type>* <name>pLongTermRefPicsSps</name><comment>Must be a valid pointer if long_term_ref_pics_present_flag is set</comment></member> <member optional="true">const <type>StdVideoH265LongTermRefPicsSps</type>* <name>pLongTermRefPicsSps</name><comment>Must be a valid pointer if long_term_ref_pics_present_flag is set</comment></member>
<member>const <type>StdVideoH265SequenceParameterSetVui</type>* <name>pSequenceParameterSetVui</name><comment>Must be a valid pointer if StdVideoH265SpsFlags:vui_parameters_present_flag is set palette_max_size</comment></member> <member optional="true">const <type>StdVideoH265SequenceParameterSetVui</type>* <name>pSequenceParameterSetVui</name><comment>Must be a valid pointer if StdVideoH265SpsFlags:vui_parameters_present_flag is set palette_max_size</comment></member>
<member>const <type>StdVideoH265PredictorPaletteEntries</type>* <name>pPredictorPaletteEntries</name><comment>Must be a valid pointer if sps_palette_predictor_initializer_present_flag is set</comment></member> <member optional="true">const <type>StdVideoH265PredictorPaletteEntries</type>* <name>pPredictorPaletteEntries</name><comment>Must be a valid pointer if sps_palette_predictor_initializer_present_flag is set</comment></member>
</type> </type>
<type category="struct" name="StdVideoH265PpsFlags"> <type category="struct" name="StdVideoH265PpsFlags">
<member><type>uint32_t</type> <name>dependent_slice_segments_enabled_flag</name> : 1</member> <member><type>uint32_t</type> <name>dependent_slice_segments_enabled_flag</name> : 1</member>
@ -694,8 +695,8 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint16_t</type> <name>column_width_minus1</name>[<enum>STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE</enum>]</member> <member><type>uint16_t</type> <name>column_width_minus1</name>[<enum>STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE</enum>]</member>
<member><type>uint16_t</type> <name>row_height_minus1</name>[<enum>STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE</enum>]</member> <member><type>uint16_t</type> <name>row_height_minus1</name>[<enum>STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE</enum>]</member>
<member><type>uint32_t</type> <name>reserved3</name><comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint32_t</type> <name>reserved3</name><comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoH265ScalingLists</type>* <name>pScalingLists</name><comment>Must be a valid pointer if pps_scaling_list_data_present_flag is set</comment></member> <member optional="true">const <type>StdVideoH265ScalingLists</type>* <name>pScalingLists</name><comment>Must be a valid pointer if pps_scaling_list_data_present_flag is set</comment></member>
<member>const <type>StdVideoH265PredictorPaletteEntries</type>* <name>pPredictorPaletteEntries</name><comment>Must be a valid pointer if pps_palette_predictor_initializer_present_flag is set</comment></member> <member optional="true">const <type>StdVideoH265PredictorPaletteEntries</type>* <name>pPredictorPaletteEntries</name><comment>Must be a valid pointer if pps_palette_predictor_initializer_present_flag is set</comment></member>
</type> </type>
<!-- vulkan_video_codec_h265std_decode.h structs --> <!-- vulkan_video_codec_h265std_decode.h structs -->
@ -793,7 +794,7 @@ The current public version of video.xml is maintained in the default branch
<member><type>int8_t</type> <name>slice_act_cr_qp_offset</name></member> <member><type>int8_t</type> <name>slice_act_cr_qp_offset</name></member>
<member><type>int8_t</type> <name>slice_qp_delta</name></member> <member><type>int8_t</type> <name>slice_qp_delta</name></member>
<member><type>uint16_t</type> <name>reserved1</name><comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint16_t</type> <name>reserved1</name><comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoEncodeH265WeightTable</type>* <name>pWeightTable</name><comment></comment></member> <member optional="true">const <type>StdVideoEncodeH265WeightTable</type>* <name>pWeightTable</name><comment></comment></member>
</type> </type>
<type category="struct" name="StdVideoEncodeH265ReferenceListsInfoFlags"> <type category="struct" name="StdVideoEncodeH265ReferenceListsInfoFlags">
<member><type>uint32_t</type> <name>ref_pic_list_modification_flag_l0</name> : 1</member> <member><type>uint32_t</type> <name>ref_pic_list_modification_flag_l0</name> : 1</member>
@ -831,9 +832,9 @@ The current public version of video.xml is maintained in the default branch
<member><type>int32_t</type> <name>PicOrderCntVal</name><comment>Picture order count derived as specified in 8.3.1</comment></member> <member><type>int32_t</type> <name>PicOrderCntVal</name><comment>Picture order count derived as specified in 8.3.1</comment></member>
<member><type>uint8_t</type> <name>TemporalId</name><comment>Temporal ID, as defined in 7.4.2.2</comment></member> <member><type>uint8_t</type> <name>TemporalId</name><comment>Temporal ID, as defined in 7.4.2.2</comment></member>
<member><type>uint8_t</type> <name>reserved1</name>[7]<comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint8_t</type> <name>reserved1</name>[7]<comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoEncodeH265ReferenceListsInfo</type>* <name>pRefLists</name></member> <member optional="true">const <type>StdVideoEncodeH265ReferenceListsInfo</type>* <name>pRefLists</name></member>
<member>const <type>StdVideoH265ShortTermRefPicSet</type>* <name>pShortTermRefPicSet</name><comment>Must be a valid pointer if short_term_ref_pic_set_sps_flag is not set</comment></member> <member optional="true">const <type>StdVideoH265ShortTermRefPicSet</type>* <name>pShortTermRefPicSet</name><comment>Must be a valid pointer if short_term_ref_pic_set_sps_flag is not set</comment></member>
<member>const <type>StdVideoEncodeH265LongTermRefPics</type>* <name>pLongTermRefPics</name><comment>Must be a valid pointer if long_term_ref_pics_present_flag is set</comment></member> <member optional="true">const <type>StdVideoEncodeH265LongTermRefPics</type>* <name>pLongTermRefPics</name><comment>Must be a valid pointer if long_term_ref_pics_present_flag is set</comment></member>
</type> </type>
<type category="struct" name="StdVideoEncodeH265ReferenceInfoFlags"> <type category="struct" name="StdVideoEncodeH265ReferenceInfoFlags">
<member><type>uint32_t</type> <name>used_for_long_term_reference</name> : 1<comment>A picture that is marked as "used for long-term reference", derived binary value from clause 8.3.2 Decoding process for reference picture set</comment></member> <member><type>uint32_t</type> <name>used_for_long_term_reference</name> : 1<comment>A picture that is marked as "used for long-term reference", derived binary value from clause 8.3.2 Decoding process for reference picture set</comment></member>
@ -933,7 +934,7 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint16_t</type> <name>reserved1</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint16_t</type> <name>reserved1</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoVP9ColorConfig</type>* <name>pColorConfig</name></member> <member>const <type>StdVideoVP9ColorConfig</type>* <name>pColorConfig</name></member>
<member>const <type>StdVideoVP9LoopFilter</type>* <name>pLoopFilter</name></member> <member>const <type>StdVideoVP9LoopFilter</type>* <name>pLoopFilter</name></member>
<member>const <type>StdVideoVP9Segmentation</type>* <name>pSegmentation</name></member> <member optional="true">const <type>StdVideoVP9Segmentation</type>* <name>pSegmentation</name></member>
</type> </type>
<!-- vulkan_video_codec_av1std.h enumerated types --> <!-- vulkan_video_codec_av1std.h enumerated types -->
@ -1019,7 +1020,7 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint8_t</type> <name>seq_force_screen_content_tools</name><comment>The final value of of seq_force_screen_content_tools per the value of seq_choose_screen_content_tools.</comment></member> <member><type>uint8_t</type> <name>seq_force_screen_content_tools</name><comment>The final value of of seq_force_screen_content_tools per the value of seq_choose_screen_content_tools.</comment></member>
<member><type>uint8_t</type> <name>reserved1</name>[5]<comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint8_t</type> <name>reserved1</name>[5]<comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoAV1ColorConfig</type>* <name>pColorConfig</name></member> <member>const <type>StdVideoAV1ColorConfig</type>* <name>pColorConfig</name></member>
<member>const <type>StdVideoAV1TimingInfo</type>* <name>pTimingInfo</name></member> <member optional="true">const <type>StdVideoAV1TimingInfo</type>* <name>pTimingInfo</name></member>
</type> </type>
<type category="struct" name="StdVideoAV1LoopFilterFlags"> <type category="struct" name="StdVideoAV1LoopFilterFlags">
<comment>Syntax defined in section 5.9.11, semantics defined in section 6.8.10</comment> <comment>Syntax defined in section 5.9.11, semantics defined in section 6.8.10</comment>
@ -1074,10 +1075,10 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint16_t</type> <name>context_update_tile_id</name></member> <member><type>uint16_t</type> <name>context_update_tile_id</name></member>
<member><type>uint8_t</type> <name>tile_size_bytes_minus_1</name></member> <member><type>uint8_t</type> <name>tile_size_bytes_minus_1</name></member>
<member><type>uint8_t</type> <name>reserved1</name>[7]<comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint8_t</type> <name>reserved1</name>[7]<comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>uint16_t</type>* <name>pMiColStarts</name><comment>TileCols number of elements</comment></member> <member len="TileCols">const <type>uint16_t</type>* <name>pMiColStarts</name><comment>TileCols number of elements</comment></member>
<member>const <type>uint16_t</type>* <name>pMiRowStarts</name><comment>TileRows number of elements</comment></member> <member len="TileRows">const <type>uint16_t</type>* <name>pMiRowStarts</name><comment>TileRows number of elements</comment></member>
<member>const <type>uint16_t</type>* <name>pWidthInSbsMinus1</name><comment>TileCols number of elements</comment></member> <member len="TileCols">const <type>uint16_t</type>* <name>pWidthInSbsMinus1</name><comment>TileCols number of elements</comment></member>
<member>const <type>uint16_t</type>* <name>pHeightInSbsMinus1</name><comment>TileRows number of elements</comment></member> <member len="TileRows">const <type>uint16_t</type>* <name>pHeightInSbsMinus1</name><comment>TileRows number of elements</comment></member>
</type> </type>
<type category="struct" name="StdVideoAV1CDEF"> <type category="struct" name="StdVideoAV1CDEF">
<comment>Syntax defined in section 5.9.19, semantics defined in section 6.10.14</comment> <comment>Syntax defined in section 5.9.19, semantics defined in section 6.10.14</comment>
@ -1187,12 +1188,12 @@ The current public version of video.xml is maintained in the default branch
<member><type>uint32_t</type> <name>expectedFrameId</name>[<enum>STD_VIDEO_AV1_NUM_REF_FRAMES</enum>]</member> <member><type>uint32_t</type> <name>expectedFrameId</name>[<enum>STD_VIDEO_AV1_NUM_REF_FRAMES</enum>]</member>
<member>const <type>StdVideoAV1TileInfo</type>* <name>pTileInfo</name></member> <member>const <type>StdVideoAV1TileInfo</type>* <name>pTileInfo</name></member>
<member>const <type>StdVideoAV1Quantization</type>* <name>pQuantization</name></member> <member>const <type>StdVideoAV1Quantization</type>* <name>pQuantization</name></member>
<member>const <type>StdVideoAV1Segmentation</type>* <name>pSegmentation</name></member> <member optional="true">const <type>StdVideoAV1Segmentation</type>* <name>pSegmentation</name></member>
<member>const <type>StdVideoAV1LoopFilter</type>* <name>pLoopFilter</name></member> <member>const <type>StdVideoAV1LoopFilter</type>* <name>pLoopFilter</name></member>
<member>const <type>StdVideoAV1CDEF</type>* <name>pCDEF</name></member> <member optional="true">const <type>StdVideoAV1CDEF</type>* <name>pCDEF</name></member>
<member>const <type>StdVideoAV1LoopRestoration</type>* <name>pLoopRestoration</name></member> <member optional="true">const <type>StdVideoAV1LoopRestoration</type>* <name>pLoopRestoration</name></member>
<member>const <type>StdVideoAV1GlobalMotion</type>* <name>pGlobalMotion</name></member> <member>const <type>StdVideoAV1GlobalMotion</type>* <name>pGlobalMotion</name></member>
<member>const <type>StdVideoAV1FilmGrain</type>* <name>pFilmGrain</name></member> <member optional="true">const <type>StdVideoAV1FilmGrain</type>* <name>pFilmGrain</name></member>
</type> </type>
<type category="struct" name="StdVideoDecodeAV1ReferenceInfoFlags"> <type category="struct" name="StdVideoDecodeAV1ReferenceInfoFlags">
<member><type>uint32_t</type> <name>disable_frame_end_update_cdf</name> : 1</member> <member><type>uint32_t</type> <name>disable_frame_end_update_cdf</name> : 1</member>
@ -1286,15 +1287,15 @@ The current public version of video.xml is maintained in the default branch
<member><type>int8_t</type> <name>ref_frame_idx</name>[<enum>STD_VIDEO_AV1_REFS_PER_FRAME</enum>]</member> <member><type>int8_t</type> <name>ref_frame_idx</name>[<enum>STD_VIDEO_AV1_REFS_PER_FRAME</enum>]</member>
<member><type>uint8_t</type> <name>reserved1</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint8_t</type> <name>reserved1</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member>
<member><type>uint32_t</type> <name>delta_frame_id_minus_1</name>[<enum>STD_VIDEO_AV1_REFS_PER_FRAME</enum>]</member> <member><type>uint32_t</type> <name>delta_frame_id_minus_1</name>[<enum>STD_VIDEO_AV1_REFS_PER_FRAME</enum>]</member>
<member>const <type>StdVideoAV1TileInfo</type>* <name>pTileInfo</name></member> <member optional="true">const <type>StdVideoAV1TileInfo</type>* <name>pTileInfo</name></member>
<member>const <type>StdVideoAV1Quantization</type>* <name>pQuantization</name></member> <member>const <type>StdVideoAV1Quantization</type>* <name>pQuantization</name></member>
<member>const <type>StdVideoAV1Segmentation</type>* <name>pSegmentation</name></member> <member optional="true">const <type>StdVideoAV1Segmentation</type>* <name>pSegmentation</name></member>
<member>const <type>StdVideoAV1LoopFilter</type>* <name>pLoopFilter</name></member> <member>const <type>StdVideoAV1LoopFilter</type>* <name>pLoopFilter</name></member>
<member>const <type>StdVideoAV1CDEF</type>* <name>pCDEF</name></member> <member optional="true">const <type>StdVideoAV1CDEF</type>* <name>pCDEF</name></member>
<member>const <type>StdVideoAV1LoopRestoration</type>* <name>pLoopRestoration</name></member> <member optional="true">const <type>StdVideoAV1LoopRestoration</type>* <name>pLoopRestoration</name></member>
<member>const <type>StdVideoAV1GlobalMotion</type>* <name>pGlobalMotion</name></member> <member>const <type>StdVideoAV1GlobalMotion</type>* <name>pGlobalMotion</name></member>
<member>const <type>StdVideoEncodeAV1ExtensionHeader</type>* <name>pExtensionHeader</name></member> <member optional="true">const <type>StdVideoEncodeAV1ExtensionHeader</type>* <name>pExtensionHeader</name></member>
<member>const <type>uint32_t</type>* <name>pBufferRemovalTimes</name></member> <member optional="true">const <type>uint32_t</type>* <name>pBufferRemovalTimes</name></member>
</type> </type>
<type category="struct" name="StdVideoEncodeAV1ReferenceInfoFlags"> <type category="struct" name="StdVideoEncodeAV1ReferenceInfoFlags">
<!-- TODO: Are these needed? For now it is simply copied from AV1 decode --> <!-- TODO: Are these needed? For now it is simply copied from AV1 decode -->
@ -1308,7 +1309,7 @@ The current public version of video.xml is maintained in the default branch
<member><type>StdVideoAV1FrameType</type> <name>frame_type</name></member> <member><type>StdVideoAV1FrameType</type> <name>frame_type</name></member>
<member><type>uint8_t</type> <name>OrderHint</name></member> <member><type>uint8_t</type> <name>OrderHint</name></member>
<member><type>uint8_t</type> <name>reserved1</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member> <member><type>uint8_t</type> <name>reserved1</name>[3]<comment>Reserved for future use and must be initialized with 0.</comment></member>
<member>const <type>StdVideoEncodeAV1ExtensionHeader</type>* <name>pExtensionHeader</name></member> <member optional="true">const <type>StdVideoEncodeAV1ExtensionHeader</type>* <name>pExtensionHeader</name></member>
</type> </type>
</types> </types>
@ -1722,14 +1723,14 @@ The current public version of video.xml is maintained in the default branch
<require> <require>
<type name="vk_video/vulkan_video_codecs_common.h"/> <type name="vk_video/vulkan_video_codecs_common.h"/>
<enum name="STD_VIDEO_H264_CPB_CNT_LIST_SIZE" value="32"/> <enum name="STD_VIDEO_H264_CPB_CNT_LIST_SIZE" value="32" type="uint32_t"/>
<enum name="STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS" value="6"/> <enum name="STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS" value="6" type="uint32_t"/>
<enum name="STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS" value="16"/> <enum name="STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS" value="16" type="uint32_t"/>
<enum name="STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS" value="6"/> <enum name="STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS" value="6" type="uint32_t"/>
<enum name="STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS" value="64"/> <enum name="STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS" value="64" type="uint32_t"/>
<enum name="STD_VIDEO_H264_MAX_NUM_LIST_REF" value="32"/> <enum name="STD_VIDEO_H264_MAX_NUM_LIST_REF" value="32" type="uint32_t"/>
<enum name="STD_VIDEO_H264_MAX_CHROMA_PLANES" value="2"/> <enum name="STD_VIDEO_H264_MAX_CHROMA_PLANES" value="2" type="uint32_t"/>
<enum name="STD_VIDEO_H264_NO_REFERENCE_PICTURE" value="0xFF"/> <enum name="STD_VIDEO_H264_NO_REFERENCE_PICTURE" value="0xFF" type="uint8_t"/>
<type name="StdVideoH264ChromaFormatIdc"/> <type name="StdVideoH264ChromaFormatIdc"/>
<type name="StdVideoH264ProfileIdc"/> <type name="StdVideoH264ProfileIdc"/>
@ -1763,7 +1764,7 @@ The current public version of video.xml is maintained in the default branch
<enum name="VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION" value="VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0"/> <enum name="VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION" value="VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0"/>
<enum name="VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME" value="&quot;VK_STD_vulkan_video_codec_h264_decode&quot;"/> <enum name="VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME" value="&quot;VK_STD_vulkan_video_codec_h264_decode&quot;"/>
<enum name="STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE" value="2"/> <enum name="STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE" value="2" type="uint32_t"/>
<type name="StdVideoDecodeH264FieldOrderCount"/> <type name="StdVideoDecodeH264FieldOrderCount"/>
<type name="StdVideoDecodeH264PictureInfoFlags"/> <type name="StdVideoDecodeH264PictureInfoFlags"/>
@ -1798,29 +1799,29 @@ The current public version of video.xml is maintained in the default branch
<require> <require>
<type name="vk_video/vulkan_video_codecs_common.h"/> <type name="vk_video/vulkan_video_codecs_common.h"/>
<enum name="STD_VIDEO_H265_CPB_CNT_LIST_SIZE" value="32"/> <enum name="STD_VIDEO_H265_CPB_CNT_LIST_SIZE" value="32" type="uint32_t"/>
<enum name="STD_VIDEO_H265_SUBLAYERS_LIST_SIZE" value="7"/> <enum name="STD_VIDEO_H265_SUBLAYERS_LIST_SIZE" value="7" type="uint32_t"/>
<enum name="STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS" value="6"/> <enum name="STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS" value="6" type="uint32_t"/>
<enum name="STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS" value="16"/> <enum name="STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS" value="16" type="uint32_t"/>
<enum name="STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS" value="6"/> <enum name="STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS" value="6" type="uint32_t"/>
<enum name="STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS" value="64"/> <enum name="STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS" value="64" type="uint32_t"/>
<enum name="STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS" value="6"/> <enum name="STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS" value="6" type="uint32_t"/>
<enum name="STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS" value="64"/> <enum name="STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS" value="64" type="uint32_t"/>
<enum name="STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS" value="2"/> <enum name="STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS" value="2" type="uint32_t"/>
<enum name="STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS" value="64"/> <enum name="STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS" value="64" type="uint32_t"/>
<enum name="STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE" value="6"/> <enum name="STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE" value="6" type="uint32_t"/>
<enum name="STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE" value="19"/> <enum name="STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE" value="19" type="uint32_t"/>
<enum name="STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE" value="21"/> <enum name="STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE" value="21" type="uint32_t"/>
<enum name="STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE" value="3"/> <enum name="STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE" value="3" type="uint32_t"/>
<enum name="STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE" value="128"/> <enum name="STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE" value="128" type="uint32_t"/>
<enum name="STD_VIDEO_H265_MAX_NUM_LIST_REF" value="15"/> <enum name="STD_VIDEO_H265_MAX_NUM_LIST_REF" value="15" type="uint32_t"/>
<enum name="STD_VIDEO_H265_MAX_CHROMA_PLANES" value="2"/> <enum name="STD_VIDEO_H265_MAX_CHROMA_PLANES" value="2" type="uint32_t"/>
<enum name="STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS" value="64"/> <enum name="STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS" value="64" type="uint32_t"/>
<enum name="STD_VIDEO_H265_MAX_DPB_SIZE" value="16"/> <enum name="STD_VIDEO_H265_MAX_DPB_SIZE" value="16" type="uint32_t"/>
<enum name="STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS" value="32"/> <enum name="STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS" value="32" type="uint32_t"/>
<enum name="STD_VIDEO_H265_MAX_LONG_TERM_PICS" value="16"/> <enum name="STD_VIDEO_H265_MAX_LONG_TERM_PICS" value="16" type="uint32_t"/>
<enum name="STD_VIDEO_H265_MAX_DELTA_POC" value="48"/> <enum name="STD_VIDEO_H265_MAX_DELTA_POC" value="48" type="uint32_t"/>
<enum name="STD_VIDEO_H265_NO_REFERENCE_PICTURE" value="0xFF"/> <enum name="STD_VIDEO_H265_NO_REFERENCE_PICTURE" value="0xFF" type="uint8_t"/>
<type name="StdVideoH265ChromaFormatIdc"/> <type name="StdVideoH265ChromaFormatIdc"/>
<type name="StdVideoH265ProfileIdc"/> <type name="StdVideoH265ProfileIdc"/>
@ -1857,7 +1858,7 @@ The current public version of video.xml is maintained in the default branch
<enum name="VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION" value="VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0"/> <enum name="VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION" value="VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0"/>
<enum name="VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME" value="&quot;VK_STD_vulkan_video_codec_h265_decode&quot;"/> <enum name="VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME" value="&quot;VK_STD_vulkan_video_codec_h265_decode&quot;"/>
<enum name="STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE" value="8"/> <enum name="STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE" value="8" type="uint32_t"/>
<type name="StdVideoDecodeH265PictureInfoFlags"/> <type name="StdVideoDecodeH265PictureInfoFlags"/>
<type name="StdVideoDecodeH265PictureInfo"/> <type name="StdVideoDecodeH265PictureInfo"/>
@ -1890,14 +1891,14 @@ The current public version of video.xml is maintained in the default branch
<require> <require>
<type name="vk_video/vulkan_video_codecs_common.h"/> <type name="vk_video/vulkan_video_codecs_common.h"/>
<enum name="STD_VIDEO_VP9_NUM_REF_FRAMES" value="8"/> <enum name="STD_VIDEO_VP9_NUM_REF_FRAMES" value="8" type="uint32_t"/>
<enum name="STD_VIDEO_VP9_REFS_PER_FRAME" value="3"/> <enum name="STD_VIDEO_VP9_REFS_PER_FRAME" value="3" type="uint32_t"/>
<enum name="STD_VIDEO_VP9_MAX_REF_FRAMES" value="4"/> <enum name="STD_VIDEO_VP9_MAX_REF_FRAMES" value="4" type="uint32_t"/>
<enum name="STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS" value="2"/> <enum name="STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS" value="2" type="uint32_t"/>
<enum name="STD_VIDEO_VP9_MAX_SEGMENTS" value="8"/> <enum name="STD_VIDEO_VP9_MAX_SEGMENTS" value="8" type="uint32_t"/>
<enum name="STD_VIDEO_VP9_SEG_LVL_MAX" value="4"/> <enum name="STD_VIDEO_VP9_SEG_LVL_MAX" value="4" type="uint32_t"/>
<enum name="STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS" value="7"/> <enum name="STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS" value="7" type="uint32_t"/>
<enum name="STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB" value="3"/> <enum name="STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB" value="3" type="uint32_t"/>
<type name="StdVideoVP9Profile"/> <type name="StdVideoVP9Profile"/>
<type name="StdVideoVP9Level"/> <type name="StdVideoVP9Level"/>
@ -1929,27 +1930,27 @@ The current public version of video.xml is maintained in the default branch
<require> <require>
<type name="vk_video/vulkan_video_codecs_common.h"/> <type name="vk_video/vulkan_video_codecs_common.h"/>
<enum name="STD_VIDEO_AV1_NUM_REF_FRAMES" value="8"/> <enum name="STD_VIDEO_AV1_NUM_REF_FRAMES" value="8" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_REFS_PER_FRAME" value="7"/> <enum name="STD_VIDEO_AV1_REFS_PER_FRAME" value="7" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME" value="8"/> <enum name="STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME" value="8" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_TILE_COLS" value="64"/> <enum name="STD_VIDEO_AV1_MAX_TILE_COLS" value="64" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_TILE_ROWS" value="64"/> <enum name="STD_VIDEO_AV1_MAX_TILE_ROWS" value="64" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_SEGMENTS" value="8"/> <enum name="STD_VIDEO_AV1_MAX_SEGMENTS" value="8" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_SEG_LVL_MAX" value="8"/> <enum name="STD_VIDEO_AV1_SEG_LVL_MAX" value="8" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_PRIMARY_REF_NONE" value="7"/> <enum name="STD_VIDEO_AV1_PRIMARY_REF_NONE" value="7" type="uint8_t"/>
<enum name="STD_VIDEO_AV1_SELECT_INTEGER_MV" value="2"/> <enum name="STD_VIDEO_AV1_SELECT_INTEGER_MV" value="2" type="uint8_t"/>
<enum name="STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS" value="2"/> <enum name="STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS" value="2" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_SKIP_MODE_FRAMES" value="2"/> <enum name="STD_VIDEO_AV1_SKIP_MODE_FRAMES" value="2" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS" value="4"/> <enum name="STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS" value="4" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS" value="2"/> <enum name="STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS" value="2" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS" value="8"/> <enum name="STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS" value="8" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_NUM_PLANES" value="3"/> <enum name="STD_VIDEO_AV1_MAX_NUM_PLANES" value="3" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS" value="6"/> <enum name="STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS" value="6" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_NUM_Y_POINTS" value="14"/> <enum name="STD_VIDEO_AV1_MAX_NUM_Y_POINTS" value="14" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_NUM_CB_POINTS" value="10"/> <enum name="STD_VIDEO_AV1_MAX_NUM_CB_POINTS" value="10" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_NUM_CR_POINTS" value="10"/> <enum name="STD_VIDEO_AV1_MAX_NUM_CR_POINTS" value="10" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_NUM_POS_LUMA" value="24"/> <enum name="STD_VIDEO_AV1_MAX_NUM_POS_LUMA" value="24" type="uint32_t"/>
<enum name="STD_VIDEO_AV1_MAX_NUM_POS_CHROMA" value="25"/> <enum name="STD_VIDEO_AV1_MAX_NUM_POS_CHROMA" value="25" type="uint32_t"/>
<type name="StdVideoAV1Profile"/> <type name="StdVideoAV1Profile"/>
<type name="StdVideoAV1Level"/> <type name="StdVideoAV1Level"/>

1139
registry/vk.xml
View file

File diff suppressed because it is too large Load diff

86
registry/vulkan_object.py
View file

@ -234,6 +234,8 @@ class Member:
# - VkStructureType sType # - VkStructureType sType
cDeclaration: str cDeclaration: str
bitFieldWidth: (int | None) # bit width (only for bit field struct members)
def __lt__(self, other): def __lt__(self, other):
return self.name < other.name return self.name < other.name
@ -260,6 +262,9 @@ class Struct:
extends: list[str] # Struct names that this struct extends extends: list[str] # Struct names that this struct extends
extendedBy: list[str] # Struct names that can be extended by this struct extendedBy: list[str] # Struct names that can be extended by this struct
# This field is only set for enum definitions coming from Video Std headers
videoStdHeader: (str | None) = None
def __lt__(self, other): def __lt__(self, other):
return self.name < other.name return self.name < other.name
@ -298,6 +303,9 @@ class Enum:
# Unique list of all extension that are involved in 'fields' (superset of 'extensions') # Unique list of all extension that are involved in 'fields' (superset of 'extensions')
fieldExtensions: list[str] fieldExtensions: list[str]
# This field is only set for enum definitions coming from Video Std headers
videoStdHeader: (str | None) = None
def __lt__(self, other): def __lt__(self, other):
return self.name < other.name return self.name < other.name
@ -366,6 +374,9 @@ class Constant:
value: (int | float) value: (int | float)
valueStr: str # value as shown in spec (ex. "(~0U)", "256U", etc) valueStr: str # value as shown in spec (ex. "(~0U)", "256U", etc)
# This field is only set for enum definitions coming from Video Std headers
videoStdHeader: (str | None) = None
@dataclass @dataclass
class FormatComponent: class FormatComponent:
"""<format/component>""" """<format/component>"""
@ -461,6 +472,75 @@ class Spirv:
capability: bool capability: bool
enable: list[SpirvEnables] enable: list[SpirvEnables]
@dataclass
class VideoRequiredCapabilities:
"""<videorequirecapabilities>"""
struct: str # ex) VkVideoEncodeCapabilitiesKHR
member: str # ex) flags
value: str # ex) VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR
# may contain XML boolean expressions ("+" means AND, "," means OR)
@dataclass
class VideoFormat:
"""<videoformat>"""
name: str # ex) Decode Output
usage: str # ex) VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR
# may contain XML boolean expressions ("+" means AND, "," means OR)
requiredCaps: list[VideoRequiredCapabilities]
properties: dict[str, str]
def __lt__(self, other):
return self.name < other.name
@dataclass
class VideoProfileMember:
"""<videoprofilemember> and <videoprofile>"""
name: str
# Video profile struct member (value attribute of <videoprofile>) value as key,
# profile name substring (name attribute of <videoprofile>) as value
values: dict[str, str]
@dataclass
class VideoProfiles:
"""<videoprofiles>"""
name: str
members: dict[str, VideoProfileMember]
@dataclass
class VideoCodec:
"""<videocodec>"""
name: str # ex) H.264 Decode
value: (str | None) # If no video codec operation flag bit is associated with the codec
# then it is a codec category (e.g. decode, encode), not a specific codec
profiles: dict[str, VideoProfiles]
capabilities: dict[str, str]
formats: dict[str, VideoFormat]
def __lt__(self, other):
return self.name < other.name
@dataclass
class VideoStdHeader:
"""<extension> in video.xml"""
name: str # ex) vulkan_video_codec_h264std_decode
version: (str | None) # ex) VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0
# None if it is a shared common Video Std header
headerFile: str # ex) vk_video/vulkan_video_codec_h264std_decode.h
# Other Video Std headers that this one depends on
depends: list[str]
@dataclass
class VideoStd:
headers: dict[str, VideoStdHeader] = field(default_factory=dict, init=False)
enums: dict[str, Enum] = field(default_factory=dict, init=False)
structs: dict[str, Struct] = field(default_factory=dict, init=False)
constants: dict[str, Constant] = field(default_factory=dict, init=False)
# This is the global Vulkan Object that holds all the information from parsing the XML # This is the global Vulkan Object that holds all the information from parsing the XML
# This class is designed so all generator scripts can use this to obtain data # This class is designed so all generator scripts can use this to obtain data
@dataclass @dataclass
@ -492,3 +572,9 @@ class VulkanObject():
vendorTags: list[str] = field(default_factory=list, init=False) vendorTags: list[str] = field(default_factory=list, init=False)
# ex) [ Queues.COMPUTE : VK_QUEUE_COMPUTE_BIT ] # ex) [ Queues.COMPUTE : VK_QUEUE_COMPUTE_BIT ]
queueBits: dict[IntFlag, str] = field(default_factory=dict, init=False) queueBits: dict[IntFlag, str] = field(default_factory=dict, init=False)
# Video codec information from the vk.xml
videoCodecs: dict[str, VideoCodec] = field(default_factory=dict, init=False)
# Video Std header information from the video.xml
videoStd: (VideoStd | None) = None