From ad85498e33a53f4c89979e0af8e3fe3b512aa47c Mon Sep 17 00:00:00 2001 From: Locke Lin Date: Mon, 8 Jan 2024 14:21:00 -0700 Subject: [PATCH] Update headers to 1.3.275 TODO: CmdPushDescriptorSetWithTemplate2KHR needs to be handled as CmdPushDescriptorSetWithTemplateKHR. --- external/Vulkan-Headers | 2 +- framework/encode/vulkan_state_info.h | 2 + framework/format/api_call_id.h | 6 + .../generated_decode_pnext_struct.cpp | 236 +- .../generated_encode_pnext_struct.cpp | 177 +- .../generated/generated_layer_func_table.h | 6 + .../generated_vulkan_api_call_encoders.cpp | 216 ++ .../generated_vulkan_api_call_encoders.h | 24 + .../generated_vulkan_command_buffer_util.cpp | 300 ++ .../generated_vulkan_command_buffer_util.h | 12 + .../generated/generated_vulkan_consumer.h | 30 + .../generated/generated_vulkan_decoder.cpp | 126 + .../generated/generated_vulkan_decoder.h | 12 + .../generated_vulkan_dispatch_table.h | 18 + .../generated_vulkan_enum_to_json.cpp | 832 ++--- .../generated/generated_vulkan_enum_to_json.h | 48 +- .../generated_vulkan_enum_to_string.cpp | 438 +-- .../generated_vulkan_enum_to_string.h | 32 +- .../generated_vulkan_feature_util.cpp | 52 + .../generated_vulkan_json_consumer.cpp | 84 + .../generated_vulkan_json_consumer.h | 30 + ...ed_vulkan_referenced_resource_consumer.cpp | 156 + ...ated_vulkan_referenced_resource_consumer.h | 30 + .../generated_vulkan_replay_consumer.cpp | 410 ++- .../generated_vulkan_replay_consumer.h | 30 + .../generated_vulkan_struct_decoders.cpp | 2292 +++++++------- .../generated_vulkan_struct_decoders.h | 726 +++-- ...generated_vulkan_struct_decoders_forward.h | 166 +- .../generated_vulkan_struct_encoders.cpp | 827 ++--- .../generated_vulkan_struct_encoders.h | 83 +- ...generated_vulkan_struct_handle_mappers.cpp | 122 + .../generated_vulkan_struct_handle_mappers.h | 15 + ...enerated_vulkan_struct_handle_wrappers.cpp | 263 +- .../generated_vulkan_struct_handle_wrappers.h | 14 + .../generated_vulkan_struct_to_json.cpp | 2684 +++++++++-------- .../generated_vulkan_struct_to_json.h | 76 +- ..._struct_handle_mappers_header_generator.py | 4 + 37 files changed, 6492 insertions(+), 4089 deletions(-) diff --git a/external/Vulkan-Headers b/external/Vulkan-Headers index 41263fc5a..217e93c66 160000 --- a/external/Vulkan-Headers +++ b/external/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 41263fc5aa994b8eafaca946583bfcceca8ca419 +Subproject commit 217e93c664ec6704ec2d8c36fa116c1a4a1e2d40 diff --git a/framework/encode/vulkan_state_info.h b/framework/encode/vulkan_state_info.h index 7dca862eb..4008df433 100644 --- a/framework/encode/vulkan_state_info.h +++ b/framework/encode/vulkan_state_info.h @@ -129,6 +129,8 @@ enum CommandHandleType : uint32_t VideoSessionKHRHandle, VideoSessionParametersKHRHandle, ShaderEXTHandle, + DescriptorSetLayoutHandle, + DescriptorUpdateTemplateHandle, NumHandleTypes // THIS MUST BE THE LAST ENUM VALUE ! }; diff --git a/framework/format/api_call_id.h b/framework/format/api_call_id.h index 9d2d51be3..b2fb23591 100644 --- a/framework/format/api_call_id.h +++ b/framework/format/api_call_id.h @@ -702,6 +702,12 @@ enum ApiCallId : uint32_t ApiCall_vkFrameBoundaryANDROID = MakeApiCallId(ApiFamily_Vulkan, 0x12dc), ApiCall_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = MakeApiCallId(ApiFamily_Vulkan, 0x12dd), ApiCall_vkGetCalibratedTimestampsKHR = MakeApiCallId(ApiFamily_Vulkan, 0x12de), + ApiCall_vkCmdBindDescriptorSets2KHR = MakeApiCallId(ApiFamily_Vulkan, 0x12df), + ApiCall_vkCmdPushConstants2KHR = MakeApiCallId(ApiFamily_Vulkan, 0x12e0), + ApiCall_vkCmdPushDescriptorSet2KHR = MakeApiCallId(ApiFamily_Vulkan, 0x12e1), + ApiCall_vkCmdPushDescriptorSetWithTemplate2KHR = MakeApiCallId(ApiFamily_Vulkan, 0x12e2), + ApiCall_vkCmdSetDescriptorBufferOffsets2EXT = MakeApiCallId(ApiFamily_Vulkan, 0x12e3), + ApiCall_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = MakeApiCallId(ApiFamily_Vulkan, 0x12e4), ApiCall_VulkanLast, diff --git a/framework/generated/generated_decode_pnext_struct.cpp b/framework/generated/generated_decode_pnext_struct.cpp index df830082b..88697e098 100644 --- a/framework/generated/generated_decode_pnext_struct.cpp +++ b/framework/generated/generated_decode_pnext_struct.cpp @@ -78,6 +78,10 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -546,6 +550,110 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -802,6 +910,14 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -814,6 +930,18 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -846,110 +974,6 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -2030,6 +2054,10 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); diff --git a/framework/generated/generated_encode_pnext_struct.cpp b/framework/generated/generated_encode_pnext_struct.cpp index b79abd3f0..a1c561302 100644 --- a/framework/generated/generated_encode_pnext_struct.cpp +++ b/framework/generated/generated_encode_pnext_struct.cpp @@ -80,6 +80,9 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -431,6 +434,84 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -623,6 +704,12 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -632,6 +719,15 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -656,84 +752,6 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: EncodeStructPtr(encoder, reinterpret_cast(base)); break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -1544,6 +1562,9 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: EncodeStructPtr(encoder, reinterpret_cast(base)); break; diff --git a/framework/generated/generated_layer_func_table.h b/framework/generated/generated_layer_func_table.h index 16f9bc0c7..b94679e9d 100644 --- a/framework/generated/generated_layer_func_table.h +++ b/framework/generated/generated_layer_func_table.h @@ -412,6 +412,12 @@ const std::unordered_map func_table = { { "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", reinterpret_cast(encode::GetPhysicalDeviceCooperativeMatrixPropertiesKHR) }, { "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", reinterpret_cast(encode::GetPhysicalDeviceCalibrateableTimeDomainsKHR) }, { "vkGetCalibratedTimestampsKHR", reinterpret_cast(encode::GetCalibratedTimestampsKHR) }, + { "vkCmdBindDescriptorSets2KHR", reinterpret_cast(encode::CmdBindDescriptorSets2KHR) }, + { "vkCmdPushConstants2KHR", reinterpret_cast(encode::CmdPushConstants2KHR) }, + { "vkCmdPushDescriptorSet2KHR", reinterpret_cast(encode::CmdPushDescriptorSet2KHR) }, + { "vkCmdPushDescriptorSetWithTemplate2KHR", reinterpret_cast(encode::CmdPushDescriptorSetWithTemplate2KHR) }, + { "vkCmdSetDescriptorBufferOffsets2EXT", reinterpret_cast(encode::CmdSetDescriptorBufferOffsets2EXT) }, + { "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", reinterpret_cast(encode::CmdBindDescriptorBufferEmbeddedSamplers2EXT) }, { "vkFrameBoundaryANDROID", reinterpret_cast(encode::FrameBoundaryANDROID) }, { "vkCreateDebugReportCallbackEXT", reinterpret_cast(encode::CreateDebugReportCallbackEXT) }, { "vkDestroyDebugReportCallbackEXT", reinterpret_cast(encode::DestroyDebugReportCallbackEXT) }, diff --git a/framework/generated/generated_vulkan_api_call_encoders.cpp b/framework/generated/generated_vulkan_api_call_encoders.cpp index f50ce571a..9dd2e4243 100644 --- a/framework/generated/generated_vulkan_api_call_encoders.cpp +++ b/framework/generated/generated_vulkan_api_call_encoders.cpp @@ -14324,6 +14324,222 @@ VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR( return result; } +VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR( + VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, commandBuffer, pBindDescriptorSetsInfo); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdBindDescriptorSets2KHR); + if (encoder) + { + encoder->EncodeHandleValue(commandBuffer); + EncodeStructPtr(encoder, pBindDescriptorSetsInfo); + manager->EndCommandApiCallCapture(commandBuffer, TrackCmdBindDescriptorSets2KHRHandles, pBindDescriptorSetsInfo); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo_unwrapped = UnwrapStructPtrHandles(pBindDescriptorSetsInfo, handle_unwrap_memory); + + GetDeviceTable(commandBuffer)->CmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo_unwrapped); + + CustomEncoderPostCall::Dispatch(manager, commandBuffer, pBindDescriptorSetsInfo); +} + +VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR( + VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, commandBuffer, pPushConstantsInfo); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdPushConstants2KHR); + if (encoder) + { + encoder->EncodeHandleValue(commandBuffer); + EncodeStructPtr(encoder, pPushConstantsInfo); + manager->EndCommandApiCallCapture(commandBuffer, TrackCmdPushConstants2KHRHandles, pPushConstantsInfo); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkPushConstantsInfoKHR* pPushConstantsInfo_unwrapped = UnwrapStructPtrHandles(pPushConstantsInfo, handle_unwrap_memory); + + GetDeviceTable(commandBuffer)->CmdPushConstants2KHR(commandBuffer, pPushConstantsInfo_unwrapped); + + CustomEncoderPostCall::Dispatch(manager, commandBuffer, pPushConstantsInfo); +} + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, commandBuffer, pPushDescriptorSetInfo); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdPushDescriptorSet2KHR); + if (encoder) + { + encoder->EncodeHandleValue(commandBuffer); + EncodeStructPtr(encoder, pPushDescriptorSetInfo); + manager->EndCommandApiCallCapture(commandBuffer, TrackCmdPushDescriptorSet2KHRHandles, pPushDescriptorSetInfo); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo_unwrapped = UnwrapStructPtrHandles(pPushDescriptorSetInfo, handle_unwrap_memory); + + GetDeviceTable(commandBuffer)->CmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo_unwrapped); + + CustomEncoderPostCall::Dispatch(manager, commandBuffer, pPushDescriptorSetInfo); +} + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, commandBuffer, pPushDescriptorSetWithTemplateInfo); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdPushDescriptorSetWithTemplate2KHR); + if (encoder) + { + encoder->EncodeHandleValue(commandBuffer); + EncodeStructPtr(encoder, pPushDescriptorSetWithTemplateInfo); + manager->EndCommandApiCallCapture(commandBuffer, TrackCmdPushDescriptorSetWithTemplate2KHRHandles, pPushDescriptorSetWithTemplateInfo); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo_unwrapped = UnwrapStructPtrHandles(pPushDescriptorSetWithTemplateInfo, handle_unwrap_memory); + + GetDeviceTable(commandBuffer)->CmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo_unwrapped); + + CustomEncoderPostCall::Dispatch(manager, commandBuffer, pPushDescriptorSetWithTemplateInfo); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, commandBuffer, pSetDescriptorBufferOffsetsInfo); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdSetDescriptorBufferOffsets2EXT); + if (encoder) + { + encoder->EncodeHandleValue(commandBuffer); + EncodeStructPtr(encoder, pSetDescriptorBufferOffsetsInfo); + manager->EndCommandApiCallCapture(commandBuffer, TrackCmdSetDescriptorBufferOffsets2EXTHandles, pSetDescriptorBufferOffsetsInfo); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo_unwrapped = UnwrapStructPtrHandles(pSetDescriptorBufferOffsetsInfo, handle_unwrap_memory); + + GetDeviceTable(commandBuffer)->CmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo_unwrapped); + + CustomEncoderPostCall::Dispatch(manager, commandBuffer, pSetDescriptorBufferOffsetsInfo); +} + +VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT); + if (encoder) + { + encoder->EncodeHandleValue(commandBuffer); + EncodeStructPtr(encoder, pBindDescriptorBufferEmbeddedSamplersInfo); + manager->EndCommandApiCallCapture(commandBuffer, TrackCmdBindDescriptorBufferEmbeddedSamplers2EXTHandles, pBindDescriptorBufferEmbeddedSamplersInfo); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo_unwrapped = UnwrapStructPtrHandles(pBindDescriptorBufferEmbeddedSamplersInfo, handle_unwrap_memory); + + GetDeviceTable(commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo_unwrapped); + + CustomEncoderPostCall::Dispatch(manager, commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); +} + VKAPI_ATTR void VKAPI_CALL FrameBoundaryANDROID( VkDevice device, VkSemaphore semaphore, diff --git a/framework/generated/generated_vulkan_api_call_encoders.h b/framework/generated/generated_vulkan_api_call_encoders.h index 3acbb93c9..c6ab90866 100644 --- a/framework/generated/generated_vulkan_api_call_encoders.h +++ b/framework/generated/generated_vulkan_api_call_encoders.h @@ -1957,6 +1957,30 @@ VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR( uint64_t* pTimestamps, uint64_t* pMaxDeviation); +VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR( + VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); + +VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR( + VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo); + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); + +VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); + +VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); + +VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + VKAPI_ATTR void VKAPI_CALL FrameBoundaryANDROID( VkDevice device, VkSemaphore semaphore, diff --git a/framework/generated/generated_vulkan_command_buffer_util.cpp b/framework/generated/generated_vulkan_command_buffer_util.cpp index 2141730a1..bc75c5cc8 100644 --- a/framework/generated/generated_vulkan_command_buffer_util.cpp +++ b/framework/generated/generated_vulkan_command_buffer_util.cpp @@ -647,6 +647,22 @@ void TrackCmdDecodeVideoKHRHandles(CommandBufferWrapper* wrapper, const VkVideoD if (pDecodeInfo != nullptr) { + auto pnext_header = reinterpret_cast(pDecodeInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + { + auto pnext_value = reinterpret_cast(pnext_header); + if(pnext_value->queryPool != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::QueryPoolHandle].insert(GetWrappedId(pnext_value->queryPool)); + break; + } + } + pnext_header = pnext_header->pNext; + } if(pDecodeInfo->srcBuffer != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::BufferHandle].insert(GetWrappedId(pDecodeInfo->srcBuffer)); if(pDecodeInfo->dstPictureResource.imageViewBinding != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::ImageViewHandle].insert(GetWrappedId(pDecodeInfo->dstPictureResource.imageViewBinding)); @@ -778,6 +794,22 @@ void TrackCmdEncodeVideoKHRHandles(CommandBufferWrapper* wrapper, const VkVideoE if (pEncodeInfo != nullptr) { + auto pnext_header = reinterpret_cast(pEncodeInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + { + auto pnext_value = reinterpret_cast(pnext_header); + if(pnext_value->queryPool != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::QueryPoolHandle].insert(GetWrappedId(pnext_value->queryPool)); + break; + } + } + pnext_header = pnext_header->pNext; + } if(pEncodeInfo->dstBuffer != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::BufferHandle].insert(GetWrappedId(pEncodeInfo->dstBuffer)); if(pEncodeInfo->srcPictureResource.imageViewBinding != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::ImageViewHandle].insert(GetWrappedId(pEncodeInfo->srcPictureResource.imageViewBinding)); @@ -981,6 +1013,274 @@ void TrackCmdBindIndexBuffer2KHRHandles(CommandBufferWrapper* wrapper, VkBuffer if(buffer != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::BufferHandle].insert(GetWrappedId(buffer)); } +void TrackCmdBindDescriptorSets2KHRHandles(CommandBufferWrapper* wrapper, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) +{ + assert(wrapper != nullptr); + + if (pBindDescriptorSetsInfo != nullptr) + { + auto pnext_header = reinterpret_cast(pBindDescriptorSetsInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pSetLayouts != nullptr) + { + for (uint32_t pSetLayouts_index = 0; pSetLayouts_index < pnext_value->setLayoutCount; ++pSetLayouts_index) + { + if(pnext_value->pSetLayouts[pSetLayouts_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::DescriptorSetLayoutHandle].insert(GetWrappedId(pnext_value->pSetLayouts[pSetLayouts_index])); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + if(pBindDescriptorSetsInfo->layout != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::PipelineLayoutHandle].insert(GetWrappedId(pBindDescriptorSetsInfo->layout)); + + if (pBindDescriptorSetsInfo->pDescriptorSets != nullptr) + { + for (uint32_t pDescriptorSets_index = 0; pDescriptorSets_index < pBindDescriptorSetsInfo->descriptorSetCount; ++pDescriptorSets_index) + { + if(pBindDescriptorSetsInfo->pDescriptorSets[pDescriptorSets_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::DescriptorSetHandle].insert(GetWrappedId(pBindDescriptorSetsInfo->pDescriptorSets[pDescriptorSets_index])); + } + } + } +} + +void TrackCmdPushConstants2KHRHandles(CommandBufferWrapper* wrapper, const VkPushConstantsInfoKHR* pPushConstantsInfo) +{ + assert(wrapper != nullptr); + + if (pPushConstantsInfo != nullptr) + { + auto pnext_header = reinterpret_cast(pPushConstantsInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pSetLayouts != nullptr) + { + for (uint32_t pSetLayouts_index = 0; pSetLayouts_index < pnext_value->setLayoutCount; ++pSetLayouts_index) + { + if(pnext_value->pSetLayouts[pSetLayouts_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::DescriptorSetLayoutHandle].insert(GetWrappedId(pnext_value->pSetLayouts[pSetLayouts_index])); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + if(pPushConstantsInfo->layout != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::PipelineLayoutHandle].insert(GetWrappedId(pPushConstantsInfo->layout)); + } +} + +void TrackCmdPushDescriptorSet2KHRHandles(CommandBufferWrapper* wrapper, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) +{ + assert(wrapper != nullptr); + + if (pPushDescriptorSetInfo != nullptr) + { + auto pnext_header = reinterpret_cast(pPushDescriptorSetInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pSetLayouts != nullptr) + { + for (uint32_t pSetLayouts_index = 0; pSetLayouts_index < pnext_value->setLayoutCount; ++pSetLayouts_index) + { + if(pnext_value->pSetLayouts[pSetLayouts_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::DescriptorSetLayoutHandle].insert(GetWrappedId(pnext_value->pSetLayouts[pSetLayouts_index])); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + if(pPushDescriptorSetInfo->layout != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::PipelineLayoutHandle].insert(GetWrappedId(pPushDescriptorSetInfo->layout)); + + if (pPushDescriptorSetInfo->pDescriptorWrites != nullptr) + { + for (uint32_t pDescriptorWrites_index = 0; pDescriptorWrites_index < pPushDescriptorSetInfo->descriptorWriteCount; ++pDescriptorWrites_index) + { + auto pnext_header = reinterpret_cast(pPushDescriptorSetInfo->pDescriptorWrites->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pAccelerationStructures != nullptr) + { + for (uint32_t pAccelerationStructures_index = 0; pAccelerationStructures_index < pnext_value->accelerationStructureCount; ++pAccelerationStructures_index) + { + if(pnext_value->pAccelerationStructures[pAccelerationStructures_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::AccelerationStructureKHRHandle].insert(GetWrappedId(pnext_value->pAccelerationStructures[pAccelerationStructures_index])); + } + } + break; + } + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pAccelerationStructures != nullptr) + { + for (uint32_t pAccelerationStructures_index = 0; pAccelerationStructures_index < pnext_value->accelerationStructureCount; ++pAccelerationStructures_index) + { + if(pnext_value->pAccelerationStructures[pAccelerationStructures_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::AccelerationStructureNVHandle].insert(GetWrappedId(pnext_value->pAccelerationStructures[pAccelerationStructures_index])); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + if(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].dstSet != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::DescriptorSetHandle].insert(GetWrappedId(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].dstSet)); + + if (pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pImageInfo != nullptr) + { + for (uint32_t pImageInfo_index = 0; pImageInfo_index < pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].descriptorCount; ++pImageInfo_index) + { + if(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pImageInfo[pImageInfo_index].sampler != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::SamplerHandle].insert(GetWrappedId(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pImageInfo[pImageInfo_index].sampler)); + if(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pImageInfo[pImageInfo_index].imageView != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::ImageViewHandle].insert(GetWrappedId(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pImageInfo[pImageInfo_index].imageView)); + } + } + + if (pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pBufferInfo != nullptr) + { + for (uint32_t pBufferInfo_index = 0; pBufferInfo_index < pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].descriptorCount; ++pBufferInfo_index) + { + if(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pBufferInfo[pBufferInfo_index].buffer != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::BufferHandle].insert(GetWrappedId(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pBufferInfo[pBufferInfo_index].buffer)); + } + } + + if (pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pTexelBufferView != nullptr) + { + for (uint32_t pTexelBufferView_index = 0; pTexelBufferView_index < pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].descriptorCount; ++pTexelBufferView_index) + { + if(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pTexelBufferView[pTexelBufferView_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::BufferViewHandle].insert(GetWrappedId(pPushDescriptorSetInfo->pDescriptorWrites[pDescriptorWrites_index].pTexelBufferView[pTexelBufferView_index])); + } + } + } + } + } +} + +void TrackCmdPushDescriptorSetWithTemplate2KHRHandles(CommandBufferWrapper* wrapper, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) +{ + assert(wrapper != nullptr); + + if (pPushDescriptorSetWithTemplateInfo != nullptr) + { + auto pnext_header = reinterpret_cast(pPushDescriptorSetWithTemplateInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pSetLayouts != nullptr) + { + for (uint32_t pSetLayouts_index = 0; pSetLayouts_index < pnext_value->setLayoutCount; ++pSetLayouts_index) + { + if(pnext_value->pSetLayouts[pSetLayouts_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::DescriptorSetLayoutHandle].insert(GetWrappedId(pnext_value->pSetLayouts[pSetLayouts_index])); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + if(pPushDescriptorSetWithTemplateInfo->descriptorUpdateTemplate != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::DescriptorUpdateTemplateHandle].insert(GetWrappedId(pPushDescriptorSetWithTemplateInfo->descriptorUpdateTemplate)); + if(pPushDescriptorSetWithTemplateInfo->layout != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::PipelineLayoutHandle].insert(GetWrappedId(pPushDescriptorSetWithTemplateInfo->layout)); + } +} + +void TrackCmdSetDescriptorBufferOffsets2EXTHandles(CommandBufferWrapper* wrapper, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) +{ + assert(wrapper != nullptr); + + if (pSetDescriptorBufferOffsetsInfo != nullptr) + { + auto pnext_header = reinterpret_cast(pSetDescriptorBufferOffsetsInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pSetLayouts != nullptr) + { + for (uint32_t pSetLayouts_index = 0; pSetLayouts_index < pnext_value->setLayoutCount; ++pSetLayouts_index) + { + if(pnext_value->pSetLayouts[pSetLayouts_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::DescriptorSetLayoutHandle].insert(GetWrappedId(pnext_value->pSetLayouts[pSetLayouts_index])); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + if(pSetDescriptorBufferOffsetsInfo->layout != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::PipelineLayoutHandle].insert(GetWrappedId(pSetDescriptorBufferOffsetsInfo->layout)); + } +} + +void TrackCmdBindDescriptorBufferEmbeddedSamplers2EXTHandles(CommandBufferWrapper* wrapper, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) +{ + assert(wrapper != nullptr); + + if (pBindDescriptorBufferEmbeddedSamplersInfo != nullptr) + { + auto pnext_header = reinterpret_cast(pBindDescriptorBufferEmbeddedSamplersInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pSetLayouts != nullptr) + { + for (uint32_t pSetLayouts_index = 0; pSetLayouts_index < pnext_value->setLayoutCount; ++pSetLayouts_index) + { + if(pnext_value->pSetLayouts[pSetLayouts_index] != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::DescriptorSetLayoutHandle].insert(GetWrappedId(pnext_value->pSetLayouts[pSetLayouts_index])); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + if(pBindDescriptorBufferEmbeddedSamplersInfo->layout != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::PipelineLayoutHandle].insert(GetWrappedId(pBindDescriptorBufferEmbeddedSamplersInfo->layout)); + } +} + void TrackCmdBindTransformFeedbackBuffersEXTHandles(CommandBufferWrapper* wrapper, uint32_t bindingCount, const VkBuffer* pBuffers) { assert(wrapper != nullptr); diff --git a/framework/generated/generated_vulkan_command_buffer_util.h b/framework/generated/generated_vulkan_command_buffer_util.h index 38c7b172b..8fca0d016 100644 --- a/framework/generated/generated_vulkan_command_buffer_util.h +++ b/framework/generated/generated_vulkan_command_buffer_util.h @@ -178,6 +178,18 @@ void TrackCmdResolveImage2KHRHandles(CommandBufferWrapper* wrapper, const VkReso void TrackCmdBindIndexBuffer2KHRHandles(CommandBufferWrapper* wrapper, VkBuffer buffer); +void TrackCmdBindDescriptorSets2KHRHandles(CommandBufferWrapper* wrapper, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo); + +void TrackCmdPushConstants2KHRHandles(CommandBufferWrapper* wrapper, const VkPushConstantsInfoKHR* pPushConstantsInfo); + +void TrackCmdPushDescriptorSet2KHRHandles(CommandBufferWrapper* wrapper, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo); + +void TrackCmdPushDescriptorSetWithTemplate2KHRHandles(CommandBufferWrapper* wrapper, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo); + +void TrackCmdSetDescriptorBufferOffsets2EXTHandles(CommandBufferWrapper* wrapper, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); + +void TrackCmdBindDescriptorBufferEmbeddedSamplers2EXTHandles(CommandBufferWrapper* wrapper, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + void TrackCmdBindTransformFeedbackBuffersEXTHandles(CommandBufferWrapper* wrapper, uint32_t bindingCount, const VkBuffer* pBuffers); void TrackCmdBeginTransformFeedbackEXTHandles(CommandBufferWrapper* wrapper, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers); diff --git a/framework/generated/generated_vulkan_consumer.h b/framework/generated/generated_vulkan_consumer.h index dd993b030..ff97bd374 100644 --- a/framework/generated/generated_vulkan_consumer.h +++ b/framework/generated/generated_vulkan_consumer.h @@ -2489,6 +2489,36 @@ class VulkanConsumer : public VulkanConsumerBase PointerDecoder* pTimestamps, PointerDecoder* pMaxDeviation) {} + virtual void Process_vkCmdBindDescriptorSets2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorSetsInfo) {} + + virtual void Process_vkCmdPushConstants2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushConstantsInfo) {} + + virtual void Process_vkCmdPushDescriptorSet2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetInfo) {} + + virtual void Process_vkCmdPushDescriptorSetWithTemplate2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetWithTemplateInfo) {} + + virtual void Process_vkCmdSetDescriptorBufferOffsets2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pSetDescriptorBufferOffsetsInfo) {} + + virtual void Process_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorBufferEmbeddedSamplersInfo) {} + virtual void Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, diff --git a/framework/generated/generated_vulkan_decoder.cpp b/framework/generated/generated_vulkan_decoder.cpp index 37d62eb07..79088681a 100644 --- a/framework/generated/generated_vulkan_decoder.cpp +++ b/framework/generated/generated_vulkan_decoder.cpp @@ -7747,6 +7747,114 @@ size_t VulkanDecoder::Decode_vkGetCalibratedTimestampsKHR(const ApiCallInfo& cal return bytes_read; } +size_t VulkanDecoder::Decode_vkCmdBindDescriptorSets2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pBindDescriptorSetsInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pBindDescriptorSetsInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdBindDescriptorSets2KHR(call_info, commandBuffer, &pBindDescriptorSetsInfo); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkCmdPushConstants2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pPushConstantsInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pPushConstantsInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdPushConstants2KHR(call_info, commandBuffer, &pPushConstantsInfo); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkCmdPushDescriptorSet2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pPushDescriptorSetInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pPushDescriptorSetInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdPushDescriptorSet2KHR(call_info, commandBuffer, &pPushDescriptorSetInfo); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkCmdPushDescriptorSetWithTemplate2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pPushDescriptorSetWithTemplateInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pPushDescriptorSetWithTemplateInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdPushDescriptorSetWithTemplate2KHR(call_info, commandBuffer, &pPushDescriptorSetWithTemplateInfo); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkCmdSetDescriptorBufferOffsets2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pSetDescriptorBufferOffsetsInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pSetDescriptorBufferOffsetsInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdSetDescriptorBufferOffsets2EXT(call_info, commandBuffer, &pSetDescriptorBufferOffsetsInfo); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pBindDescriptorBufferEmbeddedSamplersInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pBindDescriptorBufferEmbeddedSamplersInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(call_info, commandBuffer, &pBindDescriptorBufferEmbeddedSamplersInfo); + } + + return bytes_read; +} + size_t VulkanDecoder::Decode_vkFrameBoundaryANDROID(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) { size_t bytes_read = 0; @@ -14351,6 +14459,24 @@ void VulkanDecoder::DecodeFunctionCall(format::ApiCallId call_id, case format::ApiCallId::ApiCall_vkGetCalibratedTimestampsKHR: Decode_vkGetCalibratedTimestampsKHR(call_info, parameter_buffer, buffer_size); break; + case format::ApiCallId::ApiCall_vkCmdBindDescriptorSets2KHR: + Decode_vkCmdBindDescriptorSets2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPushConstants2KHR: + Decode_vkCmdPushConstants2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPushDescriptorSet2KHR: + Decode_vkCmdPushDescriptorSet2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPushDescriptorSetWithTemplate2KHR: + Decode_vkCmdPushDescriptorSetWithTemplate2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDescriptorBufferOffsets2EXT: + Decode_vkCmdSetDescriptorBufferOffsets2EXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT: + Decode_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(call_info, parameter_buffer, buffer_size); + break; case format::ApiCallId::ApiCall_vkFrameBoundaryANDROID: Decode_vkFrameBoundaryANDROID(call_info, parameter_buffer, buffer_size); break; diff --git a/framework/generated/generated_vulkan_decoder.h b/framework/generated/generated_vulkan_decoder.h index 9e5a27409..497406c09 100644 --- a/framework/generated/generated_vulkan_decoder.h +++ b/framework/generated/generated_vulkan_decoder.h @@ -765,6 +765,18 @@ class VulkanDecoder : public VulkanDecoderBase size_t Decode_vkGetCalibratedTimestampsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + size_t Decode_vkCmdBindDescriptorSets2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPushConstants2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPushDescriptorSet2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPushDescriptorSetWithTemplate2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDescriptorBufferOffsets2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + size_t Decode_vkFrameBoundaryANDROID(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); size_t Decode_vkCreateDebugReportCallbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); diff --git a/framework/generated/generated_vulkan_dispatch_table.h b/framework/generated/generated_vulkan_dispatch_table.h index a699cf4e8..059d3fa5f 100644 --- a/framework/generated/generated_vulkan_dispatch_table.h +++ b/framework/generated/generated_vulkan_dispatch_table.h @@ -461,6 +461,12 @@ static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR(VkDevice, const static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR(VkDevice, const VkDeviceImageSubresourceInfoKHR*, VkSubresourceLayout2KHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetDeviceImageSubresourceLayoutKHR was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR(VkDevice, VkImage, const VkImageSubresource2KHR*, VkSubresourceLayout2KHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetImageSubresourceLayout2KHR was called, resulting in no-op behavior."); } static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR(VkDevice, uint32_t, const VkCalibratedTimestampInfoKHR*, uint64_t*, uint64_t*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetCalibratedTimestampsKHR was called, resulting in no-op behavior."); return VK_SUCCESS; } +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets2KHR(VkCommandBuffer, const VkBindDescriptorSetsInfoKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdBindDescriptorSets2KHR was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants2KHR(VkCommandBuffer, const VkPushConstantsInfoKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdPushConstants2KHR was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet2KHR(VkCommandBuffer, const VkPushDescriptorSetInfoKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdPushDescriptorSet2KHR was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdPushDescriptorSetWithTemplate2KHR was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdSetDescriptorBufferOffsets2EXT was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdBindDescriptorBufferEmbeddedSamplers2EXT was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL FrameBoundaryANDROID(VkDevice, VkSemaphore, VkImage) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkFrameBoundaryANDROID was called, resulting in no-op behavior."); } static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice, const VkDebugMarkerObjectTagInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDebugMarkerSetObjectTagEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice, const VkDebugMarkerObjectNameInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDebugMarkerSetObjectNameEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } @@ -1095,6 +1101,12 @@ struct DeviceTable PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR{ noop::GetDeviceImageSubresourceLayoutKHR }; PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR{ noop::GetImageSubresourceLayout2KHR }; PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR{ noop::GetCalibratedTimestampsKHR }; + PFN_vkCmdBindDescriptorSets2KHR CmdBindDescriptorSets2KHR{ noop::CmdBindDescriptorSets2KHR }; + PFN_vkCmdPushConstants2KHR CmdPushConstants2KHR{ noop::CmdPushConstants2KHR }; + PFN_vkCmdPushDescriptorSet2KHR CmdPushDescriptorSet2KHR{ noop::CmdPushDescriptorSet2KHR }; + PFN_vkCmdPushDescriptorSetWithTemplate2KHR CmdPushDescriptorSetWithTemplate2KHR{ noop::CmdPushDescriptorSetWithTemplate2KHR }; + PFN_vkCmdSetDescriptorBufferOffsets2EXT CmdSetDescriptorBufferOffsets2EXT{ noop::CmdSetDescriptorBufferOffsets2EXT }; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT CmdBindDescriptorBufferEmbeddedSamplers2EXT{ noop::CmdBindDescriptorBufferEmbeddedSamplers2EXT }; PFN_vkFrameBoundaryANDROID FrameBoundaryANDROID{ noop::FrameBoundaryANDROID }; PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT{ noop::DebugMarkerSetObjectTagEXT }; PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT{ noop::DebugMarkerSetObjectNameEXT }; @@ -1736,6 +1748,12 @@ static void LoadDeviceTable(PFN_vkGetDeviceProcAddr gpa, VkDevice device, Device LoadFunction(gpa, device, "vkGetDeviceImageSubresourceLayoutKHR", &table->GetDeviceImageSubresourceLayoutKHR); LoadFunction(gpa, device, "vkGetImageSubresourceLayout2KHR", &table->GetImageSubresourceLayout2KHR); LoadFunction(gpa, device, "vkGetCalibratedTimestampsKHR", &table->GetCalibratedTimestampsKHR); + LoadFunction(gpa, device, "vkCmdBindDescriptorSets2KHR", &table->CmdBindDescriptorSets2KHR); + LoadFunction(gpa, device, "vkCmdPushConstants2KHR", &table->CmdPushConstants2KHR); + LoadFunction(gpa, device, "vkCmdPushDescriptorSet2KHR", &table->CmdPushDescriptorSet2KHR); + LoadFunction(gpa, device, "vkCmdPushDescriptorSetWithTemplate2KHR", &table->CmdPushDescriptorSetWithTemplate2KHR); + LoadFunction(gpa, device, "vkCmdSetDescriptorBufferOffsets2EXT", &table->CmdSetDescriptorBufferOffsets2EXT); + LoadFunction(gpa, device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", &table->CmdBindDescriptorBufferEmbeddedSamplers2EXT); LoadFunction(gpa, device, "vkFrameBoundaryANDROID", &table->FrameBoundaryANDROID); LoadFunction(gpa, device, "vkDebugMarkerSetObjectTagEXT", &table->DebugMarkerSetObjectTagEXT); LoadFunction(gpa, device, "vkDebugMarkerSetObjectNameEXT", &table->DebugMarkerSetObjectNameEXT); diff --git a/framework/generated/generated_vulkan_enum_to_json.cpp b/framework/generated/generated_vulkan_enum_to_json.cpp index f8f672aff..dddd7fe98 100644 --- a/framework/generated/generated_vulkan_enum_to_json.cpp +++ b/framework/generated/generated_vulkan_enum_to_json.cpp @@ -1403,6 +1403,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkBufferCreateFlagBits& va case VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: jdata = "VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; break; + case VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: + jdata = "VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -2438,6 +2441,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkDescriptorSetLayoutCreat case VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT: jdata = "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT"; break; + case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV: + jdata = "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -4775,6 +4781,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkImageCreateFlagBits& val case VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM: jdata = "VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM"; break; + case VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: + jdata = "VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -8553,89 +8562,89 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: jdata = "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR"; break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR"; break; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: jdata = "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR"; @@ -10275,6 +10284,15 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: jdata = "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR"; + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV"; + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM"; break; @@ -10335,6 +10353,33 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: jdata = "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR"; + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + jdata = "VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR"; + break; + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR"; + break; + case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR"; + break; + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR"; + break; + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR"; + break; + case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT"; + break; + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT"; + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV"; break; @@ -10827,11 +10872,11 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoCodecOperationFlagB case VK_VIDEO_CODEC_OPERATION_NONE_KHR: jdata = "VK_VIDEO_CODEC_OPERATION_NONE_KHR"; break; - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT: - jdata = "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT"; + case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: + jdata = "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR"; break; - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT: - jdata = "VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT"; + case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: + jdata = "VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR"; break; case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: jdata = "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR"; @@ -10992,35 +11037,35 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeFeedbackFlagB } } -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264CapabilityFlagBitsEXT& value, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264CapabilityFlagBitsKHR& value, const JsonOptions& options) { switch (value) { - case VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR"; break; default: jdata = to_hex_fixed_width(value); @@ -11028,23 +11073,23 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264Capabilit } } -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264RateControlFlagBitsEXT& value, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264RateControlFlagBitsKHR& value, const JsonOptions& options) { switch (value) { - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR"; break; default: jdata = to_hex_fixed_width(value); @@ -11052,68 +11097,68 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264RateContr } } -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264StdFlagBitsEXT& value, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264StdFlagBitsKHR& value, const JsonOptions& options) { switch (value) { - case VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT"; + case VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"; break; default: jdata = to_hex_fixed_width(value); @@ -11121,38 +11166,38 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264StdFlagBi } } -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265CapabilityFlagBitsEXT& value, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265CapabilityFlagBitsKHR& value, const JsonOptions& options) { switch (value) { - case VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR"; break; default: jdata = to_hex_fixed_width(value); @@ -11160,17 +11205,17 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265Capabilit } } -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265CtbSizeFlagBitsEXT& value, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265CtbSizeFlagBitsKHR& value, const JsonOptions& options) { switch (value) { - case VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR"; break; default: jdata = to_hex_fixed_width(value); @@ -11178,23 +11223,23 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265CtbSizeFl } } -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265RateControlFlagBitsEXT& value, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265RateControlFlagBitsKHR& value, const JsonOptions& options) { switch (value) { - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR"; break; default: jdata = to_hex_fixed_width(value); @@ -11202,71 +11247,71 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265RateContr } } -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265StdFlagBitsEXT& value, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265StdFlagBitsKHR& value, const JsonOptions& options) { switch (value) { - case VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"; break; default: jdata = to_hex_fixed_width(value); @@ -11274,20 +11319,20 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265StdFlagBi } } -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265TransformBlockSizeFlagBitsEXT& value, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265TransformBlockSizeFlagBitsKHR& value, const JsonOptions& options) { switch (value) { - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR"; break; - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT: - jdata = "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT"; + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR: + jdata = "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR"; break; default: jdata = to_hex_fixed_width(value); @@ -11373,6 +11418,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoSessionCreateFlagBi case VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR: jdata = "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR"; break; + case VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR: + jdata = "VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -11671,6 +11719,8 @@ void FieldToJson(VkBufferCreateFlags_t, nlohmann::ordered_json& jdata, const VkF return std::string("VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"); case VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: return std::string("VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"); + case VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: + return std::string("VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"); } return to_hex_fixed_width(flags); }); @@ -12238,6 +12288,8 @@ void FieldToJson(VkDescriptorSetLayoutCreateFlags_t, nlohmann::ordered_json& jda return std::string("VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV"); case VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT: return std::string("VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT"); + case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV: + return std::string("VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV"); } return to_hex_fixed_width(flags); }); @@ -13139,6 +13191,8 @@ void FieldToJson(VkImageCreateFlags_t, nlohmann::ordered_json& jdata, const VkFl return std::string("VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT"); case VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM: return std::string("VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM"); + case VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: + return std::string("VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"); } return to_hex_fixed_width(flags); }); @@ -14854,10 +14908,10 @@ void FieldToJson(VkVideoCodecOperationFlagsKHR_t, nlohmann::ordered_json& jdata, { case VK_VIDEO_CODEC_OPERATION_NONE_KHR: return std::string("VK_VIDEO_CODEC_OPERATION_NONE_KHR"); - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT: - return std::string("VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT"); - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT: - return std::string("VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT"); + case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: + return std::string("VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR"); + case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: + return std::string("VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR"); case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: return std::string("VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR"); case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: @@ -15055,7 +15109,7 @@ void FieldToJson(VkVideoEncodeFlagsKHR_t, nlohmann::ordered_json& jdata, const V jdata = to_hex_fixed_width(flags); } -void FieldToJson(VkVideoEncodeH264CapabilityFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +void FieldToJson(VkVideoEncodeH264CapabilityFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) { @@ -15066,30 +15120,30 @@ void FieldToJson(VkVideoEncodeH264CapabilityFlagsEXT_t, nlohmann::ordered_json& { switch (flags) { - case VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT"); + case VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR"); } return to_hex_fixed_width(flags); }); } -void FieldToJson(VkVideoEncodeH264RateControlFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +void FieldToJson(VkVideoEncodeH264RateControlFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) { @@ -15100,22 +15154,22 @@ void FieldToJson(VkVideoEncodeH264RateControlFlagsEXT_t, nlohmann::ordered_json& { switch (flags) { - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT"); + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR"); } return to_hex_fixed_width(flags); }); } -void FieldToJson(VkVideoEncodeH264StdFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +void FieldToJson(VkVideoEncodeH264StdFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) { @@ -15126,52 +15180,52 @@ void FieldToJson(VkVideoEncodeH264StdFlagsEXT_t, nlohmann::ordered_json& jdata, { switch (flags) { - case VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT"); - case VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT"); + case VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR"); + case VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"); } return to_hex_fixed_width(flags); }); } -void FieldToJson(VkVideoEncodeH265CapabilityFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +void FieldToJson(VkVideoEncodeH265CapabilityFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) { @@ -15182,32 +15236,32 @@ void FieldToJson(VkVideoEncodeH265CapabilityFlagsEXT_t, nlohmann::ordered_json& { switch (flags) { - case VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR"); } return to_hex_fixed_width(flags); }); } -void FieldToJson(VkVideoEncodeH265CtbSizeFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +void FieldToJson(VkVideoEncodeH265CtbSizeFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) { @@ -15218,18 +15272,18 @@ void FieldToJson(VkVideoEncodeH265CtbSizeFlagsEXT_t, nlohmann::ordered_json& jda { switch (flags) { - case VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT"); + case VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR"); } return to_hex_fixed_width(flags); }); } -void FieldToJson(VkVideoEncodeH265RateControlFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +void FieldToJson(VkVideoEncodeH265RateControlFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) { @@ -15240,22 +15294,22 @@ void FieldToJson(VkVideoEncodeH265RateControlFlagsEXT_t, nlohmann::ordered_json& { switch (flags) { - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT"); + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR"); } return to_hex_fixed_width(flags); }); } -void FieldToJson(VkVideoEncodeH265StdFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +void FieldToJson(VkVideoEncodeH265StdFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) { @@ -15266,54 +15320,54 @@ void FieldToJson(VkVideoEncodeH265StdFlagsEXT_t, nlohmann::ordered_json& jdata, { switch (flags) { - case VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT"); + case VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"); } return to_hex_fixed_width(flags); }); } -void FieldToJson(VkVideoEncodeH265TransformBlockSizeFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +void FieldToJson(VkVideoEncodeH265TransformBlockSizeFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) { @@ -15324,14 +15378,14 @@ void FieldToJson(VkVideoEncodeH265TransformBlockSizeFlagsEXT_t, nlohmann::ordere { switch (flags) { - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT"); - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT: - return std::string("VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT"); + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR"); + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR: + return std::string("VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR"); } return to_hex_fixed_width(flags); }); @@ -15412,6 +15466,8 @@ void FieldToJson(VkVideoSessionCreateFlagsKHR_t, nlohmann::ordered_json& jdata, return std::string("VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR"); case VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR: return std::string("VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR"); + case VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR: + return std::string("VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR"); } return to_hex_fixed_width(flags); }); diff --git a/framework/generated/generated_vulkan_enum_to_json.h b/framework/generated/generated_vulkan_enum_to_json.h index d9334d01a..baa481255 100644 --- a/framework/generated/generated_vulkan_enum_to_json.h +++ b/framework/generated/generated_vulkan_enum_to_json.h @@ -208,14 +208,14 @@ struct VkVideoEncodeCapabilityFlagsKHR_t { }; struct VkVideoEncodeContentFlagsKHR_t { }; struct VkVideoEncodeFeedbackFlagsKHR_t { }; struct VkVideoEncodeFlagsKHR_t { }; -struct VkVideoEncodeH264CapabilityFlagsEXT_t { }; -struct VkVideoEncodeH264RateControlFlagsEXT_t { }; -struct VkVideoEncodeH264StdFlagsEXT_t { }; -struct VkVideoEncodeH265CapabilityFlagsEXT_t { }; -struct VkVideoEncodeH265CtbSizeFlagsEXT_t { }; -struct VkVideoEncodeH265RateControlFlagsEXT_t { }; -struct VkVideoEncodeH265StdFlagsEXT_t { }; -struct VkVideoEncodeH265TransformBlockSizeFlagsEXT_t { }; +struct VkVideoEncodeH264CapabilityFlagsKHR_t { }; +struct VkVideoEncodeH264RateControlFlagsKHR_t { }; +struct VkVideoEncodeH264StdFlagsKHR_t { }; +struct VkVideoEncodeH265CapabilityFlagsKHR_t { }; +struct VkVideoEncodeH265CtbSizeFlagsKHR_t { }; +struct VkVideoEncodeH265RateControlFlagsKHR_t { }; +struct VkVideoEncodeH265StdFlagsKHR_t { }; +struct VkVideoEncodeH265TransformBlockSizeFlagsKHR_t { }; struct VkVideoEncodeRateControlFlagsKHR_t { }; struct VkVideoEncodeRateControlModeFlagsKHR_t { }; struct VkVideoEncodeUsageFlagsKHR_t { }; @@ -491,14 +491,14 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoDecodeUsageFlagBits void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeCapabilityFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeContentFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeFeedbackFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264CapabilityFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264RateControlFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264StdFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265CapabilityFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265CtbSizeFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265RateControlFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265StdFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265TransformBlockSizeFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264CapabilityFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264RateControlFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH264StdFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265CapabilityFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265CtbSizeFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265RateControlFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265StdFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeH265TransformBlockSizeFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeRateControlModeFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeTuningModeKHR& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkVideoEncodeUsageFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); @@ -669,14 +669,14 @@ void FieldToJson(VkVideoEncodeCapabilityFlagsKHR_t, nlohmann::ordered_json& jdat void FieldToJson(VkVideoEncodeContentFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkVideoEncodeFeedbackFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkVideoEncodeFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(VkVideoEncodeH264CapabilityFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(VkVideoEncodeH264RateControlFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(VkVideoEncodeH264StdFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(VkVideoEncodeH265CapabilityFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(VkVideoEncodeH265CtbSizeFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(VkVideoEncodeH265RateControlFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(VkVideoEncodeH265StdFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(VkVideoEncodeH265TransformBlockSizeFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkVideoEncodeH264CapabilityFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkVideoEncodeH264RateControlFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkVideoEncodeH264StdFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkVideoEncodeH265CapabilityFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkVideoEncodeH265CtbSizeFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkVideoEncodeH265RateControlFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkVideoEncodeH265StdFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkVideoEncodeH265TransformBlockSizeFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkVideoEncodeRateControlFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkVideoEncodeRateControlModeFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkVideoEncodeUsageFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); diff --git a/framework/generated/generated_vulkan_enum_to_string.cpp b/framework/generated/generated_vulkan_enum_to_string.cpp index 3998cf5d4..68faef9d3 100644 --- a/framework/generated/generated_vulkan_enum_to_string.cpp +++ b/framework/generated/generated_vulkan_enum_to_string.cpp @@ -531,6 +531,7 @@ template <> std::string ToString(const VkBufferCreateFla case VK_BUFFER_CREATE_PROTECTED_BIT: return "VK_BUFFER_CREATE_PROTECTED_BIT"; case VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: return "VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT"; case VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: return "VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT"; + case VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: return "VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"; default: break; } return "Unhandled VkBufferCreateFlagBits"; @@ -759,6 +760,7 @@ template <> std::string ToString(const VkDe case VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT: return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT"; case VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV: return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV"; case VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT: return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT"; + case VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV: return "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV"; default: break; } return "Unhandled VkDescriptorSetLayoutCreateFlagBits"; @@ -1300,6 +1302,7 @@ template <> std::string ToString(const VkImageCreateFlagB case VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT: return "VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT"; case VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT: return "VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT"; case VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM: return "VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM"; + case VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: return "VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR"; default: break; } return "Unhandled VkImageCreateFlagBits"; @@ -2419,34 +2422,34 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: return "VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX"; case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX"; case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT"; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR"; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR"; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR"; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR"; @@ -2993,6 +2996,9 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM"; case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: return "VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM"; case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: return "VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM"; @@ -3013,6 +3019,15 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT"; case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR"; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: return "VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR"; + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR: return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR"; + case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR: return "VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR"; + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR: return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR"; + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR: return "VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR"; + case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: return "VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT"; + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: return "VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV"; default: break; } @@ -3930,8 +3945,8 @@ template <> std::string ToString(const VkVideo { switch (value) { case VK_VIDEO_CODEC_OPERATION_NONE_KHR: return "VK_VIDEO_CODEC_OPERATION_NONE_KHR"; - case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT: return "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT"; - case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT: return "VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT"; + case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: return "VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR"; + case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: return "VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR"; case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: return "VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR"; case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: return "VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR"; default: break; @@ -3982,6 +3997,7 @@ template <> std::string ToString(const VkVideoS switch (value) { case VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR: return "VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR"; case VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR: return "VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR"; + case VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR: return "VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR"; default: break; } return "Unhandled VkVideoSessionCreateFlagBitsKHR"; @@ -4024,6 +4040,187 @@ template <> std::string ToString(VkFlags vkFlags, return BitmaskToString(vkFlags); } +template <> std::string ToString(const VkVideoEncodeH264CapabilityFlagBitsKHR& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: return "VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: return "VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR: return "VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR: return "VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: return "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: return "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: return "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR: return "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR: return "VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR"; + default: break; + } + return "Unhandled VkVideoEncodeH264CapabilityFlagBitsKHR"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + +template <> std::string ToString(const VkVideoEncodeH264RateControlFlagBitsKHR& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR"; + default: break; + } + return "Unhandled VkVideoEncodeH264RateControlFlagBitsKHR"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + +template <> std::string ToString(const VkVideoEncodeH264StdFlagBitsKHR& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR"; + case VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: return "VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"; + default: break; + } + return "Unhandled VkVideoEncodeH264StdFlagBitsKHR"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + +template <> std::string ToString(const VkVideoEncodeH265CapabilityFlagBitsKHR& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR"; + default: break; + } + return "Unhandled VkVideoEncodeH265CapabilityFlagBitsKHR"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + +template <> std::string ToString(const VkVideoEncodeH265CtbSizeFlagBitsKHR& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR: return "VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR"; + default: break; + } + return "Unhandled VkVideoEncodeH265CtbSizeFlagBitsKHR"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + +template <> std::string ToString(const VkVideoEncodeH265RateControlFlagBitsKHR& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR"; + default: break; + } + return "Unhandled VkVideoEncodeH265RateControlFlagBitsKHR"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + +template <> std::string ToString(const VkVideoEncodeH265StdFlagBitsKHR& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: return "VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR"; + default: break; + } + return "Unhandled VkVideoEncodeH265StdFlagBitsKHR"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + +template <> std::string ToString(const VkVideoEncodeH265TransformBlockSizeFlagBitsKHR& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR: return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR: return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR: return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR"; + case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR: return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR"; + default: break; + } + return "Unhandled VkVideoEncodeH265TransformBlockSizeFlagBitsKHR"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + template <> std::string ToString(const VkVideoDecodeH264PictureLayoutFlagBitsKHR& value, ToStringFlags, uint32_t, uint32_t) { switch (value) { @@ -4483,187 +4680,6 @@ template <> std::string ToString(const VkRasterizationO return "Unhandled VkRasterizationOrderAMD"; } -template <> std::string ToString(const VkVideoEncodeH264CapabilityFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) -{ - switch (value) { - case VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT: return "VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT: return "VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT: return "VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT: return "VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT: return "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT: return "VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT: return "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT: return "VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT: return "VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_EXT"; - default: break; - } - return "Unhandled VkVideoEncodeH264CapabilityFlagBitsEXT"; -} - -template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) -{ - return BitmaskToString(vkFlags); -} - -template <> std::string ToString(const VkVideoEncodeH264RateControlFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) -{ - switch (value) { - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT: return "VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_EXT"; - default: break; - } - return "Unhandled VkVideoEncodeH264RateControlFlagBitsEXT"; -} - -template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) -{ - return BitmaskToString(vkFlags); -} - -template <> std::string ToString(const VkVideoEncodeH264StdFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) -{ - switch (value) { - case VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_EXT"; - case VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT: return "VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT"; - default: break; - } - return "Unhandled VkVideoEncodeH264StdFlagBitsEXT"; -} - -template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) -{ - return BitmaskToString(vkFlags); -} - -template <> std::string ToString(const VkVideoEncodeH265CapabilityFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) -{ - switch (value) { - case VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_EXT"; - default: break; - } - return "Unhandled VkVideoEncodeH265CapabilityFlagBitsEXT"; -} - -template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) -{ - return BitmaskToString(vkFlags); -} - -template <> std::string ToString(const VkVideoEncodeH265CtbSizeFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) -{ - switch (value) { - case VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT: return "VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_EXT"; - default: break; - } - return "Unhandled VkVideoEncodeH265CtbSizeFlagBitsEXT"; -} - -template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) -{ - return BitmaskToString(vkFlags); -} - -template <> std::string ToString(const VkVideoEncodeH265RateControlFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) -{ - switch (value) { - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT: return "VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_EXT"; - default: break; - } - return "Unhandled VkVideoEncodeH265RateControlFlagBitsEXT"; -} - -template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) -{ - return BitmaskToString(vkFlags); -} - -template <> std::string ToString(const VkVideoEncodeH265StdFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) -{ - switch (value) { - case VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT: return "VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_EXT"; - default: break; - } - return "Unhandled VkVideoEncodeH265StdFlagBitsEXT"; -} - -template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) -{ - return BitmaskToString(vkFlags); -} - -template <> std::string ToString(const VkVideoEncodeH265TransformBlockSizeFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) -{ - switch (value) { - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT: return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT: return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT: return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_EXT"; - case VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT: return "VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_EXT"; - default: break; - } - return "Unhandled VkVideoEncodeH265TransformBlockSizeFlagBitsEXT"; -} - -template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) -{ - return BitmaskToString(vkFlags); -} - template <> std::string ToString(const VkShaderInfoTypeAMD& value, ToStringFlags, uint32_t, uint32_t) { switch (value) { diff --git a/framework/generated/generated_vulkan_enum_to_string.h b/framework/generated/generated_vulkan_enum_to_string.h index 1f9573481..69b116815 100644 --- a/framework/generated/generated_vulkan_enum_to_string.h +++ b/framework/generated/generated_vulkan_enum_to_string.h @@ -267,6 +267,22 @@ template <> std::string ToString(const VkVid template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkVideoDecodeUsageFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkVideoEncodeH264CapabilityFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkVideoEncodeH264RateControlFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkVideoEncodeH264StdFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkVideoEncodeH265CapabilityFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkVideoEncodeH265CtbSizeFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkVideoEncodeH265RateControlFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkVideoEncodeH265StdFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkVideoEncodeH265TransformBlockSizeFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkVideoDecodeH264PictureLayoutFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkAcquireProfilingLockFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); @@ -301,22 +317,6 @@ template <> std::string ToString(const VkDebugReportFl template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkDebugReportObjectTypeEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkRasterizationOrderAMD& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(const VkVideoEncodeH264CapabilityFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(const VkVideoEncodeH264RateControlFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(const VkVideoEncodeH264StdFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(const VkVideoEncodeH265CapabilityFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(const VkVideoEncodeH265CtbSizeFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(const VkVideoEncodeH265RateControlFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(const VkVideoEncodeH265StdFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(const VkVideoEncodeH265TransformBlockSizeFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkShaderInfoTypeAMD& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkExternalMemoryFeatureFlagBitsNV& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); diff --git a/framework/generated/generated_vulkan_feature_util.cpp b/framework/generated/generated_vulkan_feature_util.cpp index 2281fb843..2e1f5adf1 100644 --- a/framework/generated/generated_vulkan_feature_util.cpp +++ b/framework/generated/generated_vulkan_feature_util.cpp @@ -1720,6 +1720,21 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + { + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR* currentNext = reinterpret_cast(next); + VkPhysicalDeviceVideoMaintenance1FeaturesKHR query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->videoMaintenance1 == VK_TRUE) && (query.videoMaintenance1 == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature videoMaintenance1 %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->videoMaintenance1 = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* currentNext = reinterpret_cast(next); @@ -1742,6 +1757,21 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + { + const VkPhysicalDeviceMaintenance6FeaturesKHR* currentNext = reinterpret_cast(next); + VkPhysicalDeviceMaintenance6FeaturesKHR query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->maintenance6 == VK_TRUE) && (query.maintenance6 == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature maintenance6 %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->maintenance6 = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { const VkPhysicalDeviceTransformFeedbackFeaturesEXT* currentNext = reinterpret_cast(next); @@ -4031,6 +4061,28 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + { + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV* currentNext = reinterpret_cast(next); + VkPhysicalDevicePerStageDescriptorSetFeaturesNV query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->perStageDescriptorSet == VK_TRUE) && (query.perStageDescriptorSet == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature perStageDescriptorSet %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->perStageDescriptorSet = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + if ((currentNext->dynamicPipelineLayout == VK_TRUE) && (query.dynamicPipelineLayout == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature dynamicPipelineLayout %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->dynamicPipelineLayout = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { const VkPhysicalDeviceImageProcessing2FeaturesQCOM* currentNext = reinterpret_cast(next); diff --git a/framework/generated/generated_vulkan_json_consumer.cpp b/framework/generated/generated_vulkan_json_consumer.cpp index c362a64f2..0faf420b5 100644 --- a/framework/generated/generated_vulkan_json_consumer.cpp +++ b/framework/generated/generated_vulkan_json_consumer.cpp @@ -6018,6 +6018,90 @@ void VulkanExportJsonConsumer::Process_vkGetCalibratedTimestampsKHR( WriteBlockEnd(); } +void VulkanExportJsonConsumer::Process_vkCmdBindDescriptorSets2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorSetsInfo) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdBindDescriptorSets2KHR"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options); + FieldToJson(args["pBindDescriptorSetsInfo"], pBindDescriptorSetsInfo, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkCmdPushConstants2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushConstantsInfo) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdPushConstants2KHR"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options); + FieldToJson(args["pPushConstantsInfo"], pPushConstantsInfo, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkCmdPushDescriptorSet2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetInfo) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdPushDescriptorSet2KHR"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options); + FieldToJson(args["pPushDescriptorSetInfo"], pPushDescriptorSetInfo, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkCmdPushDescriptorSetWithTemplate2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetWithTemplateInfo) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdPushDescriptorSetWithTemplate2KHR"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options); + FieldToJson(args["pPushDescriptorSetWithTemplateInfo"], pPushDescriptorSetWithTemplateInfo, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkCmdSetDescriptorBufferOffsets2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pSetDescriptorBufferOffsetsInfo) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdSetDescriptorBufferOffsets2EXT"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options); + FieldToJson(args["pSetDescriptorBufferOffsetsInfo"], pSetDescriptorBufferOffsetsInfo, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorBufferEmbeddedSamplersInfo) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options); + FieldToJson(args["pBindDescriptorBufferEmbeddedSamplersInfo"], pBindDescriptorBufferEmbeddedSamplersInfo, json_options); + WriteBlockEnd(); +} + void VulkanExportJsonConsumer::Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, diff --git a/framework/generated/generated_vulkan_json_consumer.h b/framework/generated/generated_vulkan_json_consumer.h index 4ee8225bf..d4eab9e61 100644 --- a/framework/generated/generated_vulkan_json_consumer.h +++ b/framework/generated/generated_vulkan_json_consumer.h @@ -2456,6 +2456,36 @@ class VulkanExportJsonConsumer : public VulkanExportJsonConsumerBase PointerDecoder* pTimestamps, PointerDecoder* pMaxDeviation) override; + virtual void Process_vkCmdBindDescriptorSets2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorSetsInfo) override; + + virtual void Process_vkCmdPushConstants2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushConstantsInfo) override; + + virtual void Process_vkCmdPushDescriptorSet2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetInfo) override; + + virtual void Process_vkCmdPushDescriptorSetWithTemplate2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetWithTemplateInfo) override; + + virtual void Process_vkCmdSetDescriptorBufferOffsets2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pSetDescriptorBufferOffsetsInfo) override; + + virtual void Process_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorBufferEmbeddedSamplersInfo) override; + virtual void Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, diff --git a/framework/generated/generated_vulkan_referenced_resource_consumer.cpp b/framework/generated/generated_vulkan_referenced_resource_consumer.cpp index a38a681fa..2d4d15090 100644 --- a/framework/generated/generated_vulkan_referenced_resource_consumer.cpp +++ b/framework/generated/generated_vulkan_referenced_resource_consumer.cpp @@ -1453,6 +1453,162 @@ void VulkanReferencedResourceConsumer::Process_vkCmdBindIndexBuffer2KHR( GetTable().AddResourceToUser(commandBuffer, buffer); } +void VulkanReferencedResourceConsumer::Process_vkCmdBindDescriptorSets2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorSetsInfo) +{ + assert(pBindDescriptorSetsInfo != nullptr); + + if (!pBindDescriptorSetsInfo->IsNull() && (pBindDescriptorSetsInfo->HasData())) + { + auto pBindDescriptorSetsInfo_ptr = pBindDescriptorSetsInfo->GetMetaStructPointer(); + + if (!pBindDescriptorSetsInfo_ptr->pDescriptorSets.IsNull() && (pBindDescriptorSetsInfo_ptr->pDescriptorSets.HasData())) + { + auto pDescriptorSets_ptr = pBindDescriptorSetsInfo_ptr->pDescriptorSets.GetPointer(); + size_t pDescriptorSets_count = pBindDescriptorSetsInfo_ptr->pDescriptorSets.GetLength(); + for (size_t pDescriptorSets_index = 0; pDescriptorSets_index < pDescriptorSets_count; ++pDescriptorSets_index) + { + GetTable().AddContainerToUser(commandBuffer, pDescriptorSets_ptr[pDescriptorSets_index]); + } + } + } +} + +void VulkanReferencedResourceConsumer::Process_vkCmdPushConstants2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushConstantsInfo) +{ + assert(pPushConstantsInfo != nullptr); + + if (!pPushConstantsInfo->IsNull() && (pPushConstantsInfo->HasData())) + { + auto pPushConstantsInfo_ptr = pPushConstantsInfo->GetMetaStructPointer(); + } +} + +void VulkanReferencedResourceConsumer::Process_vkCmdPushDescriptorSet2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetInfo) +{ + assert(pPushDescriptorSetInfo != nullptr); + + if (!pPushDescriptorSetInfo->IsNull() && (pPushDescriptorSetInfo->HasData())) + { + auto pPushDescriptorSetInfo_ptr = pPushDescriptorSetInfo->GetMetaStructPointer(); + + if (!pPushDescriptorSetInfo_ptr->pDescriptorWrites->IsNull() && (pPushDescriptorSetInfo_ptr->pDescriptorWrites->HasData())) + { + auto pDescriptorWrites_ptr = pPushDescriptorSetInfo_ptr->pDescriptorWrites->GetMetaStructPointer(); + size_t pDescriptorWrites_count = pPushDescriptorSetInfo_ptr->pDescriptorWrites->GetLength(); + for (size_t pDescriptorWrites_index = 0; pDescriptorWrites_index < pDescriptorWrites_count; ++pDescriptorWrites_index) + { + const VkBaseInStructure* pnext_header = nullptr; + if (pDescriptorWrites_ptr->pNext != nullptr) + { + pnext_header = reinterpret_cast(pDescriptorWrites_ptr->pNext->GetPointer()); + } + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: + { + auto pnext_value = reinterpret_cast(pDescriptorWrites_ptr->pNext->GetPointer()); + if (!pnext_value->pAccelerationStructures.IsNull() && (pnext_value->pAccelerationStructures.HasData())) + { + auto pAccelerationStructures_ptr = pnext_value->pAccelerationStructures.GetPointer(); + size_t pAccelerationStructures_count = pnext_value->pAccelerationStructures.GetLength(); + for (size_t pAccelerationStructures_index = 0; pAccelerationStructures_index < pAccelerationStructures_count; ++pAccelerationStructures_index) + { + GetTable().AddResourceToUser(commandBuffer, pAccelerationStructures_ptr[pAccelerationStructures_index]); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + GetTable().AddContainerToUser(commandBuffer, pDescriptorWrites_ptr[pDescriptorWrites_index].dstSet); + + if (!pDescriptorWrites_ptr[pDescriptorWrites_index].pImageInfo->IsNull() && (pDescriptorWrites_ptr[pDescriptorWrites_index].pImageInfo->HasData())) + { + auto pImageInfo_ptr = pDescriptorWrites_ptr[pDescriptorWrites_index].pImageInfo->GetMetaStructPointer(); + size_t pImageInfo_count = pDescriptorWrites_ptr[pDescriptorWrites_index].pImageInfo->GetLength(); + for (size_t pImageInfo_index = 0; pImageInfo_index < pImageInfo_count; ++pImageInfo_index) + { + GetTable().AddResourceToUser(commandBuffer, pImageInfo_ptr[pImageInfo_index].imageView); + } + } + + if (!pDescriptorWrites_ptr[pDescriptorWrites_index].pBufferInfo->IsNull() && (pDescriptorWrites_ptr[pDescriptorWrites_index].pBufferInfo->HasData())) + { + auto pBufferInfo_ptr = pDescriptorWrites_ptr[pDescriptorWrites_index].pBufferInfo->GetMetaStructPointer(); + size_t pBufferInfo_count = pDescriptorWrites_ptr[pDescriptorWrites_index].pBufferInfo->GetLength(); + for (size_t pBufferInfo_index = 0; pBufferInfo_index < pBufferInfo_count; ++pBufferInfo_index) + { + GetTable().AddResourceToUser(commandBuffer, pBufferInfo_ptr[pBufferInfo_index].buffer); + } + } + + if (!pDescriptorWrites_ptr[pDescriptorWrites_index].pTexelBufferView.IsNull() && (pDescriptorWrites_ptr[pDescriptorWrites_index].pTexelBufferView.HasData())) + { + auto pTexelBufferView_ptr = pDescriptorWrites_ptr[pDescriptorWrites_index].pTexelBufferView.GetPointer(); + size_t pTexelBufferView_count = pDescriptorWrites_ptr[pDescriptorWrites_index].pTexelBufferView.GetLength(); + for (size_t pTexelBufferView_index = 0; pTexelBufferView_index < pTexelBufferView_count; ++pTexelBufferView_index) + { + GetTable().AddResourceToUser(commandBuffer, pTexelBufferView_ptr[pTexelBufferView_index]); + } + } + } + } + } +} + +void VulkanReferencedResourceConsumer::Process_vkCmdPushDescriptorSetWithTemplate2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetWithTemplateInfo) +{ + assert(pPushDescriptorSetWithTemplateInfo != nullptr); + + if (!pPushDescriptorSetWithTemplateInfo->IsNull() && (pPushDescriptorSetWithTemplateInfo->HasData())) + { + auto pPushDescriptorSetWithTemplateInfo_ptr = pPushDescriptorSetWithTemplateInfo->GetMetaStructPointer(); + } +} + +void VulkanReferencedResourceConsumer::Process_vkCmdSetDescriptorBufferOffsets2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pSetDescriptorBufferOffsetsInfo) +{ + assert(pSetDescriptorBufferOffsetsInfo != nullptr); + + if (!pSetDescriptorBufferOffsetsInfo->IsNull() && (pSetDescriptorBufferOffsetsInfo->HasData())) + { + auto pSetDescriptorBufferOffsetsInfo_ptr = pSetDescriptorBufferOffsetsInfo->GetMetaStructPointer(); + } +} + +void VulkanReferencedResourceConsumer::Process_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorBufferEmbeddedSamplersInfo) +{ + assert(pBindDescriptorBufferEmbeddedSamplersInfo != nullptr); + + if (!pBindDescriptorBufferEmbeddedSamplersInfo->IsNull() && (pBindDescriptorBufferEmbeddedSamplersInfo->HasData())) + { + auto pBindDescriptorBufferEmbeddedSamplersInfo_ptr = pBindDescriptorBufferEmbeddedSamplersInfo->GetMetaStructPointer(); + } +} + void VulkanReferencedResourceConsumer::Process_vkCmdBindTransformFeedbackBuffersEXT( const ApiCallInfo& call_info, format::HandleId commandBuffer, diff --git a/framework/generated/generated_vulkan_referenced_resource_consumer.h b/framework/generated/generated_vulkan_referenced_resource_consumer.h index 7204f79d7..6896bc8f3 100644 --- a/framework/generated/generated_vulkan_referenced_resource_consumer.h +++ b/framework/generated/generated_vulkan_referenced_resource_consumer.h @@ -451,6 +451,36 @@ class VulkanReferencedResourceConsumer : public VulkanReferencedResourceConsumer VkDeviceSize size, VkIndexType indexType) override; + virtual void Process_vkCmdBindDescriptorSets2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorSetsInfo) override; + + virtual void Process_vkCmdPushConstants2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushConstantsInfo) override; + + virtual void Process_vkCmdPushDescriptorSet2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetInfo) override; + + virtual void Process_vkCmdPushDescriptorSetWithTemplate2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetWithTemplateInfo) override; + + virtual void Process_vkCmdSetDescriptorBufferOffsets2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pSetDescriptorBufferOffsetsInfo) override; + + virtual void Process_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorBufferEmbeddedSamplersInfo) override; + virtual void Process_vkCmdBindTransformFeedbackBuffersEXT( const ApiCallInfo& call_info, format::HandleId commandBuffer, diff --git a/framework/generated/generated_vulkan_replay_consumer.cpp b/framework/generated/generated_vulkan_replay_consumer.cpp index 5191ac3b1..13439aeb5 100644 --- a/framework/generated/generated_vulkan_replay_consumer.cpp +++ b/framework/generated/generated_vulkan_replay_consumer.cpp @@ -5475,6 +5475,78 @@ void VulkanReplayConsumer::Process_vkGetCalibratedTimestampsKHR( CheckResult("vkGetCalibratedTimestampsKHR", returnValue, replay_result, call_info); } +void VulkanReplayConsumer::Process_vkCmdBindDescriptorSets2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorSetsInfo) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + const VkBindDescriptorSetsInfoKHR* in_pBindDescriptorSetsInfo = pBindDescriptorSetsInfo->GetPointer(); + MapStructHandles(pBindDescriptorSetsInfo->GetMetaStructPointer(), GetObjectInfoTable()); + + GetDeviceTable(in_commandBuffer)->CmdBindDescriptorSets2KHR(in_commandBuffer, in_pBindDescriptorSetsInfo); +} + +void VulkanReplayConsumer::Process_vkCmdPushConstants2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushConstantsInfo) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + const VkPushConstantsInfoKHR* in_pPushConstantsInfo = pPushConstantsInfo->GetPointer(); + MapStructHandles(pPushConstantsInfo->GetMetaStructPointer(), GetObjectInfoTable()); + + GetDeviceTable(in_commandBuffer)->CmdPushConstants2KHR(in_commandBuffer, in_pPushConstantsInfo); +} + +void VulkanReplayConsumer::Process_vkCmdPushDescriptorSet2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetInfo) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + const VkPushDescriptorSetInfoKHR* in_pPushDescriptorSetInfo = pPushDescriptorSetInfo->GetPointer(); + MapStructHandles(pPushDescriptorSetInfo->GetMetaStructPointer(), GetObjectInfoTable()); + + GetDeviceTable(in_commandBuffer)->CmdPushDescriptorSet2KHR(in_commandBuffer, in_pPushDescriptorSetInfo); +} + +void VulkanReplayConsumer::Process_vkCmdPushDescriptorSetWithTemplate2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetWithTemplateInfo) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + const VkPushDescriptorSetWithTemplateInfoKHR* in_pPushDescriptorSetWithTemplateInfo = pPushDescriptorSetWithTemplateInfo->GetPointer(); + MapStructHandles(pPushDescriptorSetWithTemplateInfo->GetMetaStructPointer(), GetObjectInfoTable()); + + GetDeviceTable(in_commandBuffer)->CmdPushDescriptorSetWithTemplate2KHR(in_commandBuffer, in_pPushDescriptorSetWithTemplateInfo); +} + +void VulkanReplayConsumer::Process_vkCmdSetDescriptorBufferOffsets2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pSetDescriptorBufferOffsetsInfo) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + const VkSetDescriptorBufferOffsetsInfoEXT* in_pSetDescriptorBufferOffsetsInfo = pSetDescriptorBufferOffsetsInfo->GetPointer(); + MapStructHandles(pSetDescriptorBufferOffsetsInfo->GetMetaStructPointer(), GetObjectInfoTable()); + + GetDeviceTable(in_commandBuffer)->CmdSetDescriptorBufferOffsets2EXT(in_commandBuffer, in_pSetDescriptorBufferOffsetsInfo); +} + +void VulkanReplayConsumer::Process_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorBufferEmbeddedSamplersInfo) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* in_pBindDescriptorBufferEmbeddedSamplersInfo = pBindDescriptorBufferEmbeddedSamplersInfo->GetPointer(); + MapStructHandles(pBindDescriptorBufferEmbeddedSamplersInfo->GetMetaStructPointer(), GetObjectInfoTable()); + + GetDeviceTable(in_commandBuffer)->CmdBindDescriptorBufferEmbeddedSamplers2EXT(in_commandBuffer, in_pBindDescriptorBufferEmbeddedSamplersInfo); +} + void VulkanReplayConsumer::Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, @@ -10481,6 +10553,146 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -11016,6 +11228,16 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -11036,209 +11258,114 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: + case VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: + case VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: + case VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: + case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: + case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: @@ -13006,6 +13133,11 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); diff --git a/framework/generated/generated_vulkan_replay_consumer.h b/framework/generated/generated_vulkan_replay_consumer.h index a29429fed..3af5067f6 100644 --- a/framework/generated/generated_vulkan_replay_consumer.h +++ b/framework/generated/generated_vulkan_replay_consumer.h @@ -2489,6 +2489,36 @@ class VulkanReplayConsumer : public VulkanReplayConsumerBase PointerDecoder* pTimestamps, PointerDecoder* pMaxDeviation) override; + virtual void Process_vkCmdBindDescriptorSets2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorSetsInfo) override; + + virtual void Process_vkCmdPushConstants2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushConstantsInfo) override; + + virtual void Process_vkCmdPushDescriptorSet2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetInfo) override; + + virtual void Process_vkCmdPushDescriptorSetWithTemplate2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pPushDescriptorSetWithTemplateInfo) override; + + virtual void Process_vkCmdSetDescriptorBufferOffsets2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pSetDescriptorBufferOffsetsInfo) override; + + virtual void Process_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pBindDescriptorBufferEmbeddedSamplersInfo) override; + virtual void Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, diff --git a/framework/generated/generated_vulkan_struct_decoders.cpp b/framework/generated/generated_vulkan_struct_decoders.cpp index 09226f773..d4bfbcc22 100644 --- a/framework/generated/generated_vulkan_struct_decoders.cpp +++ b/framework/generated/generated_vulkan_struct_decoders.cpp @@ -8123,46 +8123,94 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDe return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264ProfileInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264CapabilitiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264ProfileInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH264CapabilitiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdProfileIdc)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pictureLayout)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSliceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPPictureL0ReferenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBPictureL0ReferenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxL1ReferenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTemporalLayerCount)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->expectDyadicTemporalLayerPattern)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minQp)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxQp)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiresGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSyntaxFlags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264CapabilitiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QpKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264CapabilitiesKHR* value = wrapper->decoded_value; + VkVideoEncodeH264QpKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpI)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpP)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpB)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QualityLevelPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264QualityLevelPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredRateControlFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredGopFrameCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredIdrPeriod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredConsecutiveBFrameCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredTemporalLayerCount)); + wrapper->preferredConstantQp = DecodeAllocator::Allocate(); + wrapper->preferredConstantQp->decoded_value = &(value->preferredConstantQp); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->preferredConstantQp); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredMaxL0ReferenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredMaxL1ReferenceCount)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredStdEntropyCodingModeFlag)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264SessionCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxLevelIdc)); bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); - wrapper->fieldOffsetGranularity = DecodeAllocator::Allocate(); - wrapper->fieldOffsetGranularity->decoded_value = &(value->fieldOffsetGranularity); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fieldOffsetGranularity); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersAddInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264SessionParametersAddInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH264SessionParametersAddInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); @@ -8179,487 +8227,718 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDe return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264SessionParametersCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH264SessionParametersCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdSPSCount)); bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdPPSCount)); - wrapper->pParametersAddInfo = DecodeAllocator::Allocate>(); + wrapper->pParametersAddInfo = DecodeAllocator::Allocate>(); bytes_read += wrapper->pParametersAddInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264PictureInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersGetInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264PictureInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH264SessionParametersGetInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pStdPictureInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdPictureInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sliceCount)); - bytes_read += wrapper->pSliceOffsets.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSliceOffsets = wrapper->pSliceOffsets.GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdSPS)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdPPS)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSId)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSId)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264DpbSlotInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264DpbSlotInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH264SessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pStdReferenceInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdReferenceInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdSPSOverrides)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingFragmentShadingRateAttachmentInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264NaluSliceInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingFragmentShadingRateAttachmentInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH264NaluSliceInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->imageView)); - value->imageView = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageLayout)); - wrapper->shadingRateAttachmentTexelSize = DecodeAllocator::Allocate(); - wrapper->shadingRateAttachmentTexelSize->decoded_value = &(value->shadingRateAttachmentTexelSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->shadingRateAttachmentTexelSize); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->constantQp)); + wrapper->pStdSliceHeader = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSliceHeader->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdSliceHeader = wrapper->pStdSliceHeader->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingFragmentDensityMapAttachmentInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264PictureInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingFragmentDensityMapAttachmentInfoEXT* value = wrapper->decoded_value; + VkVideoEncodeH264PictureInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->imageView)); - value->imageView = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->naluSliceEntryCount)); + wrapper->pNaluSliceEntries = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pNaluSliceEntries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pNaluSliceEntries = wrapper->pNaluSliceEntries->GetPointer(); + wrapper->pStdPictureInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPictureInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->generatePrefixNalu)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentSampleCountInfoAMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264DpbSlotInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAttachmentSampleCountInfoAMD* value = wrapper->decoded_value; + VkVideoEncodeH264DpbSlotInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentCount)); - bytes_read += wrapper->pColorAttachmentSamples.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pColorAttachmentSamples = wrapper->pColorAttachmentSamples.GetPointer(); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilAttachmentSamples)); + wrapper->pStdReferenceInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdReferenceInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiviewPerViewAttributesInfoNVX* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264ProfileInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMultiviewPerViewAttributesInfoNVX* value = wrapper->decoded_value; + VkVideoEncodeH264ProfileInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewAttributes)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewAttributesPositionXOnly)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdProfileIdc)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryWin32HandleInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportMemoryWin32HandleInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH264RateControlInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->handle)); - value->handle = nullptr; - bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->name = wrapper->name.GetPointer(); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopFrameCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->idrPeriod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->consecutiveBFrameCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->temporalLayerCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264FrameSizeKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportMemoryWin32HandleInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH264FrameSizeKHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pAttributes = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pAttributes->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAttributes = wrapper->pAttributes->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dwAccess)); - bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->name = wrapper->name.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameISize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->framePSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameBSize)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryWin32HandlePropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlLayerInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryWin32HandlePropertiesKHR* value = wrapper->decoded_value; + VkVideoEncodeH264RateControlLayerInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryTypeBits)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMinQp)); + wrapper->minQp = DecodeAllocator::Allocate(); + wrapper->minQp->decoded_value = &(value->minQp); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minQp); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxQp)); + wrapper->maxQp = DecodeAllocator::Allocate(); + wrapper->maxQp->decoded_value = &(value->maxQp); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxQp); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxFrameSize)); + wrapper->maxFrameSize = DecodeAllocator::Allocate(); + wrapper->maxFrameSize->decoded_value = &(value->maxFrameSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFrameSize); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetWin32HandleInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264GopRemainingFrameInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryGetWin32HandleInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH264GopRemainingFrameInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); - value->memory = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingI)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingP)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingB)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryFdInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265CapabilitiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportMemoryFdInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH265CapabilitiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fd)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSliceSegmentCount)); + wrapper->maxTiles = DecodeAllocator::Allocate(); + wrapper->maxTiles->decoded_value = &(value->maxTiles); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxTiles); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ctbSizes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformBlockSizes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPPictureL0ReferenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBPictureL0ReferenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxL1ReferenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubLayerCount)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->expectDyadicTemporalSubLayerPattern)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minQp)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxQp)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiresGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSyntaxFlags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryFdPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryFdPropertiesKHR* value = wrapper->decoded_value; + VkVideoEncodeH265SessionCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryTypeBits)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxLevelIdc)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetFdInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QpKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryGetFdInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH265QpKHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); - value->memory = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpI)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpP)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpB)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkWin32KeyedMutexAcquireReleaseInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH265QualityLevelPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->acquireCount)); - bytes_read += wrapper->pAcquireSyncs.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAcquireSyncs = nullptr; - bytes_read += wrapper->pAcquireKeys.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAcquireKeys = wrapper->pAcquireKeys.GetPointer(); - bytes_read += wrapper->pAcquireTimeouts.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAcquireTimeouts = wrapper->pAcquireTimeouts.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->releaseCount)); - bytes_read += wrapper->pReleaseSyncs.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pReleaseSyncs = nullptr; - bytes_read += wrapper->pReleaseKeys.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - value->pReleaseKeys = wrapper->pReleaseKeys.GetPointer(); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredRateControlFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredGopFrameCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredIdrPeriod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredConsecutiveBFrameCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredSubLayerCount)); + wrapper->preferredConstantQp = DecodeAllocator::Allocate(); + wrapper->preferredConstantQp->decoded_value = &(value->preferredConstantQp); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->preferredConstantQp); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredMaxL0ReferenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredMaxL1ReferenceCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportSemaphoreWin32HandleInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportSemaphoreWin32HandleInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH265SessionParametersAddInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); - value->semaphore = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->handle)); - value->handle = nullptr; - bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->name = wrapper->name.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdVPSCount)); + wrapper->pStdVPSs = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdVPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdVPSs = wrapper->pStdVPSs->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSCount)); + wrapper->pStdSPSs = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdSPSs = wrapper->pStdSPSs->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSCount)); + wrapper->pStdPPSs = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportSemaphoreWin32HandleInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportSemaphoreWin32HandleInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH265SessionParametersCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pAttributes = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pAttributes->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAttributes = wrapper->pAttributes->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dwAccess)); - bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->name = wrapper->name.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdVPSCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdSPSCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdPPSCount)); + wrapper->pParametersAddInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pParametersAddInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkD3D12FenceSubmitInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkD3D12FenceSubmitInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH265SessionParametersGetInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->waitSemaphoreValuesCount)); - bytes_read += wrapper->pWaitSemaphoreValues.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - value->pWaitSemaphoreValues = wrapper->pWaitSemaphoreValues.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreValuesCount)); - bytes_read += wrapper->pSignalSemaphoreValues.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSignalSemaphoreValues = wrapper->pSignalSemaphoreValues.GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdVPS)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdSPS)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdPPS)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdVPSId)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSId)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSId)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetWin32HandleInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSemaphoreGetWin32HandleInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH265SessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); - value->semaphore = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdVPSOverrides)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdSPSOverrides)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportSemaphoreFdInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportSemaphoreFdInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH265NaluSliceSegmentInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->constantQp)); + wrapper->pStdSliceSegmentHeader = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSliceSegmentHeader->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdSliceSegmentHeader = wrapper->pStdSliceSegmentHeader->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265PictureInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265PictureInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->naluSliceSegmentEntryCount)); + wrapper->pNaluSliceSegmentEntries = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pNaluSliceSegmentEntries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pNaluSliceSegmentEntries = wrapper->pNaluSliceSegmentEntries->GetPointer(); + wrapper->pStdPictureInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPictureInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265DpbSlotInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265DpbSlotInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdReferenceInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdReferenceInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265ProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265ProfileInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdProfileIdc)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265RateControlInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); - value->semaphore = VK_NULL_HANDLE; bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopFrameCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->idrPeriod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->consecutiveBFrameCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subLayerCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetFdInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265FrameSizeKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSemaphoreGetFdInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeH265FrameSizeKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameISize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->framePSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameBSize)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlLayerInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265RateControlLayerInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); - value->semaphore = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMinQp)); + wrapper->minQp = DecodeAllocator::Allocate(); + wrapper->minQp->decoded_value = &(value->minQp); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minQp); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxQp)); + wrapper->maxQp = DecodeAllocator::Allocate(); + wrapper->maxQp->decoded_value = &(value->maxQp); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxQp); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxFrameSize)); + wrapper->maxFrameSize = DecodeAllocator::Allocate(); + wrapper->maxFrameSize->decoded_value = &(value->maxFrameSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFrameSize); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePushDescriptorPropertiesKHR* value = wrapper->decoded_value; + VkVideoEncodeH265GopRemainingFrameInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPushDescriptors)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingI)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingP)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingB)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRectLayerKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264ProfileInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRectLayerKHR* value = wrapper->decoded_value; + VkVideoDecodeH264ProfileInfoKHR* value = wrapper->decoded_value; - wrapper->offset = DecodeAllocator::Allocate(); - wrapper->offset->decoded_value = &(value->offset); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->offset); - wrapper->extent = DecodeAllocator::Allocate(); - wrapper->extent->decoded_value = &(value->extent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layer)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdProfileIdc)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pictureLayout)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentRegionKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264CapabilitiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentRegionKHR* value = wrapper->decoded_value; + VkVideoDecodeH264CapabilitiesKHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rectangleCount)); - wrapper->pRectangles = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRectangles->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRectangles = wrapper->pRectangles->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); + wrapper->fieldOffsetGranularity = DecodeAllocator::Allocate(); + wrapper->fieldOffsetGranularity->decoded_value = &(value->fieldOffsetGranularity); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fieldOffsetGranularity); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentRegionsKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentRegionsKHR* value = wrapper->decoded_value; + VkVideoDecodeH264SessionParametersAddInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); - wrapper->pRegions = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRegions = wrapper->pRegions->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSCount)); + wrapper->pStdSPSs = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdSPSs = wrapper->pStdSPSs->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSCount)); + wrapper->pStdPPSs = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSharedPresentSurfaceCapabilitiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264SessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH264SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdSPSCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdPPSCount)); + wrapper->pParametersAddInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pParametersAddInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264PictureInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH264PictureInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdPictureInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPictureInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sliceCount)); + bytes_read += wrapper->pSliceOffsets.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSliceOffsets = wrapper->pSliceOffsets.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264DpbSlotInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH264DpbSlotInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdReferenceInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdReferenceInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingFragmentShadingRateAttachmentInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingFragmentShadingRateAttachmentInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->imageView)); + value->imageView = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageLayout)); + wrapper->shadingRateAttachmentTexelSize = DecodeAllocator::Allocate(); + wrapper->shadingRateAttachmentTexelSize->decoded_value = &(value->shadingRateAttachmentTexelSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->shadingRateAttachmentTexelSize); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingFragmentDensityMapAttachmentInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingFragmentDensityMapAttachmentInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->imageView)); + value->imageView = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageLayout)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentSampleCountInfoAMD* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentSampleCountInfoAMD* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentCount)); + bytes_read += wrapper->pColorAttachmentSamples.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachmentSamples = wrapper->pColorAttachmentSamples.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilAttachmentSamples)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiviewPerViewAttributesInfoNVX* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSharedPresentSurfaceCapabilitiesKHR* value = wrapper->decoded_value; + VkMultiviewPerViewAttributesInfoNVX* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sharedPresentSupportedUsageFlags)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewAttributes)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewAttributesPositionXOnly)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportFenceWin32HandleInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryWin32HandleInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportFenceWin32HandleInfoKHR* value = wrapper->decoded_value; + VkImportMemoryWin32HandleInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); - value->fence = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->handle)); value->handle = nullptr; @@ -8669,12 +8948,12 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportF return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportFenceWin32HandleInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportFenceWin32HandleInfoKHR* value = wrapper->decoded_value; + VkExportMemoryWin32HandleInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); @@ -8689,2349 +8968,2280 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportF return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFenceGetWin32HandleInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryWin32HandlePropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFenceGetWin32HandleInfoKHR* value = wrapper->decoded_value; + VkMemoryWin32HandlePropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); - value->fence = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryTypeBits)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportFenceFdInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetWin32HandleInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportFenceFdInfoKHR* value = wrapper->decoded_value; + VkMemoryGetWin32HandleInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); - value->fence = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fd)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFenceGetFdInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryFdInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFenceGetFdInfoKHR* value = wrapper->decoded_value; + VkImportMemoryFdInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); - value->fence = VK_NULL_HANDLE; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fd)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryFdPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePerformanceQueryFeaturesKHR* value = wrapper->decoded_value; + VkMemoryFdPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceCounterQueryPools)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceCounterMultipleQueryPools)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryTypeBits)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetFdInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePerformanceQueryPropertiesKHR* value = wrapper->decoded_value; + VkMemoryGetFdInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->allowCommandBufferQueryCopies)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceCounterKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceCounterKHR* value = wrapper->decoded_value; + VkWin32KeyedMutexAcquireReleaseInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->unit)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scope)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storage)); - wrapper->uuid.SetExternalMemory(value->uuid, VK_UUID_SIZE); - bytes_read += wrapper->uuid.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->acquireCount)); + bytes_read += wrapper->pAcquireSyncs.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAcquireSyncs = nullptr; + bytes_read += wrapper->pAcquireKeys.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAcquireKeys = wrapper->pAcquireKeys.GetPointer(); + bytes_read += wrapper->pAcquireTimeouts.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAcquireTimeouts = wrapper->pAcquireTimeouts.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->releaseCount)); + bytes_read += wrapper->pReleaseSyncs.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pReleaseSyncs = nullptr; + bytes_read += wrapper->pReleaseKeys.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pReleaseKeys = wrapper->pReleaseKeys.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceCounterDescriptionKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportSemaphoreWin32HandleInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceCounterDescriptionKHR* value = wrapper->decoded_value; + VkImportSemaphoreWin32HandleInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); + value->semaphore = VK_NULL_HANDLE; bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - wrapper->name.SetExternalMemory(value->name, VK_MAX_DESCRIPTION_SIZE); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->handle)); + value->handle = nullptr; bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->category.SetExternalMemory(value->category, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->category.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - - return bytes_read; -} - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolPerformanceCreateInfoKHR* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkQueryPoolPerformanceCreateInfoKHR* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndex)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->counterIndexCount)); - bytes_read += wrapper->pCounterIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCounterIndices = wrapper->pCounterIndices.GetPointer(); - - return bytes_read; -} - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcquireProfilingLockInfoKHR* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkAcquireProfilingLockInfoKHR* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeout)); + value->name = wrapper->name.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceQuerySubmitInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportSemaphoreWin32HandleInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceQuerySubmitInfoKHR* value = wrapper->decoded_value; + VkExportSemaphoreWin32HandleInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->counterPassIndex)); + wrapper->pAttributes = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttributes->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttributes = wrapper->pAttributes->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dwAccess)); + bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->name = wrapper->name.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSurfaceInfo2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkD3D12FenceSubmitInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSurfaceInfo2KHR* value = wrapper->decoded_value; + VkD3D12FenceSubmitInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->surface)); - value->surface = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->waitSemaphoreValuesCount)); + bytes_read += wrapper->pWaitSemaphoreValues.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphoreValues = wrapper->pWaitSemaphoreValues.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreValuesCount)); + bytes_read += wrapper->pSignalSemaphoreValues.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSignalSemaphoreValues = wrapper->pSignalSemaphoreValues.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilities2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetWin32HandleInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceCapabilities2KHR* value = wrapper->decoded_value; + VkSemaphoreGetWin32HandleInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->surfaceCapabilities = DecodeAllocator::Allocate(); - wrapper->surfaceCapabilities->decoded_value = &(value->surfaceCapabilities); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->surfaceCapabilities); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); + value->semaphore = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFormat2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportSemaphoreFdInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceFormat2KHR* value = wrapper->decoded_value; + VkImportSemaphoreFdInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->surfaceFormat = DecodeAllocator::Allocate(); - wrapper->surfaceFormat->decoded_value = &(value->surfaceFormat); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->surfaceFormat); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); + value->semaphore = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fd)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayProperties2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetFdInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayProperties2KHR* value = wrapper->decoded_value; + VkSemaphoreGetFdInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->displayProperties = DecodeAllocator::Allocate(); - wrapper->displayProperties->decoded_value = &(value->displayProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayProperties); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); + value->semaphore = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneProperties2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPlaneProperties2KHR* value = wrapper->decoded_value; + VkPhysicalDevicePushDescriptorPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->displayPlaneProperties = DecodeAllocator::Allocate(); - wrapper->displayPlaneProperties->decoded_value = &(value->displayPlaneProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPlaneProperties); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPushDescriptors)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModeProperties2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRectLayerKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayModeProperties2KHR* value = wrapper->decoded_value; + VkRectLayerKHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->displayModeProperties = DecodeAllocator::Allocate(); - wrapper->displayModeProperties->decoded_value = &(value->displayModeProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayModeProperties); + wrapper->offset = DecodeAllocator::Allocate(); + wrapper->offset->decoded_value = &(value->offset); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->offset); + wrapper->extent = DecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layer)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneInfo2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentRegionKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPlaneInfo2KHR* value = wrapper->decoded_value; + VkPresentRegionKHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->mode)); - value->mode = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->planeIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rectangleCount)); + wrapper->pRectangles = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pRectangles->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRectangles = wrapper->pRectangles->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneCapabilities2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentRegionsKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPlaneCapabilities2KHR* value = wrapper->decoded_value; + VkPresentRegionsKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->capabilities = DecodeAllocator::Allocate(); - wrapper->capabilities->decoded_value = &(value->capabilities); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->capabilities); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); + wrapper->pRegions = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRegions = wrapper->pRegions->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSharedPresentSurfaceCapabilitiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePortabilitySubsetFeaturesKHR* value = wrapper->decoded_value; + VkSharedPresentSurfaceCapabilitiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->constantAlphaColorBlendFactors)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->events)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatReinterpretation)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatSwizzle)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageView2DOn3DImage)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multisampleArrayImage)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mutableComparisonSamplers)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pointPolygons)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerMipLodBias)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateStencilMaskRef)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampleRateInterpolationFunctions)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationIsolines)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationPointMode)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triangleFans)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeAccessBeyondStride)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sharedPresentSupportedUsageFlags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportFenceWin32HandleInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePortabilitySubsetPropertiesKHR* value = wrapper->decoded_value; + VkImportFenceWin32HandleInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minVertexInputBindingStrideAlignment)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); + value->fence = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->handle)); + value->handle = nullptr; + bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->name = wrapper->name.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderClockFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportFenceWin32HandleInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderClockFeaturesKHR* value = wrapper->decoded_value; + VkExportFenceWin32HandleInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupClock)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDeviceClock)); + wrapper->pAttributes = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttributes->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttributes = wrapper->pAttributes->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dwAccess)); + bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->name = wrapper->name.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265ProfileInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFenceGetWin32HandleInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265ProfileInfoKHR* value = wrapper->decoded_value; + VkFenceGetWin32HandleInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdProfileIdc)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); + value->fence = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265CapabilitiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportFenceFdInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265CapabilitiesKHR* value = wrapper->decoded_value; + VkImportFenceFdInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); + value->fence = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fd)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265SessionParametersAddInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFenceGetFdInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265SessionParametersAddInfoKHR* value = wrapper->decoded_value; + VkFenceGetFdInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdVPSCount)); - wrapper->pStdVPSs = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdVPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdVPSs = wrapper->pStdVPSs->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSCount)); - wrapper->pStdSPSs = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdSPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdSPSs = wrapper->pStdSPSs->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSCount)); - wrapper->pStdPPSs = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdPPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); + value->fence = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265SessionParametersCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDevicePerformanceQueryFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdVPSCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdSPSCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdPPSCount)); - wrapper->pParametersAddInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pParametersAddInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceCounterQueryPools)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceCounterMultipleQueryPools)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265PictureInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265PictureInfoKHR* value = wrapper->decoded_value; + VkPhysicalDevicePerformanceQueryPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pStdPictureInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdPictureInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sliceSegmentCount)); - bytes_read += wrapper->pSliceSegmentOffsets.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSliceSegmentOffsets = wrapper->pSliceSegmentOffsets.GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->allowCommandBufferQueryCopies)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265DpbSlotInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceCounterKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265DpbSlotInfoKHR* value = wrapper->decoded_value; + VkPerformanceCounterKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pStdReferenceInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdReferenceInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->unit)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scope)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storage)); + wrapper->uuid.SetExternalMemory(value->uuid, VK_UUID_SIZE); + bytes_read += wrapper->uuid.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceCounterDescriptionKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceQueueGlobalPriorityCreateInfoKHR* value = wrapper->decoded_value; + VkPerformanceCounterDescriptionKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalPriority)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + wrapper->name.SetExternalMemory(value->name, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->category.SetExternalMemory(value->category, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->category.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolPerformanceCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* value = wrapper->decoded_value; + VkQueryPoolPerformanceCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalPriorityQuery)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->counterIndexCount)); + bytes_read += wrapper->pCounterIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCounterIndices = wrapper->pCounterIndices.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcquireProfilingLockInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueueFamilyGlobalPriorityPropertiesKHR* value = wrapper->decoded_value; + VkAcquireProfilingLockInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->priorityCount)); - wrapper->priorities.SetExternalMemory(value->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR); - bytes_read += wrapper->priorities.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeout)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFragmentShadingRateAttachmentInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceQuerySubmitInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFragmentShadingRateAttachmentInfoKHR* value = wrapper->decoded_value; + VkPerformanceQuerySubmitInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pFragmentShadingRateAttachment = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pFragmentShadingRateAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pFragmentShadingRateAttachment = wrapper->pFragmentShadingRateAttachment->GetPointer(); - wrapper->shadingRateAttachmentTexelSize = DecodeAllocator::Allocate(); - wrapper->shadingRateAttachmentTexelSize->decoded_value = &(value->shadingRateAttachmentTexelSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->shadingRateAttachmentTexelSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->counterPassIndex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineFragmentShadingRateStateCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSurfaceInfo2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineFragmentShadingRateStateCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceSurfaceInfo2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->fragmentSize = DecodeAllocator::Allocate(); - wrapper->fragmentSize->decoded_value = &(value->fragmentSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentSize); - wrapper->combinerOps.SetExternalMemory(value->combinerOps, 2); - bytes_read += wrapper->combinerOps.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->surface)); + value->surface = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilities2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShadingRateFeaturesKHR* value = wrapper->decoded_value; + VkSurfaceCapabilities2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineFragmentShadingRate)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRate)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentFragmentShadingRate)); + wrapper->surfaceCapabilities = DecodeAllocator::Allocate(); + wrapper->surfaceCapabilities->decoded_value = &(value->surfaceCapabilities); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->surfaceCapabilities); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFormat2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShadingRatePropertiesKHR* value = wrapper->decoded_value; + VkSurfaceFormat2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->minFragmentShadingRateAttachmentTexelSize = DecodeAllocator::Allocate(); - wrapper->minFragmentShadingRateAttachmentTexelSize->decoded_value = &(value->minFragmentShadingRateAttachmentTexelSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minFragmentShadingRateAttachmentTexelSize); - wrapper->maxFragmentShadingRateAttachmentTexelSize = DecodeAllocator::Allocate(); - wrapper->maxFragmentShadingRateAttachmentTexelSize->decoded_value = &(value->maxFragmentShadingRateAttachmentTexelSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFragmentShadingRateAttachmentTexelSize); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentShadingRateAttachmentTexelSizeAspectRatio)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRateWithMultipleViewports)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layeredShadingRateAttachments)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateNonTrivialCombinerOps)); - wrapper->maxFragmentSize = DecodeAllocator::Allocate(); - wrapper->maxFragmentSize->decoded_value = &(value->maxFragmentSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFragmentSize); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentSizeAspectRatio)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentShadingRateCoverageSamples)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentShadingRateRasterizationSamples)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderDepthStencilWrites)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithSampleMask)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderSampleMask)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithConservativeRasterization)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithFragmentShaderInterlock)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithCustomSampleLocations)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateStrictMultiplyCombiner)); + wrapper->surfaceFormat = DecodeAllocator::Allocate(); + wrapper->surfaceFormat->decoded_value = &(value->surfaceFormat); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->surfaceFormat); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayProperties2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShadingRateKHR* value = wrapper->decoded_value; + VkDisplayProperties2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleCounts)); - wrapper->fragmentSize = DecodeAllocator::Allocate(); - wrapper->fragmentSize->decoded_value = &(value->fragmentSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentSize); + wrapper->displayProperties = DecodeAllocator::Allocate(); + wrapper->displayProperties->decoded_value = &(value->displayProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayProperties); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceProtectedCapabilitiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneProperties2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceProtectedCapabilitiesKHR* value = wrapper->decoded_value; + VkDisplayPlaneProperties2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportsProtected)); + wrapper->displayPlaneProperties = DecodeAllocator::Allocate(); + wrapper->displayPlaneProperties->decoded_value = &(value->displayPlaneProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPlaneProperties); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentWaitFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModeProperties2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePresentWaitFeaturesKHR* value = wrapper->decoded_value; + VkDisplayModeProperties2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentWait)); + wrapper->displayModeProperties = DecodeAllocator::Allocate(); + wrapper->displayModeProperties->decoded_value = &(value->displayModeProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayModeProperties); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneInfo2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* value = wrapper->decoded_value; + VkDisplayPlaneInfo2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineExecutableInfo)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->mode)); + value->mode = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->planeIndex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneCapabilities2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineInfoKHR* value = wrapper->decoded_value; + VkDisplayPlaneCapabilities2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); - value->pipeline = VK_NULL_HANDLE; + wrapper->capabilities = DecodeAllocator::Allocate(); + wrapper->capabilities->decoded_value = &(value->capabilities); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->capabilities); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutablePropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineExecutablePropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDevicePortabilitySubsetFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stages)); - wrapper->name.SetExternalMemory(value->name, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSize)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->constantAlphaColorBlendFactors)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->events)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatReinterpretation)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatSwizzle)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageView2DOn3DImage)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multisampleArrayImage)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mutableComparisonSamplers)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pointPolygons)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerMipLodBias)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateStencilMaskRef)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampleRateInterpolationFunctions)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationIsolines)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationPointMode)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triangleFans)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeAccessBeyondStride)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineExecutableInfoKHR* value = wrapper->decoded_value; + VkPhysicalDevicePortabilitySubsetPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); - value->pipeline = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->executableIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minVertexInputBindingStrideAlignment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableStatisticKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderClockFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineExecutableStatisticKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderClockFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->name.SetExternalMemory(value->name, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); - wrapper->value = DecodeAllocator::Allocate(); - wrapper->value->decoded_value = &(value->value); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->value); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupClock)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDeviceClock)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableInternalRepresentationKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265ProfileInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineExecutableInternalRepresentationKHR* value = wrapper->decoded_value; + VkVideoDecodeH265ProfileInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->name.SetExternalMemory(value->name, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->isText)); - bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dataSize)); - bytes_read += wrapper->pData.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); - value->pData = wrapper->pData.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdProfileIdc)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryMapInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265CapabilitiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryMapInfoKHR* value = wrapper->decoded_value; + VkVideoDecodeH265CapabilitiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); - value->memory = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryUnmapInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265SessionParametersAddInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryUnmapInfoKHR* value = wrapper->decoded_value; + VkVideoDecodeH265SessionParametersAddInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); - value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdVPSCount)); + wrapper->pStdVPSs = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdVPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdVPSs = wrapper->pStdVPSs->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSCount)); + wrapper->pStdSPSs = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdSPSs = wrapper->pStdSPSs->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSCount)); + wrapper->pStdPPSs = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineLibraryCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265SessionParametersCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineLibraryCreateInfoKHR* value = wrapper->decoded_value; + VkVideoDecodeH265SessionParametersCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->libraryCount)); - bytes_read += wrapper->pLibraries.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pLibraries = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdVPSCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdSPSCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdPPSCount)); + wrapper->pParametersAddInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pParametersAddInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentIdKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265PictureInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentIdKHR* value = wrapper->decoded_value; + VkVideoDecodeH265PictureInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); - bytes_read += wrapper->pPresentIds.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPresentIds = wrapper->pPresentIds.GetPointer(); + wrapper->pStdPictureInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPictureInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sliceSegmentCount)); + bytes_read += wrapper->pSliceSegmentOffsets.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSliceSegmentOffsets = wrapper->pSliceSegmentOffsets.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentIdFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265DpbSlotInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePresentIdFeaturesKHR* value = wrapper->decoded_value; + VkVideoDecodeH265DpbSlotInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentId)); + wrapper->pStdReferenceInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdReferenceInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeInfoKHR* value = wrapper->decoded_value; + VkDeviceQueueGlobalPriorityCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstBuffer)); - value->dstBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBufferOffset)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBufferRange)); - wrapper->srcPictureResource = DecodeAllocator::Allocate(); - wrapper->srcPictureResource->decoded_value = &(value->srcPictureResource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcPictureResource); - wrapper->pSetupReferenceSlot = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSetupReferenceSlot->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSetupReferenceSlot = wrapper->pSetupReferenceSlot->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->referenceSlotCount)); - wrapper->pReferenceSlots = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pReferenceSlots->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pReferenceSlots = wrapper->pReferenceSlots->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->precedingExternallyEncodedBytes)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalPriority)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeCapabilitiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeCapabilitiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rateControlModes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRateControlLayers)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBitrate)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxQualityLevels)); - wrapper->encodeInputPictureGranularity = DecodeAllocator::Allocate(); - wrapper->encodeInputPictureGranularity->decoded_value = &(value->encodeInputPictureGranularity); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->encodeInputPictureGranularity); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedEncodeFeedbackFlags)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalPriorityQuery)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* value = wrapper->decoded_value; + VkQueueFamilyGlobalPriorityPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->encodeFeedbackFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->priorityCount)); + wrapper->priorities.SetExternalMemory(value->priorities, VK_MAX_GLOBAL_PRIORITY_SIZE_KHR); + bytes_read += wrapper->priorities.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeUsageInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFragmentShadingRateAttachmentInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeUsageInfoKHR* value = wrapper->decoded_value; + VkFragmentShadingRateAttachmentInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->videoUsageHints)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->videoContentHints)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tuningMode)); + wrapper->pFragmentShadingRateAttachment = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pFragmentShadingRateAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pFragmentShadingRateAttachment = wrapper->pFragmentShadingRateAttachment->GetPointer(); + wrapper->shadingRateAttachmentTexelSize = DecodeAllocator::Allocate(); + wrapper->shadingRateAttachmentTexelSize->decoded_value = &(value->shadingRateAttachmentTexelSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->shadingRateAttachmentTexelSize); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeRateControlLayerInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineFragmentShadingRateStateCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeRateControlLayerInfoKHR* value = wrapper->decoded_value; + VkPipelineFragmentShadingRateStateCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->averageBitrate)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBitrate)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameRateNumerator)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameRateDenominator)); + wrapper->fragmentSize = DecodeAllocator::Allocate(); + wrapper->fragmentSize->decoded_value = &(value->fragmentSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentSize); + wrapper->combinerOps.SetExternalMemory(value->combinerOps, 2); + bytes_read += wrapper->combinerOps.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeRateControlInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeRateControlInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShadingRateFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rateControlMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layerCount)); - wrapper->pLayers = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pLayers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pLayers = wrapper->pLayers->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->virtualBufferSizeInMs)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialVirtualBufferSizeInMs)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineFragmentShadingRate)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRate)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentFragmentShadingRate)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShadingRatePropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pVideoProfile = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pVideoProfile->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pVideoProfile = wrapper->pVideoProfile->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qualityLevel)); + wrapper->minFragmentShadingRateAttachmentTexelSize = DecodeAllocator::Allocate(); + wrapper->minFragmentShadingRateAttachmentTexelSize->decoded_value = &(value->minFragmentShadingRateAttachmentTexelSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minFragmentShadingRateAttachmentTexelSize); + wrapper->maxFragmentShadingRateAttachmentTexelSize = DecodeAllocator::Allocate(); + wrapper->maxFragmentShadingRateAttachmentTexelSize->decoded_value = &(value->maxFragmentShadingRateAttachmentTexelSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFragmentShadingRateAttachmentTexelSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentShadingRateAttachmentTexelSizeAspectRatio)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRateWithMultipleViewports)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layeredShadingRateAttachments)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateNonTrivialCombinerOps)); + wrapper->maxFragmentSize = DecodeAllocator::Allocate(); + wrapper->maxFragmentSize->decoded_value = &(value->maxFragmentSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFragmentSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentSizeAspectRatio)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentShadingRateCoverageSamples)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentShadingRateRasterizationSamples)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderDepthStencilWrites)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithSampleMask)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderSampleMask)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithConservativeRasterization)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithFragmentShaderInterlock)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithCustomSampleLocations)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateStrictMultiplyCombiner)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeQualityLevelPropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShadingRateKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredRateControlMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredRateControlLayerCount)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleCounts)); + wrapper->fragmentSize = DecodeAllocator::Allocate(); + wrapper->fragmentSize->decoded_value = &(value->fragmentSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentSize); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceProtectedCapabilitiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeQualityLevelInfoKHR* value = wrapper->decoded_value; + VkSurfaceProtectedCapabilitiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qualityLevel)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportsProtected)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersGetInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentWaitFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeSessionParametersGetInfoKHR* value = wrapper->decoded_value; + VkPhysicalDevicePresentWaitFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->videoSessionParameters)); - value->videoSessionParameters = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentWait)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersFeedbackInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeSessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasOverrides)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineExecutableInfo)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointProperties2NV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueueFamilyCheckpointProperties2NV* value = wrapper->decoded_value; + VkPipelineInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->checkpointExecutionStageMask)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); + value->pipeline = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCheckpointData2NV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutablePropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCheckpointData2NV* value = wrapper->decoded_value; + VkPipelineExecutablePropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stage)); - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pCheckpointMarker)); - value->pCheckpointMarker = nullptr; + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stages)); + wrapper->name.SetExternalMemory(value->name, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSize)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* value = wrapper->decoded_value; + VkPipelineExecutableInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderBarycentric)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); + value->pipeline = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->executableIndex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableStatisticKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* value = wrapper->decoded_value; + VkPipelineExecutableStatisticKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triStripVertexOrderIndependentOfProvokingVertex)); + wrapper->name.SetExternalMemory(value->name, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + wrapper->value = DecodeAllocator::Allocate(); + wrapper->value->decoded_value = &(value->value); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->value); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableInternalRepresentationKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* value = wrapper->decoded_value; + VkPipelineExecutableInternalRepresentationKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupUniformControlFlow)); + wrapper->name.SetExternalMemory(value->name, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->isText)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dataSize)); + bytes_read += wrapper->pData.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pData = wrapper->pData.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryMapInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* value = wrapper->decoded_value; + VkMemoryMapInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayoutScalarBlockLayout)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout8BitAccess)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout16BitAccess)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryUnmapInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* value = wrapper->decoded_value; + VkMemoryUnmapInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingMaintenance1)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPipelineTraceRaysIndirect2)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTraceRaysIndirectCommand2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineLibraryCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkTraceRaysIndirectCommand2KHR* value = wrapper->decoded_value; + VkPipelineLibraryCreateInfoKHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordAddress)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordSize)); - bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableAddress)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableSize)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableStride)); - bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableAddress)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableSize)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableStride)); - bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableAddress)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableSize)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableStride)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->width)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->height)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depth)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->libraryCount)); + bytes_read += wrapper->pLibraries.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLibraries = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentIdKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance5FeaturesKHR* value = wrapper->decoded_value; + VkPresentIdKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maintenance5)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); + bytes_read += wrapper->pPresentIds.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentIds = wrapper->pPresentIds.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentIdFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance5PropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDevicePresentIdFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentMultisampleCoverageAfterSampleCounting)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentSampleMaskTestBeforeSampleCounting)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilSwizzleOneSupport)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->polygonModePointSize)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictSinglePixelWideLinesUseParallelogram)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictWideLinesUseParallelogram)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentId)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingAreaInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingAreaInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentCount)); - bytes_read += wrapper->pColorAttachmentFormats.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pColorAttachmentFormats = wrapper->pColorAttachmentFormats.GetPointer(); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthAttachmentFormat)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilAttachmentFormat)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstBuffer)); + value->dstBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBufferOffset)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBufferRange)); + wrapper->srcPictureResource = DecodeAllocator::Allocate(); + wrapper->srcPictureResource->decoded_value = &(value->srcPictureResource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcPictureResource); + wrapper->pSetupReferenceSlot = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSetupReferenceSlot->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSetupReferenceSlot = wrapper->pSetupReferenceSlot->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->referenceSlotCount)); + wrapper->pReferenceSlots = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pReferenceSlots->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pReferenceSlots = wrapper->pReferenceSlots->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->precedingExternallyEncodedBytes)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSubresource2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeCapabilitiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageSubresource2KHR* value = wrapper->decoded_value; + VkVideoEncodeCapabilitiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->imageSubresource = DecodeAllocator::Allocate(); - wrapper->imageSubresource->decoded_value = &(value->imageSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rateControlModes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRateControlLayers)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBitrate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxQualityLevels)); + wrapper->encodeInputPictureGranularity = DecodeAllocator::Allocate(); + wrapper->encodeInputPictureGranularity->decoded_value = &(value->encodeInputPictureGranularity); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->encodeInputPictureGranularity); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedEncodeFeedbackFlags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceImageSubresourceInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceImageSubresourceInfoKHR* value = wrapper->decoded_value; + VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pCreateInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pCreateInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCreateInfo = wrapper->pCreateInfo->GetPointer(); - wrapper->pSubresource = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSubresource->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSubresource = wrapper->pSubresource->GetPointer(); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->encodeFeedbackFlags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubresourceLayout2KHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeUsageInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubresourceLayout2KHR* value = wrapper->decoded_value; + VkVideoEncodeUsageInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->subresourceLayout = DecodeAllocator::Allocate(); - wrapper->subresourceLayout->decoded_value = &(value->subresourceLayout); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceLayout); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->videoUsageHints)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->videoContentHints)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tuningMode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCreateFlags2CreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeRateControlLayerInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineCreateFlags2CreateInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeRateControlLayerInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->averageBitrate)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBitrate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameRateNumerator)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameRateDenominator)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferUsageFlags2CreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeRateControlInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBufferUsageFlags2CreateInfoKHR* value = wrapper->decoded_value; + VkVideoEncodeRateControlInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rateControlMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layerCount)); + wrapper->pLayers = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pLayers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLayers = wrapper->pLayers->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->virtualBufferSizeInMs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialVirtualBufferSizeInMs)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPositionFetch)); + wrapper->pVideoProfile = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pVideoProfile->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVideoProfile = wrapper->pVideoProfile->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qualityLevel)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCooperativeMatrixPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCooperativeMatrixPropertiesKHR* value = wrapper->decoded_value; + VkVideoEncodeQualityLevelPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->MSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->NSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->KSize)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->AType)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->BType)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->CType)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ResultType)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->saturatingAccumulation)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scope)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredRateControlMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredRateControlLayerCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCooperativeMatrixFeaturesKHR* value = wrapper->decoded_value; + VkVideoEncodeQualityLevelInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrix)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixRobustBufferAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qualityLevel)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersGetInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCooperativeMatrixPropertiesKHR* value = wrapper->decoded_value; + VkVideoEncodeSessionParametersGetInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixSupportedStages)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->videoSessionParameters)); + value->videoSessionParameters = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersFeedbackInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* value = wrapper->decoded_value; + VkVideoEncodeSessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexAttribDivisor)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportsNonZeroFirstInstance)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasOverrides)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDivisorDescriptionKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointProperties2NV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVertexInputBindingDivisorDescriptionKHR* value = wrapper->decoded_value; + VkQueueFamilyCheckpointProperties2NV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->divisor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->checkpointExecutionStageMask)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCheckpointData2NV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineVertexInputDivisorStateCreateInfoKHR* value = wrapper->decoded_value; + VkCheckpointData2NV* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexBindingDivisorCount)); - wrapper->pVertexBindingDivisors = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pVertexBindingDivisors->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pVertexBindingDivisors = wrapper->pVertexBindingDivisors->GetPointer(); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stage)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pCheckpointMarker)); + value->pCheckpointMarker = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateDivisor)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateZeroDivisor)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderBarycentric)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCalibratedTimestampInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeDomain)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triStripVertexOrderIndependentOfProvokingVertex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugReportCallbackCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugReportCallbackCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnCallback)); - value->pfnCallback = nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pUserData)); - value->pUserData = nullptr; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupUniformControlFlow)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateRasterizationOrderAMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRasterizationStateRasterizationOrderAMD* value = wrapper->decoded_value; + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrder)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayoutScalarBlockLayout)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout8BitAccess)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout16BitAccess)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugMarkerObjectNameInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectType)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->object)); - value->object = 0; - bytes_read += wrapper->pObjectName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pObjectName = wrapper->pObjectName.GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingMaintenance1)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPipelineTraceRaysIndirect2)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectTagInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTraceRaysIndirectCommand2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugMarkerObjectTagInfoEXT* value = wrapper->decoded_value; + VkTraceRaysIndirectCommand2KHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectType)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->object)); - value->object = 0; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tagName)); - bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tagSize)); - bytes_read += wrapper->pTag.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); - value->pTag = wrapper->pTag.GetPointer(); + bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordAddress)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordSize)); + bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableAddress)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableSize)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableStride)); + bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableAddress)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableSize)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableStride)); + bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableAddress)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableSize)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->width)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->height)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depth)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerMarkerInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugMarkerMarkerInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceMaintenance5FeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += wrapper->pMarkerName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pMarkerName = wrapper->pMarkerName.GetPointer(); - wrapper->color.SetExternalMemory(value->color, 4); - bytes_read += wrapper->color.DecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maintenance5)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationImageCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDedicatedAllocationImageCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceMaintenance5PropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dedicatedAllocation)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentMultisampleCoverageAfterSampleCounting)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentSampleMaskTestBeforeSampleCounting)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilSwizzleOneSupport)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->polygonModePointSize)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictSinglePixelWideLinesUseParallelogram)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictWideLinesUseParallelogram)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationBufferCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingAreaInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDedicatedAllocationBufferCreateInfoNV* value = wrapper->decoded_value; + VkRenderingAreaInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dedicatedAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentCount)); + bytes_read += wrapper->pColorAttachmentFormats.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachmentFormats = wrapper->pColorAttachmentFormats.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthAttachmentFormat)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilAttachmentFormat)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationMemoryAllocateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSubresource2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDedicatedAllocationMemoryAllocateInfoNV* value = wrapper->decoded_value; + VkImageSubresource2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); - value->image = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); - value->buffer = VK_NULL_HANDLE; + wrapper->imageSubresource = DecodeAllocator::Allocate(); + wrapper->imageSubresource->decoded_value = &(value->imageSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceImageSubresourceInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTransformFeedbackFeaturesEXT* value = wrapper->decoded_value; + VkDeviceImageSubresourceInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedback)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryStreams)); + wrapper->pCreateInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pCreateInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCreateInfo = wrapper->pCreateInfo->GetPointer(); + wrapper->pSubresource = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSubresource->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSubresource = wrapper->pSubresource->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubresourceLayout2KHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTransformFeedbackPropertiesEXT* value = wrapper->decoded_value; + VkSubresourceLayout2KHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackStreams)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackBuffers)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackBufferSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackStreamDataSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackBufferDataSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackBufferDataStride)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackQueries)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackStreamsLinesTriangles)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackRasterizationStreamSelect)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackDraw)); + wrapper->subresourceLayout = DecodeAllocator::Allocate(); + wrapper->subresourceLayout->decoded_value = &(value->subresourceLayout); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceLayout); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCreateFlags2CreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRasterizationStateStreamCreateInfoEXT* value = wrapper->decoded_value; + VkPipelineCreateFlags2CreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationStream)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewHandleInfoNVX* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferUsageFlags2CreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageViewHandleInfoNVX* value = wrapper->decoded_value; + VkBufferUsageFlags2CreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->imageView)); - value->imageView = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorType)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->sampler)); - value->sampler = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewAddressPropertiesNVX* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageViewAddressPropertiesNVX* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); - bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPositionFetch)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264CapabilitiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCooperativeMatrixPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264CapabilitiesEXT* value = wrapper->decoded_value; + VkCooperativeMatrixPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSliceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPPictureL0ReferenceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBPictureL0ReferenceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxL1ReferenceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTemporalLayerCount)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->expectDyadicTemporalLayerPattern)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minQp)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxQp)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiresGopRemainingFrames)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSyntaxFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->MSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->NSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->KSize)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->AType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->BType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->CType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ResultType)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->saturatingAccumulation)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scope)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QpEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264QpEXT* value = wrapper->decoded_value; + VkPhysicalDeviceCooperativeMatrixFeaturesKHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpI)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpP)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpB)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrix)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixRobustBufferAccess)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QualityLevelPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264QualityLevelPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceCooperativeMatrixPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredRateControlFlags)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredGopFrameCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredIdrPeriod)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredConsecutiveBFrameCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredTemporalLayerCount)); - wrapper->preferredConstantQp = DecodeAllocator::Allocate(); - wrapper->preferredConstantQp->decoded_value = &(value->preferredConstantQp); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->preferredConstantQp); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredMaxL0ReferenceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredMaxL1ReferenceCount)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredStdEntropyCodingModeFlag)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixSupportedStages)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceVideoMaintenance1FeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxLevelIdc)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->videoMaintenance1)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersAddInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoInlineQueryInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionParametersAddInfoEXT* value = wrapper->decoded_value; + VkVideoInlineQueryInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSCount)); - wrapper->pStdSPSs = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdSPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdSPSs = wrapper->pStdSPSs->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSCount)); - wrapper->pStdPPSs = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdPPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->queryPool)); + value->queryPool = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstQuery)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queryCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionParametersCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdSPSCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdPPSCount)); - wrapper->pParametersAddInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pParametersAddInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexAttribDivisor)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportsNonZeroFirstInstance)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersGetInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDivisorDescriptionKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionParametersGetInfoEXT* value = wrapper->decoded_value; + VkVertexInputBindingDivisorDescriptionKHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdSPS)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdPPS)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSId)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSId)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->divisor)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionParametersFeedbackInfoEXT* value = wrapper->decoded_value; + VkPipelineVertexInputDivisorStateCreateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdSPSOverrides)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexBindingDivisorCount)); + wrapper->pVertexBindingDivisors = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pVertexBindingDivisors->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVertexBindingDivisors = wrapper->pVertexBindingDivisors->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264NaluSliceInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264NaluSliceInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->constantQp)); - wrapper->pStdSliceHeader = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdSliceHeader->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdSliceHeader = wrapper->pStdSliceHeader->GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateDivisor)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateZeroDivisor)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264PictureInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264PictureInfoEXT* value = wrapper->decoded_value; + VkCalibratedTimestampInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->naluSliceEntryCount)); - wrapper->pNaluSliceEntries = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pNaluSliceEntries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pNaluSliceEntries = wrapper->pNaluSliceEntries->GetPointer(); - wrapper->pStdPictureInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdPictureInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->generatePrefixNalu)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeDomain)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264DpbSlotInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264DpbSlotInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceMaintenance6FeaturesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pStdReferenceInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdReferenceInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maintenance6)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264ProfileInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264ProfileInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceMaintenance6PropertiesKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdProfileIdc)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->blockTexelViewCompatibleMultipleLayers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxCombinedImageSamplerDescriptorCount)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateClampCombinerInputs)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindMemoryStatusKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264RateControlInfoEXT* value = wrapper->decoded_value; + VkBindMemoryStatusKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopFrameCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->idrPeriod)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->consecutiveBFrameCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->temporalLayerCount)); + bytes_read += wrapper->pResult.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pResult = wrapper->pResult.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264FrameSizeEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindDescriptorSetsInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264FrameSizeEXT* value = wrapper->decoded_value; + VkBindDescriptorSetsInfoKHR* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameISize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->framePSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameBSize)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageFlags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstSet)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorSetCount)); + bytes_read += wrapper->pDescriptorSets.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDescriptorSets = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicOffsetCount)); + bytes_read += wrapper->pDynamicOffsets.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDynamicOffsets = wrapper->pDynamicOffsets.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlLayerInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushConstantsInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264RateControlLayerInfoEXT* value = wrapper->decoded_value; + VkPushConstantsInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMinQp)); - wrapper->minQp = DecodeAllocator::Allocate(); - wrapper->minQp->decoded_value = &(value->minQp); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minQp); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxQp)); - wrapper->maxQp = DecodeAllocator::Allocate(); - wrapper->maxQp->decoded_value = &(value->maxQp); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxQp); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxFrameSize)); - wrapper->maxFrameSize = DecodeAllocator::Allocate(); - wrapper->maxFrameSize->decoded_value = &(value->maxFrameSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFrameSize); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += wrapper->pValues.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pValues = wrapper->pValues.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264GopRemainingFrameInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushDescriptorSetInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264GopRemainingFrameInfoEXT* value = wrapper->decoded_value; + VkPushDescriptorSetInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useGopRemainingFrames)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingI)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingP)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingB)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageFlags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->set)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorWriteCount)); + wrapper->pDescriptorWrites = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDescriptorWrites->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDescriptorWrites = wrapper->pDescriptorWrites->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265CapabilitiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushDescriptorSetWithTemplateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265CapabilitiesEXT* value = wrapper->decoded_value; + VkPushDescriptorSetWithTemplateInfoKHR* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSliceSegmentCount)); - wrapper->maxTiles = DecodeAllocator::Allocate(); - wrapper->maxTiles->decoded_value = &(value->maxTiles); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxTiles); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ctbSizes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformBlockSizes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPPictureL0ReferenceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBPictureL0ReferenceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxL1ReferenceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubLayerCount)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->expectDyadicTemporalSubLayerPattern)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minQp)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxQp)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiresGopRemainingFrames)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSyntaxFlags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->descriptorUpdateTemplate)); + value->descriptorUpdateTemplate = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->set)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pData)); + value->pData = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSetDescriptorBufferOffsetsInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionCreateInfoEXT* value = wrapper->decoded_value; + VkSetDescriptorBufferOffsetsInfoEXT* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxLevelIdc)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageFlags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstSet)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->setCount)); + bytes_read += wrapper->pBufferIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBufferIndices = wrapper->pBufferIndices.GetPointer(); + bytes_read += wrapper->pOffsets.DecodeVkDeviceSize((buffer + bytes_read), (buffer_size - bytes_read)); + value->pOffsets = wrapper->pOffsets.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QpEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265QpEXT* value = wrapper->decoded_value; + VkBindDescriptorBufferEmbeddedSamplersInfoEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpI)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpP)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qpB)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageFlags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->set)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QualityLevelPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugReportCallbackCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265QualityLevelPropertiesEXT* value = wrapper->decoded_value; + VkDebugReportCallbackCreateInfoEXT* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredRateControlFlags)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredGopFrameCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredIdrPeriod)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredConsecutiveBFrameCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredSubLayerCount)); - wrapper->preferredConstantQp = DecodeAllocator::Allocate(); - wrapper->preferredConstantQp->decoded_value = &(value->preferredConstantQp); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->preferredConstantQp); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredMaxL0ReferenceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredMaxL1ReferenceCount)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnCallback)); + value->pfnCallback = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pUserData)); + value->pUserData = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersAddInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateRasterizationOrderAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionParametersAddInfoEXT* value = wrapper->decoded_value; + VkPipelineRasterizationStateRasterizationOrderAMD* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdVPSCount)); - wrapper->pStdVPSs = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdVPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdVPSs = wrapper->pStdVPSs->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSCount)); - wrapper->pStdSPSs = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdSPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdSPSs = wrapper->pStdSPSs->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSCount)); - wrapper->pStdPPSs = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdPPSs->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrder)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionParametersCreateInfoEXT* value = wrapper->decoded_value; + VkDebugMarkerObjectNameInfoEXT* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdVPSCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdSPSCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStdPPSCount)); - wrapper->pParametersAddInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pParametersAddInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectType)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->object)); + value->object = 0; + bytes_read += wrapper->pObjectName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pObjectName = wrapper->pObjectName.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersGetInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectTagInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionParametersGetInfoEXT* value = wrapper->decoded_value; + VkDebugMarkerObjectTagInfoEXT* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdVPS)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdSPS)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdPPS)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdVPSId)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdSPSId)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdPPSId)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectType)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->object)); + value->object = 0; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tagName)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tagSize)); + bytes_read += wrapper->pTag.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTag = wrapper->pTag.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerMarkerInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionParametersFeedbackInfoEXT* value = wrapper->decoded_value; + VkDebugMarkerMarkerInfoEXT* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdVPSOverrides)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdSPSOverrides)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); + bytes_read += wrapper->pMarkerName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMarkerName = wrapper->pMarkerName.GetPointer(); + wrapper->color.SetExternalMemory(value->color, 4); + bytes_read += wrapper->color.DecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265NaluSliceSegmentInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationImageCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265NaluSliceSegmentInfoEXT* value = wrapper->decoded_value; + VkDedicatedAllocationImageCreateInfoNV* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->constantQp)); - wrapper->pStdSliceSegmentHeader = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdSliceSegmentHeader->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdSliceSegmentHeader = wrapper->pStdSliceSegmentHeader->GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dedicatedAllocation)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265PictureInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationBufferCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265PictureInfoEXT* value = wrapper->decoded_value; + VkDedicatedAllocationBufferCreateInfoNV* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->naluSliceSegmentEntryCount)); - wrapper->pNaluSliceSegmentEntries = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pNaluSliceSegmentEntries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pNaluSliceSegmentEntries = wrapper->pNaluSliceSegmentEntries->GetPointer(); - wrapper->pStdPictureInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdPictureInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dedicatedAllocation)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265DpbSlotInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationMemoryAllocateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265DpbSlotInfoEXT* value = wrapper->decoded_value; + VkDedicatedAllocationMemoryAllocateInfoNV* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pStdReferenceInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdReferenceInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); + value->image = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265ProfileInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265ProfileInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceTransformFeedbackFeaturesEXT* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stdProfileIdc)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedback)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryStreams)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265RateControlInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceTransformFeedbackPropertiesEXT* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopFrameCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->idrPeriod)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->consecutiveBFrameCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subLayerCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackStreams)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackBuffers)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackBufferSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackStreamDataSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackBufferDataSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTransformFeedbackBufferDataStride)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackQueries)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackStreamsLinesTriangles)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackRasterizationStreamSelect)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackDraw)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265FrameSizeEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265FrameSizeEXT* value = wrapper->decoded_value; + VkPipelineRasterizationStateStreamCreateInfoEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameISize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->framePSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameBSize)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationStream)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlLayerInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewHandleInfoNVX* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265RateControlLayerInfoEXT* value = wrapper->decoded_value; + VkImageViewHandleInfoNVX* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMinQp)); - wrapper->minQp = DecodeAllocator::Allocate(); - wrapper->minQp->decoded_value = &(value->minQp); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minQp); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxQp)); - wrapper->maxQp = DecodeAllocator::Allocate(); - wrapper->maxQp->decoded_value = &(value->maxQp); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxQp); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxFrameSize)); - wrapper->maxFrameSize = DecodeAllocator::Allocate(); - wrapper->maxFrameSize->decoded_value = &(value->maxFrameSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFrameSize); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->imageView)); + value->imageView = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorType)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->sampler)); + value->sampler = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265GopRemainingFrameInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewAddressPropertiesNVX* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265GopRemainingFrameInfoEXT* value = wrapper->decoded_value; + VkImageViewAddressPropertiesNVX* value = wrapper->decoded_value; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useGopRemainingFrames)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingI)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingP)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gopRemainingB)); + bytes_read += ValueDecoder::DecodeVkDeviceAddressValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); return bytes_read; } @@ -17975,6 +18185,22 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultivi return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePerStageDescriptorSetFeaturesNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perStageDescriptorSet)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicPipelineLayout)); + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); diff --git a/framework/generated/generated_vulkan_struct_decoders.h b/framework/generated/generated_vulkan_struct_decoders.h index 61fcbf5b3..cdf11bb75 100644 --- a/framework/generated/generated_vulkan_struct_decoders.h +++ b/framework/generated/generated_vulkan_struct_decoders.h @@ -3733,6 +3733,310 @@ struct Decoded_VkVideoDecodeInfoKHR StructPointerDecoder* pReferenceSlots{ nullptr }; }; +struct Decoded_VkVideoEncodeH264CapabilitiesKHR +{ + using struct_type = VkVideoEncodeH264CapabilitiesKHR; + + VkVideoEncodeH264CapabilitiesKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264QpKHR +{ + using struct_type = VkVideoEncodeH264QpKHR; + + VkVideoEncodeH264QpKHR* decoded_value{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264QualityLevelPropertiesKHR +{ + using struct_type = VkVideoEncodeH264QualityLevelPropertiesKHR; + + VkVideoEncodeH264QualityLevelPropertiesKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + Decoded_VkVideoEncodeH264QpKHR* preferredConstantQp{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264SessionCreateInfoKHR +{ + using struct_type = VkVideoEncodeH264SessionCreateInfoKHR; + + VkVideoEncodeH264SessionCreateInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264SessionParametersAddInfoKHR +{ + using struct_type = VkVideoEncodeH264SessionParametersAddInfoKHR; + + VkVideoEncodeH264SessionParametersAddInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pStdSPSs{ nullptr }; + StructPointerDecoder* pStdPPSs{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR +{ + using struct_type = VkVideoEncodeH264SessionParametersCreateInfoKHR; + + VkVideoEncodeH264SessionParametersCreateInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pParametersAddInfo{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264SessionParametersGetInfoKHR +{ + using struct_type = VkVideoEncodeH264SessionParametersGetInfoKHR; + + VkVideoEncodeH264SessionParametersGetInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR +{ + using struct_type = VkVideoEncodeH264SessionParametersFeedbackInfoKHR; + + VkVideoEncodeH264SessionParametersFeedbackInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264NaluSliceInfoKHR +{ + using struct_type = VkVideoEncodeH264NaluSliceInfoKHR; + + VkVideoEncodeH264NaluSliceInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pStdSliceHeader{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264PictureInfoKHR +{ + using struct_type = VkVideoEncodeH264PictureInfoKHR; + + VkVideoEncodeH264PictureInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pNaluSliceEntries{ nullptr }; + StructPointerDecoder* pStdPictureInfo{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264DpbSlotInfoKHR +{ + using struct_type = VkVideoEncodeH264DpbSlotInfoKHR; + + VkVideoEncodeH264DpbSlotInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pStdReferenceInfo{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264ProfileInfoKHR +{ + using struct_type = VkVideoEncodeH264ProfileInfoKHR; + + VkVideoEncodeH264ProfileInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264RateControlInfoKHR +{ + using struct_type = VkVideoEncodeH264RateControlInfoKHR; + + VkVideoEncodeH264RateControlInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264FrameSizeKHR +{ + using struct_type = VkVideoEncodeH264FrameSizeKHR; + + VkVideoEncodeH264FrameSizeKHR* decoded_value{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264RateControlLayerInfoKHR +{ + using struct_type = VkVideoEncodeH264RateControlLayerInfoKHR; + + VkVideoEncodeH264RateControlLayerInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + Decoded_VkVideoEncodeH264QpKHR* minQp{ nullptr }; + Decoded_VkVideoEncodeH264QpKHR* maxQp{ nullptr }; + Decoded_VkVideoEncodeH264FrameSizeKHR* maxFrameSize{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH264GopRemainingFrameInfoKHR +{ + using struct_type = VkVideoEncodeH264GopRemainingFrameInfoKHR; + + VkVideoEncodeH264GopRemainingFrameInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265CapabilitiesKHR +{ + using struct_type = VkVideoEncodeH265CapabilitiesKHR; + + VkVideoEncodeH265CapabilitiesKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + Decoded_VkExtent2D* maxTiles{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265SessionCreateInfoKHR +{ + using struct_type = VkVideoEncodeH265SessionCreateInfoKHR; + + VkVideoEncodeH265SessionCreateInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265QpKHR +{ + using struct_type = VkVideoEncodeH265QpKHR; + + VkVideoEncodeH265QpKHR* decoded_value{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR +{ + using struct_type = VkVideoEncodeH265QualityLevelPropertiesKHR; + + VkVideoEncodeH265QualityLevelPropertiesKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + Decoded_VkVideoEncodeH265QpKHR* preferredConstantQp{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR +{ + using struct_type = VkVideoEncodeH265SessionParametersAddInfoKHR; + + VkVideoEncodeH265SessionParametersAddInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pStdVPSs{ nullptr }; + StructPointerDecoder* pStdSPSs{ nullptr }; + StructPointerDecoder* pStdPPSs{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR +{ + using struct_type = VkVideoEncodeH265SessionParametersCreateInfoKHR; + + VkVideoEncodeH265SessionParametersCreateInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pParametersAddInfo{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR +{ + using struct_type = VkVideoEncodeH265SessionParametersGetInfoKHR; + + VkVideoEncodeH265SessionParametersGetInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR +{ + using struct_type = VkVideoEncodeH265SessionParametersFeedbackInfoKHR; + + VkVideoEncodeH265SessionParametersFeedbackInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR +{ + using struct_type = VkVideoEncodeH265NaluSliceSegmentInfoKHR; + + VkVideoEncodeH265NaluSliceSegmentInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pStdSliceSegmentHeader{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265PictureInfoKHR +{ + using struct_type = VkVideoEncodeH265PictureInfoKHR; + + VkVideoEncodeH265PictureInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pNaluSliceSegmentEntries{ nullptr }; + StructPointerDecoder* pStdPictureInfo{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265DpbSlotInfoKHR +{ + using struct_type = VkVideoEncodeH265DpbSlotInfoKHR; + + VkVideoEncodeH265DpbSlotInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pStdReferenceInfo{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265ProfileInfoKHR +{ + using struct_type = VkVideoEncodeH265ProfileInfoKHR; + + VkVideoEncodeH265ProfileInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265RateControlInfoKHR +{ + using struct_type = VkVideoEncodeH265RateControlInfoKHR; + + VkVideoEncodeH265RateControlInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265FrameSizeKHR +{ + using struct_type = VkVideoEncodeH265FrameSizeKHR; + + VkVideoEncodeH265FrameSizeKHR* decoded_value{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265RateControlLayerInfoKHR +{ + using struct_type = VkVideoEncodeH265RateControlLayerInfoKHR; + + VkVideoEncodeH265RateControlLayerInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + Decoded_VkVideoEncodeH265QpKHR* minQp{ nullptr }; + Decoded_VkVideoEncodeH265QpKHR* maxQp{ nullptr }; + Decoded_VkVideoEncodeH265FrameSizeKHR* maxFrameSize{ nullptr }; +}; + +struct Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR +{ + using struct_type = VkVideoEncodeH265GopRemainingFrameInfoKHR; + + VkVideoEncodeH265GopRemainingFrameInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + struct Decoded_VkVideoDecodeH264ProfileInfoKHR { using struct_type = VkVideoDecodeH264ProfileInfoKHR; @@ -5090,6 +5394,25 @@ struct Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR PNextNode* pNext{ nullptr }; }; +struct Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR +{ + using struct_type = VkPhysicalDeviceVideoMaintenance1FeaturesKHR; + + VkPhysicalDeviceVideoMaintenance1FeaturesKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVideoInlineQueryInfoKHR +{ + using struct_type = VkVideoInlineQueryInfoKHR; + + VkVideoInlineQueryInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + format::HandleId queryPool{ format::kNullHandleId }; +}; + struct Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR { using struct_type = VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR; @@ -5134,435 +5457,227 @@ struct Decoded_VkCalibratedTimestampInfoKHR PNextNode* pNext{ nullptr }; }; -struct Decoded_VkDebugReportCallbackCreateInfoEXT +struct Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR { - using struct_type = VkDebugReportCallbackCreateInfoEXT; + using struct_type = VkPhysicalDeviceMaintenance6FeaturesKHR; - VkDebugReportCallbackCreateInfoEXT* decoded_value{ nullptr }; + VkPhysicalDeviceMaintenance6FeaturesKHR* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - uint64_t pfnCallback{ 0 }; - uint64_t pUserData{ 0 }; }; -struct Decoded_VkPipelineRasterizationStateRasterizationOrderAMD +struct Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR { - using struct_type = VkPipelineRasterizationStateRasterizationOrderAMD; + using struct_type = VkPhysicalDeviceMaintenance6PropertiesKHR; - VkPipelineRasterizationStateRasterizationOrderAMD* decoded_value{ nullptr }; + VkPhysicalDeviceMaintenance6PropertiesKHR* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; }; -struct Decoded_VkDebugMarkerObjectNameInfoEXT +struct Decoded_VkBindMemoryStatusKHR { - using struct_type = VkDebugMarkerObjectNameInfoEXT; + using struct_type = VkBindMemoryStatusKHR; - VkDebugMarkerObjectNameInfoEXT* decoded_value{ nullptr }; + VkBindMemoryStatusKHR* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - uint64_t object{ 0 }; - StringDecoder pObjectName; + PointerDecoder pResult; }; -struct Decoded_VkDebugMarkerObjectTagInfoEXT +struct Decoded_VkBindDescriptorSetsInfoKHR { - using struct_type = VkDebugMarkerObjectTagInfoEXT; + using struct_type = VkBindDescriptorSetsInfoKHR; - VkDebugMarkerObjectTagInfoEXT* decoded_value{ nullptr }; + VkBindDescriptorSetsInfoKHR* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - uint64_t object{ 0 }; - PointerDecoder pTag; -}; - -struct Decoded_VkDebugMarkerMarkerInfoEXT -{ - using struct_type = VkDebugMarkerMarkerInfoEXT; - - VkDebugMarkerMarkerInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - StringDecoder pMarkerName; - PointerDecoder color; -}; - -struct Decoded_VkDedicatedAllocationImageCreateInfoNV -{ - using struct_type = VkDedicatedAllocationImageCreateInfoNV; - - VkDedicatedAllocationImageCreateInfoNV* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkDedicatedAllocationBufferCreateInfoNV -{ - using struct_type = VkDedicatedAllocationBufferCreateInfoNV; - - VkDedicatedAllocationBufferCreateInfoNV* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkDedicatedAllocationMemoryAllocateInfoNV -{ - using struct_type = VkDedicatedAllocationMemoryAllocateInfoNV; - - VkDedicatedAllocationMemoryAllocateInfoNV* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - format::HandleId image{ format::kNullHandleId }; - format::HandleId buffer{ format::kNullHandleId }; -}; - -struct Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT -{ - using struct_type = VkPhysicalDeviceTransformFeedbackFeaturesEXT; - - VkPhysicalDeviceTransformFeedbackFeaturesEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT -{ - using struct_type = VkPhysicalDeviceTransformFeedbackPropertiesEXT; - - VkPhysicalDeviceTransformFeedbackPropertiesEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT -{ - using struct_type = VkPipelineRasterizationStateStreamCreateInfoEXT; - - VkPipelineRasterizationStateStreamCreateInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkImageViewHandleInfoNVX -{ - using struct_type = VkImageViewHandleInfoNVX; - - VkImageViewHandleInfoNVX* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - format::HandleId imageView{ format::kNullHandleId }; - format::HandleId sampler{ format::kNullHandleId }; -}; - -struct Decoded_VkImageViewAddressPropertiesNVX -{ - using struct_type = VkImageViewAddressPropertiesNVX; - - VkImageViewAddressPropertiesNVX* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264CapabilitiesEXT -{ - using struct_type = VkVideoEncodeH264CapabilitiesEXT; - - VkVideoEncodeH264CapabilitiesEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264QpEXT -{ - using struct_type = VkVideoEncodeH264QpEXT; - - VkVideoEncodeH264QpEXT* decoded_value{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264QualityLevelPropertiesEXT -{ - using struct_type = VkVideoEncodeH264QualityLevelPropertiesEXT; - - VkVideoEncodeH264QualityLevelPropertiesEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - Decoded_VkVideoEncodeH264QpEXT* preferredConstantQp{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264SessionCreateInfoEXT -{ - using struct_type = VkVideoEncodeH264SessionCreateInfoEXT; - - VkVideoEncodeH264SessionCreateInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264SessionParametersAddInfoEXT -{ - using struct_type = VkVideoEncodeH264SessionParametersAddInfoEXT; - - VkVideoEncodeH264SessionParametersAddInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - StructPointerDecoder* pStdSPSs{ nullptr }; - StructPointerDecoder* pStdPPSs{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264SessionParametersCreateInfoEXT -{ - using struct_type = VkVideoEncodeH264SessionParametersCreateInfoEXT; - - VkVideoEncodeH264SessionParametersCreateInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - StructPointerDecoder* pParametersAddInfo{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264SessionParametersGetInfoEXT -{ - using struct_type = VkVideoEncodeH264SessionParametersGetInfoEXT; - - VkVideoEncodeH264SessionParametersGetInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoEXT -{ - using struct_type = VkVideoEncodeH264SessionParametersFeedbackInfoEXT; - - VkVideoEncodeH264SessionParametersFeedbackInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264NaluSliceInfoEXT -{ - using struct_type = VkVideoEncodeH264NaluSliceInfoEXT; - - VkVideoEncodeH264NaluSliceInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - StructPointerDecoder* pStdSliceHeader{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264PictureInfoEXT -{ - using struct_type = VkVideoEncodeH264PictureInfoEXT; - - VkVideoEncodeH264PictureInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - StructPointerDecoder* pNaluSliceEntries{ nullptr }; - StructPointerDecoder* pStdPictureInfo{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264DpbSlotInfoEXT -{ - using struct_type = VkVideoEncodeH264DpbSlotInfoEXT; - - VkVideoEncodeH264DpbSlotInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - StructPointerDecoder* pStdReferenceInfo{ nullptr }; + format::HandleId layout{ format::kNullHandleId }; + HandlePointerDecoder pDescriptorSets; + PointerDecoder pDynamicOffsets; }; -struct Decoded_VkVideoEncodeH264ProfileInfoEXT +struct Decoded_VkPushConstantsInfoKHR { - using struct_type = VkVideoEncodeH264ProfileInfoEXT; + using struct_type = VkPushConstantsInfoKHR; - VkVideoEncodeH264ProfileInfoEXT* decoded_value{ nullptr }; + VkPushConstantsInfoKHR* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; + format::HandleId layout{ format::kNullHandleId }; + PointerDecoder pValues; }; -struct Decoded_VkVideoEncodeH264RateControlInfoEXT +struct Decoded_VkPushDescriptorSetInfoKHR { - using struct_type = VkVideoEncodeH264RateControlInfoEXT; + using struct_type = VkPushDescriptorSetInfoKHR; - VkVideoEncodeH264RateControlInfoEXT* decoded_value{ nullptr }; + VkPushDescriptorSetInfoKHR* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; + format::HandleId layout{ format::kNullHandleId }; + StructPointerDecoder* pDescriptorWrites{ nullptr }; }; -struct Decoded_VkVideoEncodeH264FrameSizeEXT -{ - using struct_type = VkVideoEncodeH264FrameSizeEXT; - - VkVideoEncodeH264FrameSizeEXT* decoded_value{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH264RateControlLayerInfoEXT +struct Decoded_VkPushDescriptorSetWithTemplateInfoKHR { - using struct_type = VkVideoEncodeH264RateControlLayerInfoEXT; + using struct_type = VkPushDescriptorSetWithTemplateInfoKHR; - VkVideoEncodeH264RateControlLayerInfoEXT* decoded_value{ nullptr }; + VkPushDescriptorSetWithTemplateInfoKHR* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - Decoded_VkVideoEncodeH264QpEXT* minQp{ nullptr }; - Decoded_VkVideoEncodeH264QpEXT* maxQp{ nullptr }; - Decoded_VkVideoEncodeH264FrameSizeEXT* maxFrameSize{ nullptr }; + format::HandleId descriptorUpdateTemplate{ format::kNullHandleId }; + format::HandleId layout{ format::kNullHandleId }; + uint64_t pData{ 0 }; }; -struct Decoded_VkVideoEncodeH264GopRemainingFrameInfoEXT +struct Decoded_VkSetDescriptorBufferOffsetsInfoEXT { - using struct_type = VkVideoEncodeH264GopRemainingFrameInfoEXT; + using struct_type = VkSetDescriptorBufferOffsetsInfoEXT; - VkVideoEncodeH264GopRemainingFrameInfoEXT* decoded_value{ nullptr }; + VkSetDescriptorBufferOffsetsInfoEXT* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; + format::HandleId layout{ format::kNullHandleId }; + PointerDecoder pBufferIndices; + PointerDecoder pOffsets; }; -struct Decoded_VkVideoEncodeH265CapabilitiesEXT +struct Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT { - using struct_type = VkVideoEncodeH265CapabilitiesEXT; + using struct_type = VkBindDescriptorBufferEmbeddedSamplersInfoEXT; - VkVideoEncodeH265CapabilitiesEXT* decoded_value{ nullptr }; + VkBindDescriptorBufferEmbeddedSamplersInfoEXT* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - Decoded_VkExtent2D* maxTiles{ nullptr }; + format::HandleId layout{ format::kNullHandleId }; }; -struct Decoded_VkVideoEncodeH265SessionCreateInfoEXT +struct Decoded_VkDebugReportCallbackCreateInfoEXT { - using struct_type = VkVideoEncodeH265SessionCreateInfoEXT; + using struct_type = VkDebugReportCallbackCreateInfoEXT; - VkVideoEncodeH265SessionCreateInfoEXT* decoded_value{ nullptr }; + VkDebugReportCallbackCreateInfoEXT* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; + uint64_t pfnCallback{ 0 }; + uint64_t pUserData{ 0 }; }; -struct Decoded_VkVideoEncodeH265QpEXT -{ - using struct_type = VkVideoEncodeH265QpEXT; - - VkVideoEncodeH265QpEXT* decoded_value{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH265QualityLevelPropertiesEXT +struct Decoded_VkPipelineRasterizationStateRasterizationOrderAMD { - using struct_type = VkVideoEncodeH265QualityLevelPropertiesEXT; + using struct_type = VkPipelineRasterizationStateRasterizationOrderAMD; - VkVideoEncodeH265QualityLevelPropertiesEXT* decoded_value{ nullptr }; + VkPipelineRasterizationStateRasterizationOrderAMD* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - Decoded_VkVideoEncodeH265QpEXT* preferredConstantQp{ nullptr }; }; -struct Decoded_VkVideoEncodeH265SessionParametersAddInfoEXT +struct Decoded_VkDebugMarkerObjectNameInfoEXT { - using struct_type = VkVideoEncodeH265SessionParametersAddInfoEXT; + using struct_type = VkDebugMarkerObjectNameInfoEXT; - VkVideoEncodeH265SessionParametersAddInfoEXT* decoded_value{ nullptr }; + VkDebugMarkerObjectNameInfoEXT* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - StructPointerDecoder* pStdVPSs{ nullptr }; - StructPointerDecoder* pStdSPSs{ nullptr }; - StructPointerDecoder* pStdPPSs{ nullptr }; + uint64_t object{ 0 }; + StringDecoder pObjectName; }; -struct Decoded_VkVideoEncodeH265SessionParametersCreateInfoEXT +struct Decoded_VkDebugMarkerObjectTagInfoEXT { - using struct_type = VkVideoEncodeH265SessionParametersCreateInfoEXT; + using struct_type = VkDebugMarkerObjectTagInfoEXT; - VkVideoEncodeH265SessionParametersCreateInfoEXT* decoded_value{ nullptr }; + VkDebugMarkerObjectTagInfoEXT* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - StructPointerDecoder* pParametersAddInfo{ nullptr }; + uint64_t object{ 0 }; + PointerDecoder pTag; }; -struct Decoded_VkVideoEncodeH265SessionParametersGetInfoEXT +struct Decoded_VkDebugMarkerMarkerInfoEXT { - using struct_type = VkVideoEncodeH265SessionParametersGetInfoEXT; + using struct_type = VkDebugMarkerMarkerInfoEXT; - VkVideoEncodeH265SessionParametersGetInfoEXT* decoded_value{ nullptr }; + VkDebugMarkerMarkerInfoEXT* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; + StringDecoder pMarkerName; + PointerDecoder color; }; -struct Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoEXT +struct Decoded_VkDedicatedAllocationImageCreateInfoNV { - using struct_type = VkVideoEncodeH265SessionParametersFeedbackInfoEXT; + using struct_type = VkDedicatedAllocationImageCreateInfoNV; - VkVideoEncodeH265SessionParametersFeedbackInfoEXT* decoded_value{ nullptr }; + VkDedicatedAllocationImageCreateInfoNV* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; }; -struct Decoded_VkVideoEncodeH265NaluSliceSegmentInfoEXT +struct Decoded_VkDedicatedAllocationBufferCreateInfoNV { - using struct_type = VkVideoEncodeH265NaluSliceSegmentInfoEXT; + using struct_type = VkDedicatedAllocationBufferCreateInfoNV; - VkVideoEncodeH265NaluSliceSegmentInfoEXT* decoded_value{ nullptr }; + VkDedicatedAllocationBufferCreateInfoNV* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - StructPointerDecoder* pStdSliceSegmentHeader{ nullptr }; }; -struct Decoded_VkVideoEncodeH265PictureInfoEXT +struct Decoded_VkDedicatedAllocationMemoryAllocateInfoNV { - using struct_type = VkVideoEncodeH265PictureInfoEXT; + using struct_type = VkDedicatedAllocationMemoryAllocateInfoNV; - VkVideoEncodeH265PictureInfoEXT* decoded_value{ nullptr }; + VkDedicatedAllocationMemoryAllocateInfoNV* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - StructPointerDecoder* pNaluSliceSegmentEntries{ nullptr }; - StructPointerDecoder* pStdPictureInfo{ nullptr }; + format::HandleId image{ format::kNullHandleId }; + format::HandleId buffer{ format::kNullHandleId }; }; -struct Decoded_VkVideoEncodeH265DpbSlotInfoEXT +struct Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT { - using struct_type = VkVideoEncodeH265DpbSlotInfoEXT; + using struct_type = VkPhysicalDeviceTransformFeedbackFeaturesEXT; - VkVideoEncodeH265DpbSlotInfoEXT* decoded_value{ nullptr }; + VkPhysicalDeviceTransformFeedbackFeaturesEXT* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - StructPointerDecoder* pStdReferenceInfo{ nullptr }; }; -struct Decoded_VkVideoEncodeH265ProfileInfoEXT +struct Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT { - using struct_type = VkVideoEncodeH265ProfileInfoEXT; + using struct_type = VkPhysicalDeviceTransformFeedbackPropertiesEXT; - VkVideoEncodeH265ProfileInfoEXT* decoded_value{ nullptr }; + VkPhysicalDeviceTransformFeedbackPropertiesEXT* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; }; -struct Decoded_VkVideoEncodeH265RateControlInfoEXT +struct Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT { - using struct_type = VkVideoEncodeH265RateControlInfoEXT; + using struct_type = VkPipelineRasterizationStateStreamCreateInfoEXT; - VkVideoEncodeH265RateControlInfoEXT* decoded_value{ nullptr }; + VkPipelineRasterizationStateStreamCreateInfoEXT* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; }; -struct Decoded_VkVideoEncodeH265FrameSizeEXT -{ - using struct_type = VkVideoEncodeH265FrameSizeEXT; - - VkVideoEncodeH265FrameSizeEXT* decoded_value{ nullptr }; -}; - -struct Decoded_VkVideoEncodeH265RateControlLayerInfoEXT +struct Decoded_VkImageViewHandleInfoNVX { - using struct_type = VkVideoEncodeH265RateControlLayerInfoEXT; + using struct_type = VkImageViewHandleInfoNVX; - VkVideoEncodeH265RateControlLayerInfoEXT* decoded_value{ nullptr }; + VkImageViewHandleInfoNVX* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; - Decoded_VkVideoEncodeH265QpEXT* minQp{ nullptr }; - Decoded_VkVideoEncodeH265QpEXT* maxQp{ nullptr }; - Decoded_VkVideoEncodeH265FrameSizeEXT* maxFrameSize{ nullptr }; + format::HandleId imageView{ format::kNullHandleId }; + format::HandleId sampler{ format::kNullHandleId }; }; -struct Decoded_VkVideoEncodeH265GopRemainingFrameInfoEXT +struct Decoded_VkImageViewAddressPropertiesNVX { - using struct_type = VkVideoEncodeH265GopRemainingFrameInfoEXT; + using struct_type = VkImageViewAddressPropertiesNVX; - VkVideoEncodeH265GopRemainingFrameInfoEXT* decoded_value{ nullptr }; + VkImageViewAddressPropertiesNVX* decoded_value{ nullptr }; PNextNode* pNext{ nullptr }; }; @@ -9413,6 +9528,15 @@ struct Decoded_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM StructPointerDecoder* pPerViewRenderAreas{ nullptr }; }; +struct Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV +{ + using struct_type = VkPhysicalDevicePerStageDescriptorSetFeaturesNV; + + VkPhysicalDevicePerStageDescriptorSetFeaturesNV* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + struct Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM { using struct_type = VkPhysicalDeviceImageProcessing2FeaturesQCOM; diff --git a/framework/generated/generated_vulkan_struct_decoders_forward.h b/framework/generated/generated_vulkan_struct_decoders_forward.h index b22e1e700..0154d1a36 100644 --- a/framework/generated/generated_vulkan_struct_decoders_forward.h +++ b/framework/generated/generated_vulkan_struct_decoders_forward.h @@ -829,6 +829,74 @@ size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeUsageInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeInfoKHR* wrapper); +struct Decoded_VkVideoEncodeH264CapabilitiesKHR; +struct Decoded_VkVideoEncodeH264QpKHR; +struct Decoded_VkVideoEncodeH264QualityLevelPropertiesKHR; +struct Decoded_VkVideoEncodeH264SessionCreateInfoKHR; +struct Decoded_VkVideoEncodeH264SessionParametersAddInfoKHR; +struct Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR; +struct Decoded_VkVideoEncodeH264SessionParametersGetInfoKHR; +struct Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR; +struct Decoded_VkVideoEncodeH264NaluSliceInfoKHR; +struct Decoded_VkVideoEncodeH264PictureInfoKHR; +struct Decoded_VkVideoEncodeH264DpbSlotInfoKHR; +struct Decoded_VkVideoEncodeH264ProfileInfoKHR; +struct Decoded_VkVideoEncodeH264RateControlInfoKHR; +struct Decoded_VkVideoEncodeH264FrameSizeKHR; +struct Decoded_VkVideoEncodeH264RateControlLayerInfoKHR; +struct Decoded_VkVideoEncodeH264GopRemainingFrameInfoKHR; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264CapabilitiesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QpKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QualityLevelPropertiesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionCreateInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersAddInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersGetInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264NaluSliceInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264PictureInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264DpbSlotInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264ProfileInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264FrameSizeKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlLayerInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264GopRemainingFrameInfoKHR* wrapper); + +struct Decoded_VkVideoEncodeH265CapabilitiesKHR; +struct Decoded_VkVideoEncodeH265SessionCreateInfoKHR; +struct Decoded_VkVideoEncodeH265QpKHR; +struct Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR; +struct Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR; +struct Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR; +struct Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR; +struct Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR; +struct Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR; +struct Decoded_VkVideoEncodeH265PictureInfoKHR; +struct Decoded_VkVideoEncodeH265DpbSlotInfoKHR; +struct Decoded_VkVideoEncodeH265ProfileInfoKHR; +struct Decoded_VkVideoEncodeH265RateControlInfoKHR; +struct Decoded_VkVideoEncodeH265FrameSizeKHR; +struct Decoded_VkVideoEncodeH265RateControlLayerInfoKHR; +struct Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265CapabilitiesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionCreateInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QpKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265PictureInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265DpbSlotInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265ProfileInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265FrameSizeKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlLayerInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR* wrapper); + struct Decoded_VkVideoDecodeH264ProfileInfoKHR; struct Decoded_VkVideoDecodeH264CapabilitiesKHR; struct Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR; @@ -1119,6 +1187,12 @@ size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* wrapper); +struct Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR; +struct Decoded_VkVideoInlineQueryInfoKHR; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoInlineQueryInfoKHR* wrapper); + struct Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR; struct Decoded_VkVertexInputBindingDivisorDescriptionKHR; struct Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR; @@ -1133,6 +1207,26 @@ struct Decoded_VkCalibratedTimestampInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoKHR* wrapper); +struct Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR; +struct Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR; +struct Decoded_VkBindMemoryStatusKHR; +struct Decoded_VkBindDescriptorSetsInfoKHR; +struct Decoded_VkPushConstantsInfoKHR; +struct Decoded_VkPushDescriptorSetInfoKHR; +struct Decoded_VkPushDescriptorSetWithTemplateInfoKHR; +struct Decoded_VkSetDescriptorBufferOffsetsInfoEXT; +struct Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindMemoryStatusKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindDescriptorSetsInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPushConstantsInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPushDescriptorSetInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPushDescriptorSetWithTemplateInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSetDescriptorBufferOffsetsInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* wrapper); + struct Decoded_VkDebugReportCallbackCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugReportCallbackCreateInfoEXT* wrapper); @@ -1171,74 +1265,6 @@ struct Decoded_VkImageViewAddressPropertiesNVX; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewHandleInfoNVX* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewAddressPropertiesNVX* wrapper); -struct Decoded_VkVideoEncodeH264CapabilitiesEXT; -struct Decoded_VkVideoEncodeH264QpEXT; -struct Decoded_VkVideoEncodeH264QualityLevelPropertiesEXT; -struct Decoded_VkVideoEncodeH264SessionCreateInfoEXT; -struct Decoded_VkVideoEncodeH264SessionParametersAddInfoEXT; -struct Decoded_VkVideoEncodeH264SessionParametersCreateInfoEXT; -struct Decoded_VkVideoEncodeH264SessionParametersGetInfoEXT; -struct Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoEXT; -struct Decoded_VkVideoEncodeH264NaluSliceInfoEXT; -struct Decoded_VkVideoEncodeH264PictureInfoEXT; -struct Decoded_VkVideoEncodeH264DpbSlotInfoEXT; -struct Decoded_VkVideoEncodeH264ProfileInfoEXT; -struct Decoded_VkVideoEncodeH264RateControlInfoEXT; -struct Decoded_VkVideoEncodeH264FrameSizeEXT; -struct Decoded_VkVideoEncodeH264RateControlLayerInfoEXT; -struct Decoded_VkVideoEncodeH264GopRemainingFrameInfoEXT; - -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264CapabilitiesEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QpEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QualityLevelPropertiesEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionCreateInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersAddInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersCreateInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersGetInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264NaluSliceInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264PictureInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264DpbSlotInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264ProfileInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264FrameSizeEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlLayerInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264GopRemainingFrameInfoEXT* wrapper); - -struct Decoded_VkVideoEncodeH265CapabilitiesEXT; -struct Decoded_VkVideoEncodeH265SessionCreateInfoEXT; -struct Decoded_VkVideoEncodeH265QpEXT; -struct Decoded_VkVideoEncodeH265QualityLevelPropertiesEXT; -struct Decoded_VkVideoEncodeH265SessionParametersAddInfoEXT; -struct Decoded_VkVideoEncodeH265SessionParametersCreateInfoEXT; -struct Decoded_VkVideoEncodeH265SessionParametersGetInfoEXT; -struct Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoEXT; -struct Decoded_VkVideoEncodeH265NaluSliceSegmentInfoEXT; -struct Decoded_VkVideoEncodeH265PictureInfoEXT; -struct Decoded_VkVideoEncodeH265DpbSlotInfoEXT; -struct Decoded_VkVideoEncodeH265ProfileInfoEXT; -struct Decoded_VkVideoEncodeH265RateControlInfoEXT; -struct Decoded_VkVideoEncodeH265FrameSizeEXT; -struct Decoded_VkVideoEncodeH265RateControlLayerInfoEXT; -struct Decoded_VkVideoEncodeH265GopRemainingFrameInfoEXT; - -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265CapabilitiesEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionCreateInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QpEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QualityLevelPropertiesEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersAddInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersCreateInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersGetInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265NaluSliceSegmentInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265PictureInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265DpbSlotInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265ProfileInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265FrameSizeEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlLayerInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265GopRemainingFrameInfoEXT* wrapper); - struct Decoded_VkTextureLODGatherFormatPropertiesAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTextureLODGatherFormatPropertiesAMD* wrapper); @@ -2359,6 +2385,10 @@ struct Decoded_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* wrapper); +struct Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* wrapper); + struct Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM; struct Decoded_VkPhysicalDeviceImageProcessing2PropertiesQCOM; struct Decoded_VkSamplerBlockMatchWindowCreateInfoQCOM; diff --git a/framework/generated/generated_vulkan_struct_encoders.cpp b/framework/generated/generated_vulkan_struct_encoders.cpp index 020ea6155..5bd7b65d5 100644 --- a/framework/generated/generated_vulkan_struct_encoders.cpp +++ b/framework/generated/generated_vulkan_struct_encoders.cpp @@ -4153,6 +4153,329 @@ void EncodeStruct(ParameterEncoder* encoder, const VkVideoDecodeInfoKHR& value) EncodeStructArray(encoder, value.pReferenceSlots, value.referenceSlotCount); } +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264CapabilitiesKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.flags); + encoder->EncodeEnumValue(value.maxLevelIdc); + encoder->EncodeUInt32Value(value.maxSliceCount); + encoder->EncodeUInt32Value(value.maxPPictureL0ReferenceCount); + encoder->EncodeUInt32Value(value.maxBPictureL0ReferenceCount); + encoder->EncodeUInt32Value(value.maxL1ReferenceCount); + encoder->EncodeUInt32Value(value.maxTemporalLayerCount); + encoder->EncodeVkBool32Value(value.expectDyadicTemporalLayerPattern); + encoder->EncodeInt32Value(value.minQp); + encoder->EncodeInt32Value(value.maxQp); + encoder->EncodeVkBool32Value(value.prefersGopRemainingFrames); + encoder->EncodeVkBool32Value(value.requiresGopRemainingFrames); + encoder->EncodeFlagsValue(value.stdSyntaxFlags); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264QpKHR& value) +{ + encoder->EncodeInt32Value(value.qpI); + encoder->EncodeInt32Value(value.qpP); + encoder->EncodeInt32Value(value.qpB); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264QualityLevelPropertiesKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.preferredRateControlFlags); + encoder->EncodeUInt32Value(value.preferredGopFrameCount); + encoder->EncodeUInt32Value(value.preferredIdrPeriod); + encoder->EncodeUInt32Value(value.preferredConsecutiveBFrameCount); + encoder->EncodeUInt32Value(value.preferredTemporalLayerCount); + EncodeStruct(encoder, value.preferredConstantQp); + encoder->EncodeUInt32Value(value.preferredMaxL0ReferenceCount); + encoder->EncodeUInt32Value(value.preferredMaxL1ReferenceCount); + encoder->EncodeVkBool32Value(value.preferredStdEntropyCodingModeFlag); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionCreateInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.useMaxLevelIdc); + encoder->EncodeEnumValue(value.maxLevelIdc); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersAddInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.stdSPSCount); + EncodeStructArray(encoder, value.pStdSPSs, value.stdSPSCount); + encoder->EncodeUInt32Value(value.stdPPSCount); + EncodeStructArray(encoder, value.pStdPPSs, value.stdPPSCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersCreateInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.maxStdSPSCount); + encoder->EncodeUInt32Value(value.maxStdPPSCount); + EncodeStructPtr(encoder, value.pParametersAddInfo); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersGetInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.writeStdSPS); + encoder->EncodeVkBool32Value(value.writeStdPPS); + encoder->EncodeUInt32Value(value.stdSPSId); + encoder->EncodeUInt32Value(value.stdPPSId); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersFeedbackInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.hasStdSPSOverrides); + encoder->EncodeVkBool32Value(value.hasStdPPSOverrides); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264NaluSliceInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeInt32Value(value.constantQp); + EncodeStructPtr(encoder, value.pStdSliceHeader); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264PictureInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.naluSliceEntryCount); + EncodeStructArray(encoder, value.pNaluSliceEntries, value.naluSliceEntryCount); + EncodeStructPtr(encoder, value.pStdPictureInfo); + encoder->EncodeVkBool32Value(value.generatePrefixNalu); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264DpbSlotInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + EncodeStructPtr(encoder, value.pStdReferenceInfo); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264ProfileInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeEnumValue(value.stdProfileIdc); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264RateControlInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.flags); + encoder->EncodeUInt32Value(value.gopFrameCount); + encoder->EncodeUInt32Value(value.idrPeriod); + encoder->EncodeUInt32Value(value.consecutiveBFrameCount); + encoder->EncodeUInt32Value(value.temporalLayerCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264FrameSizeKHR& value) +{ + encoder->EncodeUInt32Value(value.frameISize); + encoder->EncodeUInt32Value(value.framePSize); + encoder->EncodeUInt32Value(value.frameBSize); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264RateControlLayerInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.useMinQp); + EncodeStruct(encoder, value.minQp); + encoder->EncodeVkBool32Value(value.useMaxQp); + EncodeStruct(encoder, value.maxQp); + encoder->EncodeVkBool32Value(value.useMaxFrameSize); + EncodeStruct(encoder, value.maxFrameSize); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264GopRemainingFrameInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.useGopRemainingFrames); + encoder->EncodeUInt32Value(value.gopRemainingI); + encoder->EncodeUInt32Value(value.gopRemainingP); + encoder->EncodeUInt32Value(value.gopRemainingB); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265CapabilitiesKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.flags); + encoder->EncodeEnumValue(value.maxLevelIdc); + encoder->EncodeUInt32Value(value.maxSliceSegmentCount); + EncodeStruct(encoder, value.maxTiles); + encoder->EncodeFlagsValue(value.ctbSizes); + encoder->EncodeFlagsValue(value.transformBlockSizes); + encoder->EncodeUInt32Value(value.maxPPictureL0ReferenceCount); + encoder->EncodeUInt32Value(value.maxBPictureL0ReferenceCount); + encoder->EncodeUInt32Value(value.maxL1ReferenceCount); + encoder->EncodeUInt32Value(value.maxSubLayerCount); + encoder->EncodeVkBool32Value(value.expectDyadicTemporalSubLayerPattern); + encoder->EncodeInt32Value(value.minQp); + encoder->EncodeInt32Value(value.maxQp); + encoder->EncodeVkBool32Value(value.prefersGopRemainingFrames); + encoder->EncodeVkBool32Value(value.requiresGopRemainingFrames); + encoder->EncodeFlagsValue(value.stdSyntaxFlags); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionCreateInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.useMaxLevelIdc); + encoder->EncodeEnumValue(value.maxLevelIdc); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265QpKHR& value) +{ + encoder->EncodeInt32Value(value.qpI); + encoder->EncodeInt32Value(value.qpP); + encoder->EncodeInt32Value(value.qpB); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265QualityLevelPropertiesKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.preferredRateControlFlags); + encoder->EncodeUInt32Value(value.preferredGopFrameCount); + encoder->EncodeUInt32Value(value.preferredIdrPeriod); + encoder->EncodeUInt32Value(value.preferredConsecutiveBFrameCount); + encoder->EncodeUInt32Value(value.preferredSubLayerCount); + EncodeStruct(encoder, value.preferredConstantQp); + encoder->EncodeUInt32Value(value.preferredMaxL0ReferenceCount); + encoder->EncodeUInt32Value(value.preferredMaxL1ReferenceCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersAddInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.stdVPSCount); + EncodeStructArray(encoder, value.pStdVPSs, value.stdVPSCount); + encoder->EncodeUInt32Value(value.stdSPSCount); + EncodeStructArray(encoder, value.pStdSPSs, value.stdSPSCount); + encoder->EncodeUInt32Value(value.stdPPSCount); + EncodeStructArray(encoder, value.pStdPPSs, value.stdPPSCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersCreateInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.maxStdVPSCount); + encoder->EncodeUInt32Value(value.maxStdSPSCount); + encoder->EncodeUInt32Value(value.maxStdPPSCount); + EncodeStructPtr(encoder, value.pParametersAddInfo); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersGetInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.writeStdVPS); + encoder->EncodeVkBool32Value(value.writeStdSPS); + encoder->EncodeVkBool32Value(value.writeStdPPS); + encoder->EncodeUInt32Value(value.stdVPSId); + encoder->EncodeUInt32Value(value.stdSPSId); + encoder->EncodeUInt32Value(value.stdPPSId); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersFeedbackInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.hasStdVPSOverrides); + encoder->EncodeVkBool32Value(value.hasStdSPSOverrides); + encoder->EncodeVkBool32Value(value.hasStdPPSOverrides); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265NaluSliceSegmentInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeInt32Value(value.constantQp); + EncodeStructPtr(encoder, value.pStdSliceSegmentHeader); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265PictureInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.naluSliceSegmentEntryCount); + EncodeStructArray(encoder, value.pNaluSliceSegmentEntries, value.naluSliceSegmentEntryCount); + EncodeStructPtr(encoder, value.pStdPictureInfo); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265DpbSlotInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + EncodeStructPtr(encoder, value.pStdReferenceInfo); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265ProfileInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeEnumValue(value.stdProfileIdc); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265RateControlInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.flags); + encoder->EncodeUInt32Value(value.gopFrameCount); + encoder->EncodeUInt32Value(value.idrPeriod); + encoder->EncodeUInt32Value(value.consecutiveBFrameCount); + encoder->EncodeUInt32Value(value.subLayerCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265FrameSizeKHR& value) +{ + encoder->EncodeUInt32Value(value.frameISize); + encoder->EncodeUInt32Value(value.framePSize); + encoder->EncodeUInt32Value(value.frameBSize); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265RateControlLayerInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.useMinQp); + EncodeStruct(encoder, value.minQp); + encoder->EncodeVkBool32Value(value.useMaxQp); + EncodeStruct(encoder, value.maxQp); + encoder->EncodeVkBool32Value(value.useMaxFrameSize); + EncodeStruct(encoder, value.maxFrameSize); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265GopRemainingFrameInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.useGopRemainingFrames); + encoder->EncodeUInt32Value(value.gopRemainingI); + encoder->EncodeUInt32Value(value.gopRemainingP); + encoder->EncodeUInt32Value(value.gopRemainingB); +} + void EncodeStruct(ParameterEncoder* encoder, const VkVideoDecodeH264ProfileInfoKHR& value) { encoder->EncodeEnumValue(value.sType); @@ -5075,516 +5398,298 @@ void EncodeStruct(ParameterEncoder* encoder, const VkBufferUsageFlags2CreateInfo encoder->EncodeFlags64Value(value.usage); } -void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.rayTracingPositionFetch); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkCooperativeMatrixPropertiesKHR& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.MSize); - encoder->EncodeUInt32Value(value.NSize); - encoder->EncodeUInt32Value(value.KSize); - encoder->EncodeEnumValue(value.AType); - encoder->EncodeEnumValue(value.BType); - encoder->EncodeEnumValue(value.CType); - encoder->EncodeEnumValue(value.ResultType); - encoder->EncodeVkBool32Value(value.saturatingAccumulation); - encoder->EncodeEnumValue(value.scope); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.cooperativeMatrix); - encoder->EncodeVkBool32Value(value.cooperativeMatrixRobustBufferAccess); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeFlagsValue(value.cooperativeMatrixSupportedStages); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.maxVertexAttribDivisor); - encoder->EncodeVkBool32Value(value.supportsNonZeroFirstInstance); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkVertexInputBindingDivisorDescriptionKHR& value) -{ - encoder->EncodeUInt32Value(value.binding); - encoder->EncodeUInt32Value(value.divisor); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPipelineVertexInputDivisorStateCreateInfoKHR& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.vertexBindingDivisorCount); - EncodeStructArray(encoder, value.pVertexBindingDivisors, value.vertexBindingDivisorCount); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.vertexAttributeInstanceRateDivisor); - encoder->EncodeVkBool32Value(value.vertexAttributeInstanceRateZeroDivisor); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkCalibratedTimestampInfoKHR& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeEnumValue(value.timeDomain); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkDebugReportCallbackCreateInfoEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeFlagsValue(value.flags); - encoder->EncodeFunctionPtr(value.pfnCallback); - encoder->EncodeVoidPtr(value.pUserData); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPipelineRasterizationStateRasterizationOrderAMD& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeEnumValue(value.rasterizationOrder); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkDebugMarkerObjectNameInfoEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeEnumValue(value.objectType); - encoder->EncodeUInt64Value(GetWrappedId(value.object, value.objectType)); - encoder->EncodeString(value.pObjectName); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkDebugMarkerObjectTagInfoEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeEnumValue(value.objectType); - encoder->EncodeUInt64Value(GetWrappedId(value.object, value.objectType)); - encoder->EncodeUInt64Value(value.tagName); - encoder->EncodeSizeTValue(value.tagSize); - encoder->EncodeVoidArray(value.pTag, value.tagSize); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkDebugMarkerMarkerInfoEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeString(value.pMarkerName); - encoder->EncodeFloatArray(value.color, 4); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkDedicatedAllocationImageCreateInfoNV& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.dedicatedAllocation); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkDedicatedAllocationBufferCreateInfoNV& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.dedicatedAllocation); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkDedicatedAllocationMemoryAllocateInfoNV& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeHandleValue(value.image); - encoder->EncodeHandleValue(value.buffer); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceTransformFeedbackFeaturesEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.transformFeedback); - encoder->EncodeVkBool32Value(value.geometryStreams); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceTransformFeedbackPropertiesEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.maxTransformFeedbackStreams); - encoder->EncodeUInt32Value(value.maxTransformFeedbackBuffers); - encoder->EncodeVkDeviceSizeValue(value.maxTransformFeedbackBufferSize); - encoder->EncodeUInt32Value(value.maxTransformFeedbackStreamDataSize); - encoder->EncodeUInt32Value(value.maxTransformFeedbackBufferDataSize); - encoder->EncodeUInt32Value(value.maxTransformFeedbackBufferDataStride); - encoder->EncodeVkBool32Value(value.transformFeedbackQueries); - encoder->EncodeVkBool32Value(value.transformFeedbackStreamsLinesTriangles); - encoder->EncodeVkBool32Value(value.transformFeedbackRasterizationStreamSelect); - encoder->EncodeVkBool32Value(value.transformFeedbackDraw); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPipelineRasterizationStateStreamCreateInfoEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeFlagsValue(value.flags); - encoder->EncodeUInt32Value(value.rasterizationStream); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkImageViewHandleInfoNVX& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeHandleValue(value.imageView); - encoder->EncodeEnumValue(value.descriptorType); - encoder->EncodeHandleValue(value.sampler); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkImageViewAddressPropertiesNVX& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkDeviceAddressValue(value.deviceAddress); - encoder->EncodeVkDeviceSizeValue(value.size); + encoder->EncodeVkBool32Value(value.rayTracingPositionFetch); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264CapabilitiesEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkCooperativeMatrixPropertiesKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeFlagsValue(value.flags); - encoder->EncodeEnumValue(value.maxLevelIdc); - encoder->EncodeUInt32Value(value.maxSliceCount); - encoder->EncodeUInt32Value(value.maxPPictureL0ReferenceCount); - encoder->EncodeUInt32Value(value.maxBPictureL0ReferenceCount); - encoder->EncodeUInt32Value(value.maxL1ReferenceCount); - encoder->EncodeUInt32Value(value.maxTemporalLayerCount); - encoder->EncodeVkBool32Value(value.expectDyadicTemporalLayerPattern); - encoder->EncodeInt32Value(value.minQp); - encoder->EncodeInt32Value(value.maxQp); - encoder->EncodeVkBool32Value(value.prefersGopRemainingFrames); - encoder->EncodeVkBool32Value(value.requiresGopRemainingFrames); - encoder->EncodeFlagsValue(value.stdSyntaxFlags); + encoder->EncodeUInt32Value(value.MSize); + encoder->EncodeUInt32Value(value.NSize); + encoder->EncodeUInt32Value(value.KSize); + encoder->EncodeEnumValue(value.AType); + encoder->EncodeEnumValue(value.BType); + encoder->EncodeEnumValue(value.CType); + encoder->EncodeEnumValue(value.ResultType); + encoder->EncodeVkBool32Value(value.saturatingAccumulation); + encoder->EncodeEnumValue(value.scope); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264QpEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& value) { - encoder->EncodeInt32Value(value.qpI); - encoder->EncodeInt32Value(value.qpP); - encoder->EncodeInt32Value(value.qpB); + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.cooperativeMatrix); + encoder->EncodeVkBool32Value(value.cooperativeMatrixRobustBufferAccess); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264QualityLevelPropertiesEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeFlagsValue(value.preferredRateControlFlags); - encoder->EncodeUInt32Value(value.preferredGopFrameCount); - encoder->EncodeUInt32Value(value.preferredIdrPeriod); - encoder->EncodeUInt32Value(value.preferredConsecutiveBFrameCount); - encoder->EncodeUInt32Value(value.preferredTemporalLayerCount); - EncodeStruct(encoder, value.preferredConstantQp); - encoder->EncodeUInt32Value(value.preferredMaxL0ReferenceCount); - encoder->EncodeUInt32Value(value.preferredMaxL1ReferenceCount); - encoder->EncodeVkBool32Value(value.preferredStdEntropyCodingModeFlag); + encoder->EncodeFlagsValue(value.cooperativeMatrixSupportedStages); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionCreateInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVideoMaintenance1FeaturesKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.useMaxLevelIdc); - encoder->EncodeEnumValue(value.maxLevelIdc); + encoder->EncodeVkBool32Value(value.videoMaintenance1); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersAddInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkVideoInlineQueryInfoKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.stdSPSCount); - EncodeStructArray(encoder, value.pStdSPSs, value.stdSPSCount); - encoder->EncodeUInt32Value(value.stdPPSCount); - EncodeStructArray(encoder, value.pStdPPSs, value.stdPPSCount); + encoder->EncodeHandleValue(value.queryPool); + encoder->EncodeUInt32Value(value.firstQuery); + encoder->EncodeUInt32Value(value.queryCount); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersCreateInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.maxStdSPSCount); - encoder->EncodeUInt32Value(value.maxStdPPSCount); - EncodeStructPtr(encoder, value.pParametersAddInfo); + encoder->EncodeUInt32Value(value.maxVertexAttribDivisor); + encoder->EncodeVkBool32Value(value.supportsNonZeroFirstInstance); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersGetInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkVertexInputBindingDivisorDescriptionKHR& value) { - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.writeStdSPS); - encoder->EncodeVkBool32Value(value.writeStdPPS); - encoder->EncodeUInt32Value(value.stdSPSId); - encoder->EncodeUInt32Value(value.stdPPSId); + encoder->EncodeUInt32Value(value.binding); + encoder->EncodeUInt32Value(value.divisor); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersFeedbackInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPipelineVertexInputDivisorStateCreateInfoKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.hasStdSPSOverrides); - encoder->EncodeVkBool32Value(value.hasStdPPSOverrides); + encoder->EncodeUInt32Value(value.vertexBindingDivisorCount); + EncodeStructArray(encoder, value.pVertexBindingDivisors, value.vertexBindingDivisorCount); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264NaluSliceInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeInt32Value(value.constantQp); - EncodeStructPtr(encoder, value.pStdSliceHeader); + encoder->EncodeVkBool32Value(value.vertexAttributeInstanceRateDivisor); + encoder->EncodeVkBool32Value(value.vertexAttributeInstanceRateZeroDivisor); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264PictureInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkCalibratedTimestampInfoKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.naluSliceEntryCount); - EncodeStructArray(encoder, value.pNaluSliceEntries, value.naluSliceEntryCount); - EncodeStructPtr(encoder, value.pStdPictureInfo); - encoder->EncodeVkBool32Value(value.generatePrefixNalu); + encoder->EncodeEnumValue(value.timeDomain); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264DpbSlotInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceMaintenance6FeaturesKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - EncodeStructPtr(encoder, value.pStdReferenceInfo); + encoder->EncodeVkBool32Value(value.maintenance6); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264ProfileInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceMaintenance6PropertiesKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeEnumValue(value.stdProfileIdc); + encoder->EncodeVkBool32Value(value.blockTexelViewCompatibleMultipleLayers); + encoder->EncodeUInt32Value(value.maxCombinedImageSamplerDescriptorCount); + encoder->EncodeVkBool32Value(value.fragmentShadingRateClampCombinerInputs); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264RateControlInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkBindMemoryStatusKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeFlagsValue(value.flags); - encoder->EncodeUInt32Value(value.gopFrameCount); - encoder->EncodeUInt32Value(value.idrPeriod); - encoder->EncodeUInt32Value(value.consecutiveBFrameCount); - encoder->EncodeUInt32Value(value.temporalLayerCount); + encoder->EncodeEnumPtr(value.pResult); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264FrameSizeEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkBindDescriptorSetsInfoKHR& value) { - encoder->EncodeUInt32Value(value.frameISize); - encoder->EncodeUInt32Value(value.framePSize); - encoder->EncodeUInt32Value(value.frameBSize); + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.stageFlags); + encoder->EncodeHandleValue(value.layout); + encoder->EncodeUInt32Value(value.firstSet); + encoder->EncodeUInt32Value(value.descriptorSetCount); + encoder->EncodeHandleArray(value.pDescriptorSets, value.descriptorSetCount); + encoder->EncodeUInt32Value(value.dynamicOffsetCount); + encoder->EncodeUInt32Array(value.pDynamicOffsets, value.dynamicOffsetCount); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264RateControlLayerInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPushConstantsInfoKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.useMinQp); - EncodeStruct(encoder, value.minQp); - encoder->EncodeVkBool32Value(value.useMaxQp); - EncodeStruct(encoder, value.maxQp); - encoder->EncodeVkBool32Value(value.useMaxFrameSize); - EncodeStruct(encoder, value.maxFrameSize); + encoder->EncodeHandleValue(value.layout); + encoder->EncodeFlagsValue(value.stageFlags); + encoder->EncodeUInt32Value(value.offset); + encoder->EncodeUInt32Value(value.size); + encoder->EncodeVoidArray(value.pValues, value.size); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264GopRemainingFrameInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPushDescriptorSetInfoKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.useGopRemainingFrames); - encoder->EncodeUInt32Value(value.gopRemainingI); - encoder->EncodeUInt32Value(value.gopRemainingP); - encoder->EncodeUInt32Value(value.gopRemainingB); + encoder->EncodeFlagsValue(value.stageFlags); + encoder->EncodeHandleValue(value.layout); + encoder->EncodeUInt32Value(value.set); + encoder->EncodeUInt32Value(value.descriptorWriteCount); + EncodeStructArray(encoder, value.pDescriptorWrites, value.descriptorWriteCount); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265CapabilitiesEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPushDescriptorSetWithTemplateInfoKHR& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeFlagsValue(value.flags); - encoder->EncodeEnumValue(value.maxLevelIdc); - encoder->EncodeUInt32Value(value.maxSliceSegmentCount); - EncodeStruct(encoder, value.maxTiles); - encoder->EncodeFlagsValue(value.ctbSizes); - encoder->EncodeFlagsValue(value.transformBlockSizes); - encoder->EncodeUInt32Value(value.maxPPictureL0ReferenceCount); - encoder->EncodeUInt32Value(value.maxBPictureL0ReferenceCount); - encoder->EncodeUInt32Value(value.maxL1ReferenceCount); - encoder->EncodeUInt32Value(value.maxSubLayerCount); - encoder->EncodeVkBool32Value(value.expectDyadicTemporalSubLayerPattern); - encoder->EncodeInt32Value(value.minQp); - encoder->EncodeInt32Value(value.maxQp); - encoder->EncodeVkBool32Value(value.prefersGopRemainingFrames); - encoder->EncodeVkBool32Value(value.requiresGopRemainingFrames); - encoder->EncodeFlagsValue(value.stdSyntaxFlags); + encoder->EncodeHandleValue(value.descriptorUpdateTemplate); + encoder->EncodeHandleValue(value.layout); + encoder->EncodeUInt32Value(value.set); + encoder->EncodeVoidPtr(value.pData); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionCreateInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkSetDescriptorBufferOffsetsInfoEXT& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.useMaxLevelIdc); - encoder->EncodeEnumValue(value.maxLevelIdc); + encoder->EncodeFlagsValue(value.stageFlags); + encoder->EncodeHandleValue(value.layout); + encoder->EncodeUInt32Value(value.firstSet); + encoder->EncodeUInt32Value(value.setCount); + encoder->EncodeUInt32Array(value.pBufferIndices, value.setCount); + encoder->EncodeVkDeviceSizeArray(value.pOffsets, value.setCount); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265QpEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT& value) { - encoder->EncodeInt32Value(value.qpI); - encoder->EncodeInt32Value(value.qpP); - encoder->EncodeInt32Value(value.qpB); + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.stageFlags); + encoder->EncodeHandleValue(value.layout); + encoder->EncodeUInt32Value(value.set); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265QualityLevelPropertiesEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkDebugReportCallbackCreateInfoEXT& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeFlagsValue(value.preferredRateControlFlags); - encoder->EncodeUInt32Value(value.preferredGopFrameCount); - encoder->EncodeUInt32Value(value.preferredIdrPeriod); - encoder->EncodeUInt32Value(value.preferredConsecutiveBFrameCount); - encoder->EncodeUInt32Value(value.preferredSubLayerCount); - EncodeStruct(encoder, value.preferredConstantQp); - encoder->EncodeUInt32Value(value.preferredMaxL0ReferenceCount); - encoder->EncodeUInt32Value(value.preferredMaxL1ReferenceCount); + encoder->EncodeFlagsValue(value.flags); + encoder->EncodeFunctionPtr(value.pfnCallback); + encoder->EncodeVoidPtr(value.pUserData); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersAddInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPipelineRasterizationStateRasterizationOrderAMD& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.stdVPSCount); - EncodeStructArray(encoder, value.pStdVPSs, value.stdVPSCount); - encoder->EncodeUInt32Value(value.stdSPSCount); - EncodeStructArray(encoder, value.pStdSPSs, value.stdSPSCount); - encoder->EncodeUInt32Value(value.stdPPSCount); - EncodeStructArray(encoder, value.pStdPPSs, value.stdPPSCount); + encoder->EncodeEnumValue(value.rasterizationOrder); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersCreateInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkDebugMarkerObjectNameInfoEXT& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.maxStdVPSCount); - encoder->EncodeUInt32Value(value.maxStdSPSCount); - encoder->EncodeUInt32Value(value.maxStdPPSCount); - EncodeStructPtr(encoder, value.pParametersAddInfo); + encoder->EncodeEnumValue(value.objectType); + encoder->EncodeUInt64Value(GetWrappedId(value.object, value.objectType)); + encoder->EncodeString(value.pObjectName); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersGetInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkDebugMarkerObjectTagInfoEXT& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.writeStdVPS); - encoder->EncodeVkBool32Value(value.writeStdSPS); - encoder->EncodeVkBool32Value(value.writeStdPPS); - encoder->EncodeUInt32Value(value.stdVPSId); - encoder->EncodeUInt32Value(value.stdSPSId); - encoder->EncodeUInt32Value(value.stdPPSId); + encoder->EncodeEnumValue(value.objectType); + encoder->EncodeUInt64Value(GetWrappedId(value.object, value.objectType)); + encoder->EncodeUInt64Value(value.tagName); + encoder->EncodeSizeTValue(value.tagSize); + encoder->EncodeVoidArray(value.pTag, value.tagSize); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersFeedbackInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkDebugMarkerMarkerInfoEXT& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.hasStdVPSOverrides); - encoder->EncodeVkBool32Value(value.hasStdSPSOverrides); - encoder->EncodeVkBool32Value(value.hasStdPPSOverrides); + encoder->EncodeString(value.pMarkerName); + encoder->EncodeFloatArray(value.color, 4); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265NaluSliceSegmentInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkDedicatedAllocationImageCreateInfoNV& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeInt32Value(value.constantQp); - EncodeStructPtr(encoder, value.pStdSliceSegmentHeader); + encoder->EncodeVkBool32Value(value.dedicatedAllocation); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265PictureInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkDedicatedAllocationBufferCreateInfoNV& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.naluSliceSegmentEntryCount); - EncodeStructArray(encoder, value.pNaluSliceSegmentEntries, value.naluSliceSegmentEntryCount); - EncodeStructPtr(encoder, value.pStdPictureInfo); + encoder->EncodeVkBool32Value(value.dedicatedAllocation); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265DpbSlotInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkDedicatedAllocationMemoryAllocateInfoNV& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - EncodeStructPtr(encoder, value.pStdReferenceInfo); + encoder->EncodeHandleValue(value.image); + encoder->EncodeHandleValue(value.buffer); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265ProfileInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceTransformFeedbackFeaturesEXT& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeEnumValue(value.stdProfileIdc); + encoder->EncodeVkBool32Value(value.transformFeedback); + encoder->EncodeVkBool32Value(value.geometryStreams); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265RateControlInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceTransformFeedbackPropertiesEXT& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeFlagsValue(value.flags); - encoder->EncodeUInt32Value(value.gopFrameCount); - encoder->EncodeUInt32Value(value.idrPeriod); - encoder->EncodeUInt32Value(value.consecutiveBFrameCount); - encoder->EncodeUInt32Value(value.subLayerCount); + encoder->EncodeUInt32Value(value.maxTransformFeedbackStreams); + encoder->EncodeUInt32Value(value.maxTransformFeedbackBuffers); + encoder->EncodeVkDeviceSizeValue(value.maxTransformFeedbackBufferSize); + encoder->EncodeUInt32Value(value.maxTransformFeedbackStreamDataSize); + encoder->EncodeUInt32Value(value.maxTransformFeedbackBufferDataSize); + encoder->EncodeUInt32Value(value.maxTransformFeedbackBufferDataStride); + encoder->EncodeVkBool32Value(value.transformFeedbackQueries); + encoder->EncodeVkBool32Value(value.transformFeedbackStreamsLinesTriangles); + encoder->EncodeVkBool32Value(value.transformFeedbackRasterizationStreamSelect); + encoder->EncodeVkBool32Value(value.transformFeedbackDraw); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265FrameSizeEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkPipelineRasterizationStateStreamCreateInfoEXT& value) { - encoder->EncodeUInt32Value(value.frameISize); - encoder->EncodeUInt32Value(value.framePSize); - encoder->EncodeUInt32Value(value.frameBSize); + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.flags); + encoder->EncodeUInt32Value(value.rasterizationStream); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265RateControlLayerInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkImageViewHandleInfoNVX& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.useMinQp); - EncodeStruct(encoder, value.minQp); - encoder->EncodeVkBool32Value(value.useMaxQp); - EncodeStruct(encoder, value.maxQp); - encoder->EncodeVkBool32Value(value.useMaxFrameSize); - EncodeStruct(encoder, value.maxFrameSize); + encoder->EncodeHandleValue(value.imageView); + encoder->EncodeEnumValue(value.descriptorType); + encoder->EncodeHandleValue(value.sampler); } -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265GopRemainingFrameInfoEXT& value) +void EncodeStruct(ParameterEncoder* encoder, const VkImageViewAddressPropertiesNVX& value) { encoder->EncodeEnumValue(value.sType); EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.useGopRemainingFrames); - encoder->EncodeUInt32Value(value.gopRemainingI); - encoder->EncodeUInt32Value(value.gopRemainingP); - encoder->EncodeUInt32Value(value.gopRemainingB); + encoder->EncodeVkDeviceAddressValue(value.deviceAddress); + encoder->EncodeVkDeviceSizeValue(value.size); } void EncodeStruct(ParameterEncoder* encoder, const VkTextureLODGatherFormatPropertiesAMD& value) @@ -9009,6 +9114,14 @@ void EncodeStruct(ParameterEncoder* encoder, const VkMultiviewPerViewRenderAreas EncodeStructArray(encoder, value.pPerViewRenderAreas, value.perViewRenderAreaCount); } +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDevicePerStageDescriptorSetFeaturesNV& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.perStageDescriptorSet); + encoder->EncodeVkBool32Value(value.dynamicPipelineLayout); +} + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceImageProcessing2FeaturesQCOM& value) { encoder->EncodeEnumValue(value.sType); diff --git a/framework/generated/generated_vulkan_struct_encoders.h b/framework/generated/generated_vulkan_struct_encoders.h index dcb1bffcf..108bf7d3d 100644 --- a/framework/generated/generated_vulkan_struct_encoders.h +++ b/framework/generated/generated_vulkan_struct_encoders.h @@ -441,6 +441,40 @@ void EncodeStruct(ParameterEncoder* encoder, const VkVideoDecodeCapabilitiesKHR& void EncodeStruct(ParameterEncoder* encoder, const VkVideoDecodeUsageInfoKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkVideoDecodeInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264CapabilitiesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264QpKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264QualityLevelPropertiesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionCreateInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersAddInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersCreateInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersGetInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersFeedbackInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264NaluSliceInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264PictureInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264DpbSlotInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264ProfileInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264RateControlInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264FrameSizeKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264RateControlLayerInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264GopRemainingFrameInfoKHR& value); + +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265CapabilitiesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionCreateInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265QpKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265QualityLevelPropertiesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersAddInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersCreateInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersGetInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersFeedbackInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265NaluSliceSegmentInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265PictureInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265DpbSlotInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265ProfileInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265RateControlInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265FrameSizeKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265RateControlLayerInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265GopRemainingFrameInfoKHR& value); + void EncodeStruct(ParameterEncoder* encoder, const VkVideoDecodeH264ProfileInfoKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkVideoDecodeH264CapabilitiesKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkVideoDecodeH264SessionParametersAddInfoKHR& value); @@ -586,6 +620,9 @@ void EncodeStruct(ParameterEncoder* encoder, const VkCooperativeMatrixProperties void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVideoMaintenance1FeaturesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVideoInlineQueryInfoKHR& value); + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkVertexInputBindingDivisorDescriptionKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkPipelineVertexInputDivisorStateCreateInfoKHR& value); @@ -593,6 +630,16 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttribu void EncodeStruct(ParameterEncoder* encoder, const VkCalibratedTimestampInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceMaintenance6FeaturesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceMaintenance6PropertiesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkBindMemoryStatusKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkBindDescriptorSetsInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPushConstantsInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPushDescriptorSetInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPushDescriptorSetWithTemplateInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkSetDescriptorBufferOffsetsInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT& value); + void EncodeStruct(ParameterEncoder* encoder, const VkDebugReportCallbackCreateInfoEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkPipelineRasterizationStateRasterizationOrderAMD& value); @@ -612,40 +659,6 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPipelineRasterizationStateS void EncodeStruct(ParameterEncoder* encoder, const VkImageViewHandleInfoNVX& value); void EncodeStruct(ParameterEncoder* encoder, const VkImageViewAddressPropertiesNVX& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264CapabilitiesEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264QpEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264QualityLevelPropertiesEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionCreateInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersAddInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersCreateInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersGetInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264SessionParametersFeedbackInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264NaluSliceInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264PictureInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264DpbSlotInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264ProfileInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264RateControlInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264FrameSizeEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264RateControlLayerInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH264GopRemainingFrameInfoEXT& value); - -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265CapabilitiesEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionCreateInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265QpEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265QualityLevelPropertiesEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersAddInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersCreateInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersGetInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265SessionParametersFeedbackInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265NaluSliceSegmentInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265PictureInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265DpbSlotInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265ProfileInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265RateControlInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265FrameSizeEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265RateControlLayerInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVideoEncodeH265GopRemainingFrameInfoEXT& value); - void EncodeStruct(ParameterEncoder* encoder, const VkTextureLODGatherFormatPropertiesAMD& value); void EncodeStruct(ParameterEncoder* encoder, const VkShaderResourceUsageAMD& value); @@ -1206,6 +1219,8 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceDynamicRender void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM& value); void EncodeStruct(ParameterEncoder* encoder, const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDevicePerStageDescriptorSetFeaturesNV& value); + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceImageProcessing2FeaturesQCOM& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceImageProcessing2PropertiesQCOM& value); void EncodeStruct(ParameterEncoder* encoder, const VkSamplerBlockMatchWindowCreateInfoQCOM& value); diff --git a/framework/generated/generated_vulkan_struct_handle_mappers.cpp b/framework/generated/generated_vulkan_struct_handle_mappers.cpp index d7192a8dd..96222c88f 100644 --- a/framework/generated/generated_vulkan_struct_handle_mappers.cpp +++ b/framework/generated/generated_vulkan_struct_handle_mappers.cpp @@ -918,6 +918,11 @@ void MapStructHandles(Decoded_VkVideoDecodeInfoKHR* wrapper, const VulkanObjectI { VkVideoDecodeInfoKHR* value = wrapper->decoded_value; + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + value->srcBuffer = handle_mapping::MapHandle(wrapper->srcBuffer, object_info_table, &VulkanObjectInfoTable::GetBufferInfo); MapStructHandles(wrapper->dstPictureResource, object_info_table); @@ -1160,6 +1165,11 @@ void MapStructHandles(Decoded_VkVideoEncodeInfoKHR* wrapper, const VulkanObjectI { VkVideoEncodeInfoKHR* value = wrapper->decoded_value; + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + value->dstBuffer = handle_mapping::MapHandle(wrapper->dstBuffer, object_info_table, &VulkanObjectInfoTable::GetBufferInfo); MapStructHandles(wrapper->srcPictureResource, object_info_table); @@ -1188,6 +1198,112 @@ void MapStructHandles(Decoded_VkDeviceImageSubresourceInfoKHR* wrapper, const Vu } } +void MapStructHandles(Decoded_VkVideoInlineQueryInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkVideoInlineQueryInfoKHR* value = wrapper->decoded_value; + + value->queryPool = handle_mapping::MapHandle(wrapper->queryPool, object_info_table, &VulkanObjectInfoTable::GetQueryPoolInfo); + } +} + +void MapStructHandles(Decoded_VkBindDescriptorSetsInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkBindDescriptorSetsInfoKHR* value = wrapper->decoded_value; + + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + + value->layout = handle_mapping::MapHandle(wrapper->layout, object_info_table, &VulkanObjectInfoTable::GetPipelineLayoutInfo); + + value->pDescriptorSets = handle_mapping::MapHandleArray(&wrapper->pDescriptorSets, object_info_table, &VulkanObjectInfoTable::GetDescriptorSetInfo); + } +} + +void MapStructHandles(Decoded_VkPushConstantsInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkPushConstantsInfoKHR* value = wrapper->decoded_value; + + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + + value->layout = handle_mapping::MapHandle(wrapper->layout, object_info_table, &VulkanObjectInfoTable::GetPipelineLayoutInfo); + } +} + +void MapStructHandles(Decoded_VkPushDescriptorSetInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkPushDescriptorSetInfoKHR* value = wrapper->decoded_value; + + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + + value->layout = handle_mapping::MapHandle(wrapper->layout, object_info_table, &VulkanObjectInfoTable::GetPipelineLayoutInfo); + + MapStructArrayHandles(wrapper->pDescriptorWrites->GetMetaStructPointer(), wrapper->pDescriptorWrites->GetLength(), object_info_table); + } +} + +void MapStructHandles(Decoded_VkPushDescriptorSetWithTemplateInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkPushDescriptorSetWithTemplateInfoKHR* value = wrapper->decoded_value; + + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + + value->descriptorUpdateTemplate = handle_mapping::MapHandle(wrapper->descriptorUpdateTemplate, object_info_table, &VulkanObjectInfoTable::GetDescriptorUpdateTemplateInfo); + + value->layout = handle_mapping::MapHandle(wrapper->layout, object_info_table, &VulkanObjectInfoTable::GetPipelineLayoutInfo); + } +} + +void MapStructHandles(Decoded_VkSetDescriptorBufferOffsetsInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkSetDescriptorBufferOffsetsInfoEXT* value = wrapper->decoded_value; + + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + + value->layout = handle_mapping::MapHandle(wrapper->layout, object_info_table, &VulkanObjectInfoTable::GetPipelineLayoutInfo); + } +} + +void MapStructHandles(Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkBindDescriptorBufferEmbeddedSamplersInfoEXT* value = wrapper->decoded_value; + + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + + value->layout = handle_mapping::MapHandle(wrapper->layout, object_info_table, &VulkanObjectInfoTable::GetPipelineLayoutInfo); + } +} + void MapStructHandles(Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) { if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) @@ -1817,6 +1933,9 @@ void MapPNextStructHandles(const void* value, void* wrapper, const VulkanObjectI case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: MapStructHandles(reinterpret_cast(wrapper), object_info_table); break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + MapStructHandles(reinterpret_cast(wrapper), object_info_table); + break; case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: MapStructHandles(reinterpret_cast(wrapper), object_info_table); break; @@ -1847,6 +1966,9 @@ void MapPNextStructHandles(const void* value, void* wrapper, const VulkanObjectI case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: MapStructHandles(reinterpret_cast(wrapper), object_info_table); break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + MapStructHandles(reinterpret_cast(wrapper), object_info_table); + break; case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: MapStructHandles(reinterpret_cast(wrapper), object_info_table); break; diff --git a/framework/generated/generated_vulkan_struct_handle_mappers.h b/framework/generated/generated_vulkan_struct_handle_mappers.h index f2c5378b8..144e50bbb 100644 --- a/framework/generated/generated_vulkan_struct_handle_mappers.h +++ b/framework/generated/generated_vulkan_struct_handle_mappers.h @@ -32,6 +32,7 @@ #include "decode/pnext_node.h" #include "decode/vulkan_object_info_table.h" #include "format/platform_types.h" +#include "decode/custom_vulkan_struct_handle_mappers.h" #include "generated/generated_vulkan_struct_decoders_forward.h" #include "util/defines.h" @@ -251,6 +252,20 @@ void MapStructHandles(Decoded_VkVideoEncodeSessionParametersGetInfoKHR* wrapper, void MapStructHandles(Decoded_VkDeviceImageSubresourceInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table); +void MapStructHandles(Decoded_VkVideoInlineQueryInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkBindDescriptorSetsInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkPushConstantsInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkPushDescriptorSetInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkPushDescriptorSetWithTemplateInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkSetDescriptorBufferOffsetsInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + void MapStructHandles(Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); void MapStructHandles(Decoded_VkDebugMarkerObjectTagInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); diff --git a/framework/generated/generated_vulkan_struct_handle_wrappers.cpp b/framework/generated/generated_vulkan_struct_handle_wrappers.cpp index aa0cbecc9..ff7262984 100644 --- a/framework/generated/generated_vulkan_struct_handle_wrappers.cpp +++ b/framework/generated/generated_vulkan_struct_handle_wrappers.cpp @@ -643,6 +643,10 @@ void UnwrapStructHandles(VkVideoDecodeInfoKHR* value, HandleUnwrapMemory* unwrap { if (value != nullptr) { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } UnwrapStructHandles(&value->dstPictureResource, unwrap_memory); value->pSetupReferenceSlot = UnwrapStructPtrHandles(value->pSetupReferenceSlot, unwrap_memory); value->pReferenceSlots = UnwrapStructArrayHandles(value->pReferenceSlots, value->referenceSlotCount, unwrap_memory); @@ -817,6 +821,10 @@ void UnwrapStructHandles(VkVideoEncodeInfoKHR* value, HandleUnwrapMemory* unwrap { if (value != nullptr) { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } UnwrapStructHandles(&value->srcPictureResource, unwrap_memory); value->pSetupReferenceSlot = UnwrapStructPtrHandles(value->pSetupReferenceSlot, unwrap_memory); value->pReferenceSlots = UnwrapStructArrayHandles(value->pReferenceSlots, value->referenceSlotCount, unwrap_memory); @@ -838,6 +846,80 @@ void UnwrapStructHandles(VkDeviceImageSubresourceInfoKHR* value, HandleUnwrapMem } } +void UnwrapStructHandles(VkVideoInlineQueryInfoKHR* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + } +} + +void UnwrapStructHandles(VkBindDescriptorSetsInfoKHR* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } + } +} + +void UnwrapStructHandles(VkPushConstantsInfoKHR* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } + } +} + +void UnwrapStructHandles(VkPushDescriptorSetInfoKHR* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } + value->pDescriptorWrites = UnwrapStructArrayHandles(value->pDescriptorWrites, value->descriptorWriteCount, unwrap_memory); + } +} + +void UnwrapStructHandles(VkPushDescriptorSetWithTemplateInfoKHR* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } + } +} + +void UnwrapStructHandles(VkSetDescriptorBufferOffsetsInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } + } +} + +void UnwrapStructHandles(VkBindDescriptorBufferEmbeddedSamplersInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } + } +} + void UnwrapStructHandles(VkDebugMarkerObjectNameInfoEXT* value, HandleUnwrapMemory* unwrap_memory) { if (value != nullptr) @@ -1280,6 +1362,9 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -1631,6 +1716,84 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -1823,6 +1986,12 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -1832,6 +2001,15 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -1856,84 +2034,6 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -2744,6 +2844,9 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -2829,6 +2932,8 @@ const void* UnwrapPNextStructHandles(const void* value, HandleUnwrapMemory* unwr } case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: @@ -2849,6 +2954,8 @@ const void* UnwrapPNextStructHandles(const void* value, HandleUnwrapMemory* unwr return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: diff --git a/framework/generated/generated_vulkan_struct_handle_wrappers.h b/framework/generated/generated_vulkan_struct_handle_wrappers.h index 6434d8fcf..0f4246f31 100644 --- a/framework/generated/generated_vulkan_struct_handle_wrappers.h +++ b/framework/generated/generated_vulkan_struct_handle_wrappers.h @@ -251,6 +251,20 @@ void UnwrapStructHandles(VkVideoEncodeSessionParametersGetInfoKHR* value, Handle void UnwrapStructHandles(VkDeviceImageSubresourceInfoKHR* value, HandleUnwrapMemory* unwrap_memory); +void UnwrapStructHandles(VkVideoInlineQueryInfoKHR* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkBindDescriptorSetsInfoKHR* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkPushConstantsInfoKHR* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkPushDescriptorSetInfoKHR* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkPushDescriptorSetWithTemplateInfoKHR* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkSetDescriptorBufferOffsetsInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkBindDescriptorBufferEmbeddedSamplersInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + void UnwrapStructHandles(VkDebugMarkerObjectNameInfoEXT* value, HandleUnwrapMemory* unwrap_memory); void UnwrapStructHandles(VkDebugMarkerObjectTagInfoEXT* value, HandleUnwrapMemory* unwrap_memory); diff --git a/framework/generated/generated_vulkan_struct_to_json.cpp b/framework/generated/generated_vulkan_struct_to_json.cpp index ffab7e954..dc5df2721 100644 --- a/framework/generated/generated_vulkan_struct_to_json.cpp +++ b/framework/generated/generated_vulkan_struct_to_json.cpp @@ -6377,40 +6377,85 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeInfoK } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264ProfileInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264CapabilitiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH264ProfileInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH264ProfileInfoKHR& meta_struct = *data; + const VkVideoEncodeH264CapabilitiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264CapabilitiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["stdProfileIdc"], decoded_value.stdProfileIdc, options); - FieldToJson(jdata["pictureLayout"], decoded_value.pictureLayout, options); + FieldToJson(VkVideoEncodeH264CapabilityFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); + FieldToJson(jdata["maxSliceCount"], decoded_value.maxSliceCount, options); + FieldToJson(jdata["maxPPictureL0ReferenceCount"], decoded_value.maxPPictureL0ReferenceCount, options); + FieldToJson(jdata["maxBPictureL0ReferenceCount"], decoded_value.maxBPictureL0ReferenceCount, options); + FieldToJson(jdata["maxL1ReferenceCount"], decoded_value.maxL1ReferenceCount, options); + FieldToJson(jdata["maxTemporalLayerCount"], decoded_value.maxTemporalLayerCount, options); + jdata["expectDyadicTemporalLayerPattern"] = static_cast(decoded_value.expectDyadicTemporalLayerPattern); + FieldToJson(jdata["minQp"], decoded_value.minQp, options); + FieldToJson(jdata["maxQp"], decoded_value.maxQp, options); + jdata["prefersGopRemainingFrames"] = static_cast(decoded_value.prefersGopRemainingFrames); + jdata["requiresGopRemainingFrames"] = static_cast(decoded_value.requiresGopRemainingFrames); + FieldToJson(VkVideoEncodeH264StdFlagsKHR_t(),jdata["stdSyntaxFlags"], decoded_value.stdSyntaxFlags, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264CapabilitiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264QpKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH264CapabilitiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH264CapabilitiesKHR& meta_struct = *data; + const VkVideoEncodeH264QpKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264QpKHR& meta_struct = *data; + + FieldToJson(jdata["qpI"], decoded_value.qpI, options); + FieldToJson(jdata["qpP"], decoded_value.qpP, options); + FieldToJson(jdata["qpB"], decoded_value.qpB, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264QualityLevelPropertiesKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkVideoEncodeH264QualityLevelPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264QualityLevelPropertiesKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkVideoEncodeH264RateControlFlagsKHR_t(),jdata["preferredRateControlFlags"], decoded_value.preferredRateControlFlags, options); + FieldToJson(jdata["preferredGopFrameCount"], decoded_value.preferredGopFrameCount, options); + FieldToJson(jdata["preferredIdrPeriod"], decoded_value.preferredIdrPeriod, options); + FieldToJson(jdata["preferredConsecutiveBFrameCount"], decoded_value.preferredConsecutiveBFrameCount, options); + FieldToJson(jdata["preferredTemporalLayerCount"], decoded_value.preferredTemporalLayerCount, options); + FieldToJson(jdata["preferredConstantQp"], meta_struct.preferredConstantQp, options); + FieldToJson(jdata["preferredMaxL0ReferenceCount"], decoded_value.preferredMaxL0ReferenceCount, options); + FieldToJson(jdata["preferredMaxL1ReferenceCount"], decoded_value.preferredMaxL1ReferenceCount, options); + jdata["preferredStdEntropyCodingModeFlag"] = static_cast(decoded_value.preferredStdEntropyCodingModeFlag); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionCreateInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkVideoEncodeH264SessionCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264SessionCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["useMaxLevelIdc"] = static_cast(decoded_value.useMaxLevelIdc); FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); - FieldToJson(jdata["fieldOffsetGranularity"], meta_struct.fieldOffsetGranularity, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersAddInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH264SessionParametersAddInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR& meta_struct = *data; + const VkVideoEncodeH264SessionParametersAddInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264SessionParametersAddInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); FieldToJson(jdata["stdSPSCount"], decoded_value.stdSPSCount, options); @@ -6421,12 +6466,12 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264S } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264SessionParametersCreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH264SessionParametersCreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH264SessionParametersCreateInfoKHR& meta_struct = *data; + const VkVideoEncodeH264SessionParametersCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); FieldToJson(jdata["maxStdSPSCount"], decoded_value.maxStdSPSCount, options); @@ -6436,2321 +6481,2447 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264S } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264PictureInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersGetInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH264PictureInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH264PictureInfoKHR& meta_struct = *data; + const VkVideoEncodeH264SessionParametersGetInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264SessionParametersGetInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pStdPictureInfo"], meta_struct.pStdPictureInfo, options); - FieldToJson(jdata["sliceCount"], decoded_value.sliceCount, options); - FieldToJson(jdata["pSliceOffsets"], meta_struct.pSliceOffsets, options); + jdata["writeStdSPS"] = static_cast(decoded_value.writeStdSPS); + jdata["writeStdPPS"] = static_cast(decoded_value.writeStdPPS); + FieldToJson(jdata["stdSPSId"], decoded_value.stdSPSId, options); + FieldToJson(jdata["stdPPSId"], decoded_value.stdPPSId, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264DpbSlotInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH264DpbSlotInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH264DpbSlotInfoKHR& meta_struct = *data; + const VkVideoEncodeH264SessionParametersFeedbackInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pStdReferenceInfo"], meta_struct.pStdReferenceInfo, options); + jdata["hasStdSPSOverrides"] = static_cast(decoded_value.hasStdSPSOverrides); + jdata["hasStdPPSOverrides"] = static_cast(decoded_value.hasStdPPSOverrides); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderingFragmentShadingRateAttachmentInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264NaluSliceInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkRenderingFragmentShadingRateAttachmentInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkRenderingFragmentShadingRateAttachmentInfoKHR& meta_struct = *data; + const VkVideoEncodeH264NaluSliceInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264NaluSliceInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["imageView"], meta_struct.imageView, options); - FieldToJson(jdata["imageLayout"], decoded_value.imageLayout, options); - FieldToJson(jdata["shadingRateAttachmentTexelSize"], meta_struct.shadingRateAttachmentTexelSize, options); + FieldToJson(jdata["constantQp"], decoded_value.constantQp, options); + FieldToJson(jdata["pStdSliceHeader"], meta_struct.pStdSliceHeader, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderingFragmentDensityMapAttachmentInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264PictureInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkRenderingFragmentDensityMapAttachmentInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkRenderingFragmentDensityMapAttachmentInfoEXT& meta_struct = *data; + const VkVideoEncodeH264PictureInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264PictureInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["imageView"], meta_struct.imageView, options); - FieldToJson(jdata["imageLayout"], decoded_value.imageLayout, options); + FieldToJson(jdata["naluSliceEntryCount"], decoded_value.naluSliceEntryCount, options); + FieldToJson(jdata["pNaluSliceEntries"], meta_struct.pNaluSliceEntries, options); + FieldToJson(jdata["pStdPictureInfo"], meta_struct.pStdPictureInfo, options); + jdata["generatePrefixNalu"] = static_cast(decoded_value.generatePrefixNalu); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAttachmentSampleCountInfoAMD* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264DpbSlotInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkAttachmentSampleCountInfoAMD& decoded_value = *data->decoded_value; - const Decoded_VkAttachmentSampleCountInfoAMD& meta_struct = *data; + const VkVideoEncodeH264DpbSlotInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264DpbSlotInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["colorAttachmentCount"], decoded_value.colorAttachmentCount, options); - FieldToJson(jdata["pColorAttachmentSamples"], meta_struct.pColorAttachmentSamples, options); - FieldToJson(jdata["depthStencilAttachmentSamples"], decoded_value.depthStencilAttachmentSamples, options); + FieldToJson(jdata["pStdReferenceInfo"], meta_struct.pStdReferenceInfo, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMultiviewPerViewAttributesInfoNVX* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264ProfileInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkMultiviewPerViewAttributesInfoNVX& decoded_value = *data->decoded_value; - const Decoded_VkMultiviewPerViewAttributesInfoNVX& meta_struct = *data; + const VkVideoEncodeH264ProfileInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264ProfileInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["perViewAttributes"] = static_cast(decoded_value.perViewAttributes); - jdata["perViewAttributesPositionXOnly"] = static_cast(decoded_value.perViewAttributesPositionXOnly); + FieldToJson(jdata["stdProfileIdc"], decoded_value.stdProfileIdc, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportMemoryWin32HandleInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264RateControlInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkImportMemoryWin32HandleInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkImportMemoryWin32HandleInfoKHR& meta_struct = *data; + const VkVideoEncodeH264RateControlInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264RateControlInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); - FieldToJson(jdata["handle"], meta_struct.handle, options); - FieldToJson(jdata["name"], &meta_struct.name, options); + FieldToJson(VkVideoEncodeH264RateControlFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["gopFrameCount"], decoded_value.gopFrameCount, options); + FieldToJson(jdata["idrPeriod"], decoded_value.idrPeriod, options); + FieldToJson(jdata["consecutiveBFrameCount"], decoded_value.consecutiveBFrameCount, options); + FieldToJson(jdata["temporalLayerCount"], decoded_value.temporalLayerCount, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkExportMemoryWin32HandleInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264FrameSizeKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkExportMemoryWin32HandleInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkExportMemoryWin32HandleInfoKHR& meta_struct = *data; + const VkVideoEncodeH264FrameSizeKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264FrameSizeKHR& meta_struct = *data; - FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pAttributes"], meta_struct.pAttributes, options); - FieldToJson(jdata["dwAccess"], decoded_value.dwAccess, options); - FieldToJson(jdata["name"], &meta_struct.name, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); + FieldToJson(jdata["frameISize"], decoded_value.frameISize, options); + FieldToJson(jdata["framePSize"], decoded_value.framePSize, options); + FieldToJson(jdata["frameBSize"], decoded_value.frameBSize, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryWin32HandlePropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264RateControlLayerInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkMemoryWin32HandlePropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkMemoryWin32HandlePropertiesKHR& meta_struct = *data; + const VkVideoEncodeH264RateControlLayerInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264RateControlLayerInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["memoryTypeBits"], decoded_value.memoryTypeBits, options); + jdata["useMinQp"] = static_cast(decoded_value.useMinQp); + FieldToJson(jdata["minQp"], meta_struct.minQp, options); + jdata["useMaxQp"] = static_cast(decoded_value.useMaxQp); + FieldToJson(jdata["maxQp"], meta_struct.maxQp, options); + jdata["useMaxFrameSize"] = static_cast(decoded_value.useMaxFrameSize); + FieldToJson(jdata["maxFrameSize"], meta_struct.maxFrameSize, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryGetWin32HandleInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264GopRemainingFrameInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkMemoryGetWin32HandleInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkMemoryGetWin32HandleInfoKHR& meta_struct = *data; + const VkVideoEncodeH264GopRemainingFrameInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH264GopRemainingFrameInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["memory"], meta_struct.memory, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); + jdata["useGopRemainingFrames"] = static_cast(decoded_value.useGopRemainingFrames); + FieldToJson(jdata["gopRemainingI"], decoded_value.gopRemainingI, options); + FieldToJson(jdata["gopRemainingP"], decoded_value.gopRemainingP, options); + FieldToJson(jdata["gopRemainingB"], decoded_value.gopRemainingB, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportMemoryFdInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265CapabilitiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkImportMemoryFdInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkImportMemoryFdInfoKHR& meta_struct = *data; + const VkVideoEncodeH265CapabilitiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265CapabilitiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); - FieldToJson(jdata["fd"], decoded_value.fd, options); + FieldToJson(VkVideoEncodeH265CapabilityFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); + FieldToJson(jdata["maxSliceSegmentCount"], decoded_value.maxSliceSegmentCount, options); + FieldToJson(jdata["maxTiles"], meta_struct.maxTiles, options); + FieldToJson(VkVideoEncodeH265CtbSizeFlagsKHR_t(),jdata["ctbSizes"], decoded_value.ctbSizes, options); + FieldToJson(VkVideoEncodeH265TransformBlockSizeFlagsKHR_t(),jdata["transformBlockSizes"], decoded_value.transformBlockSizes, options); + FieldToJson(jdata["maxPPictureL0ReferenceCount"], decoded_value.maxPPictureL0ReferenceCount, options); + FieldToJson(jdata["maxBPictureL0ReferenceCount"], decoded_value.maxBPictureL0ReferenceCount, options); + FieldToJson(jdata["maxL1ReferenceCount"], decoded_value.maxL1ReferenceCount, options); + FieldToJson(jdata["maxSubLayerCount"], decoded_value.maxSubLayerCount, options); + jdata["expectDyadicTemporalSubLayerPattern"] = static_cast(decoded_value.expectDyadicTemporalSubLayerPattern); + FieldToJson(jdata["minQp"], decoded_value.minQp, options); + FieldToJson(jdata["maxQp"], decoded_value.maxQp, options); + jdata["prefersGopRemainingFrames"] = static_cast(decoded_value.prefersGopRemainingFrames); + jdata["requiresGopRemainingFrames"] = static_cast(decoded_value.requiresGopRemainingFrames); + FieldToJson(VkVideoEncodeH265StdFlagsKHR_t(),jdata["stdSyntaxFlags"], decoded_value.stdSyntaxFlags, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryFdPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkMemoryFdPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkMemoryFdPropertiesKHR& meta_struct = *data; + const VkVideoEncodeH265SessionCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265SessionCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["memoryTypeBits"], decoded_value.memoryTypeBits, options); + jdata["useMaxLevelIdc"] = static_cast(decoded_value.useMaxLevelIdc); + FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryGetFdInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265QpKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkMemoryGetFdInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkMemoryGetFdInfoKHR& meta_struct = *data; + const VkVideoEncodeH265QpKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265QpKHR& meta_struct = *data; - FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["memory"], meta_struct.memory, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); + FieldToJson(jdata["qpI"], decoded_value.qpI, options); + FieldToJson(jdata["qpP"], decoded_value.qpP, options); + FieldToJson(jdata["qpB"], decoded_value.qpB, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkWin32KeyedMutexAcquireReleaseInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR& meta_struct = *data; + const VkVideoEncodeH265QualityLevelPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["acquireCount"], decoded_value.acquireCount, options); - HandleToJson(jdata["pAcquireSyncs"], &meta_struct.pAcquireSyncs, options); - FieldToJson(jdata["pAcquireKeys"], meta_struct.pAcquireKeys, options); - FieldToJson(jdata["pAcquireTimeouts"], meta_struct.pAcquireTimeouts, options); - FieldToJson(jdata["releaseCount"], decoded_value.releaseCount, options); - HandleToJson(jdata["pReleaseSyncs"], &meta_struct.pReleaseSyncs, options); - FieldToJson(jdata["pReleaseKeys"], meta_struct.pReleaseKeys, options); + FieldToJson(VkVideoEncodeH265RateControlFlagsKHR_t(),jdata["preferredRateControlFlags"], decoded_value.preferredRateControlFlags, options); + FieldToJson(jdata["preferredGopFrameCount"], decoded_value.preferredGopFrameCount, options); + FieldToJson(jdata["preferredIdrPeriod"], decoded_value.preferredIdrPeriod, options); + FieldToJson(jdata["preferredConsecutiveBFrameCount"], decoded_value.preferredConsecutiveBFrameCount, options); + FieldToJson(jdata["preferredSubLayerCount"], decoded_value.preferredSubLayerCount, options); + FieldToJson(jdata["preferredConstantQp"], meta_struct.preferredConstantQp, options); + FieldToJson(jdata["preferredMaxL0ReferenceCount"], decoded_value.preferredMaxL0ReferenceCount, options); + FieldToJson(jdata["preferredMaxL1ReferenceCount"], decoded_value.preferredMaxL1ReferenceCount, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportSemaphoreWin32HandleInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkImportSemaphoreWin32HandleInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkImportSemaphoreWin32HandleInfoKHR& meta_struct = *data; + const VkVideoEncodeH265SessionParametersAddInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["semaphore"], meta_struct.semaphore, options); - FieldToJson(VkSemaphoreImportFlags_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); - FieldToJson(jdata["handle"], meta_struct.handle, options); - FieldToJson(jdata["name"], &meta_struct.name, options); + FieldToJson(jdata["stdVPSCount"], decoded_value.stdVPSCount, options); + FieldToJson(jdata["pStdVPSs"], meta_struct.pStdVPSs, options); + FieldToJson(jdata["stdSPSCount"], decoded_value.stdSPSCount, options); + FieldToJson(jdata["pStdSPSs"], meta_struct.pStdSPSs, options); + FieldToJson(jdata["stdPPSCount"], decoded_value.stdPPSCount, options); + FieldToJson(jdata["pStdPPSs"], meta_struct.pStdPPSs, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkExportSemaphoreWin32HandleInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkExportSemaphoreWin32HandleInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkExportSemaphoreWin32HandleInfoKHR& meta_struct = *data; + const VkVideoEncodeH265SessionParametersCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pAttributes"], meta_struct.pAttributes, options); - FieldToJson(jdata["dwAccess"], decoded_value.dwAccess, options); - FieldToJson(jdata["name"], &meta_struct.name, options); + FieldToJson(jdata["maxStdVPSCount"], decoded_value.maxStdVPSCount, options); + FieldToJson(jdata["maxStdSPSCount"], decoded_value.maxStdSPSCount, options); + FieldToJson(jdata["maxStdPPSCount"], decoded_value.maxStdPPSCount, options); + FieldToJson(jdata["pParametersAddInfo"], meta_struct.pParametersAddInfo, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkD3D12FenceSubmitInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkD3D12FenceSubmitInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkD3D12FenceSubmitInfoKHR& meta_struct = *data; + const VkVideoEncodeH265SessionParametersGetInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["waitSemaphoreValuesCount"], decoded_value.waitSemaphoreValuesCount, options); - FieldToJson(jdata["pWaitSemaphoreValues"], meta_struct.pWaitSemaphoreValues, options); - FieldToJson(jdata["signalSemaphoreValuesCount"], decoded_value.signalSemaphoreValuesCount, options); - FieldToJson(jdata["pSignalSemaphoreValues"], meta_struct.pSignalSemaphoreValues, options); + jdata["writeStdVPS"] = static_cast(decoded_value.writeStdVPS); + jdata["writeStdSPS"] = static_cast(decoded_value.writeStdSPS); + jdata["writeStdPPS"] = static_cast(decoded_value.writeStdPPS); + FieldToJson(jdata["stdVPSId"], decoded_value.stdVPSId, options); + FieldToJson(jdata["stdSPSId"], decoded_value.stdSPSId, options); + FieldToJson(jdata["stdPPSId"], decoded_value.stdPPSId, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSemaphoreGetWin32HandleInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkSemaphoreGetWin32HandleInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkSemaphoreGetWin32HandleInfoKHR& meta_struct = *data; + const VkVideoEncodeH265SessionParametersFeedbackInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["semaphore"], meta_struct.semaphore, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); + jdata["hasStdVPSOverrides"] = static_cast(decoded_value.hasStdVPSOverrides); + jdata["hasStdSPSOverrides"] = static_cast(decoded_value.hasStdSPSOverrides); + jdata["hasStdPPSOverrides"] = static_cast(decoded_value.hasStdPPSOverrides); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportSemaphoreFdInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkImportSemaphoreFdInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkImportSemaphoreFdInfoKHR& meta_struct = *data; + const VkVideoEncodeH265NaluSliceSegmentInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["semaphore"], meta_struct.semaphore, options); - FieldToJson(VkSemaphoreImportFlags_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); - FieldToJson(jdata["fd"], decoded_value.fd, options); + FieldToJson(jdata["constantQp"], decoded_value.constantQp, options); + FieldToJson(jdata["pStdSliceSegmentHeader"], meta_struct.pStdSliceSegmentHeader, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSemaphoreGetFdInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265PictureInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkSemaphoreGetFdInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkSemaphoreGetFdInfoKHR& meta_struct = *data; + const VkVideoEncodeH265PictureInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265PictureInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["semaphore"], meta_struct.semaphore, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); + FieldToJson(jdata["naluSliceSegmentEntryCount"], decoded_value.naluSliceSegmentEntryCount, options); + FieldToJson(jdata["pNaluSliceSegmentEntries"], meta_struct.pNaluSliceSegmentEntries, options); + FieldToJson(jdata["pStdPictureInfo"], meta_struct.pStdPictureInfo, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265DpbSlotInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDevicePushDescriptorPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR& meta_struct = *data; + const VkVideoEncodeH265DpbSlotInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265DpbSlotInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["maxPushDescriptors"], decoded_value.maxPushDescriptors, options); + FieldToJson(jdata["pStdReferenceInfo"], meta_struct.pStdReferenceInfo, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRectLayerKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265ProfileInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkRectLayerKHR& decoded_value = *data->decoded_value; - const Decoded_VkRectLayerKHR& meta_struct = *data; + const VkVideoEncodeH265ProfileInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265ProfileInfoKHR& meta_struct = *data; - FieldToJson(jdata["offset"], meta_struct.offset, options); - FieldToJson(jdata["extent"], meta_struct.extent, options); - FieldToJson(jdata["layer"], decoded_value.layer, options); + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["stdProfileIdc"], decoded_value.stdProfileIdc, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPresentRegionKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265RateControlInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPresentRegionKHR& decoded_value = *data->decoded_value; - const Decoded_VkPresentRegionKHR& meta_struct = *data; + const VkVideoEncodeH265RateControlInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265RateControlInfoKHR& meta_struct = *data; - FieldToJson(jdata["rectangleCount"], decoded_value.rectangleCount, options); - FieldToJson(jdata["pRectangles"], meta_struct.pRectangles, options); + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkVideoEncodeH265RateControlFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["gopFrameCount"], decoded_value.gopFrameCount, options); + FieldToJson(jdata["idrPeriod"], decoded_value.idrPeriod, options); + FieldToJson(jdata["consecutiveBFrameCount"], decoded_value.consecutiveBFrameCount, options); + FieldToJson(jdata["subLayerCount"], decoded_value.subLayerCount, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPresentRegionsKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265FrameSizeKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPresentRegionsKHR& decoded_value = *data->decoded_value; - const Decoded_VkPresentRegionsKHR& meta_struct = *data; + const VkVideoEncodeH265FrameSizeKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265FrameSizeKHR& meta_struct = *data; - FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["swapchainCount"], decoded_value.swapchainCount, options); - FieldToJson(jdata["pRegions"], meta_struct.pRegions, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); + FieldToJson(jdata["frameISize"], decoded_value.frameISize, options); + FieldToJson(jdata["framePSize"], decoded_value.framePSize, options); + FieldToJson(jdata["frameBSize"], decoded_value.frameBSize, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSharedPresentSurfaceCapabilitiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265RateControlLayerInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkSharedPresentSurfaceCapabilitiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkSharedPresentSurfaceCapabilitiesKHR& meta_struct = *data; + const VkVideoEncodeH265RateControlLayerInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265RateControlLayerInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkImageUsageFlags_t(),jdata["sharedPresentSupportedUsageFlags"], decoded_value.sharedPresentSupportedUsageFlags, options); + jdata["useMinQp"] = static_cast(decoded_value.useMinQp); + FieldToJson(jdata["minQp"], meta_struct.minQp, options); + jdata["useMaxQp"] = static_cast(decoded_value.useMaxQp); + FieldToJson(jdata["maxQp"], meta_struct.maxQp, options); + jdata["useMaxFrameSize"] = static_cast(decoded_value.useMaxFrameSize); + FieldToJson(jdata["maxFrameSize"], meta_struct.maxFrameSize, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportFenceWin32HandleInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkImportFenceWin32HandleInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkImportFenceWin32HandleInfoKHR& meta_struct = *data; + const VkVideoEncodeH265GopRemainingFrameInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["fence"], meta_struct.fence, options); - FieldToJson(VkFenceImportFlags_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); - FieldToJson(jdata["handle"], meta_struct.handle, options); - FieldToJson(jdata["name"], &meta_struct.name, options); + jdata["useGopRemainingFrames"] = static_cast(decoded_value.useGopRemainingFrames); + FieldToJson(jdata["gopRemainingI"], decoded_value.gopRemainingI, options); + FieldToJson(jdata["gopRemainingP"], decoded_value.gopRemainingP, options); + FieldToJson(jdata["gopRemainingB"], decoded_value.gopRemainingB, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkExportFenceWin32HandleInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264ProfileInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkExportFenceWin32HandleInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkExportFenceWin32HandleInfoKHR& meta_struct = *data; + const VkVideoDecodeH264ProfileInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH264ProfileInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pAttributes"], meta_struct.pAttributes, options); - FieldToJson(jdata["dwAccess"], decoded_value.dwAccess, options); - FieldToJson(jdata["name"], &meta_struct.name, options); + FieldToJson(jdata["stdProfileIdc"], decoded_value.stdProfileIdc, options); + FieldToJson(jdata["pictureLayout"], decoded_value.pictureLayout, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkFenceGetWin32HandleInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264CapabilitiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkFenceGetWin32HandleInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkFenceGetWin32HandleInfoKHR& meta_struct = *data; + const VkVideoDecodeH264CapabilitiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH264CapabilitiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["fence"], meta_struct.fence, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); + FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); + FieldToJson(jdata["fieldOffsetGranularity"], meta_struct.fieldOffsetGranularity, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportFenceFdInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkImportFenceFdInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkImportFenceFdInfoKHR& meta_struct = *data; + const VkVideoDecodeH264SessionParametersAddInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["fence"], meta_struct.fence, options); - FieldToJson(VkFenceImportFlags_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); - FieldToJson(jdata["fd"], decoded_value.fd, options); + FieldToJson(jdata["stdSPSCount"], decoded_value.stdSPSCount, options); + FieldToJson(jdata["pStdSPSs"], meta_struct.pStdSPSs, options); + FieldToJson(jdata["stdPPSCount"], decoded_value.stdPPSCount, options); + FieldToJson(jdata["pStdPPSs"], meta_struct.pStdPPSs, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkFenceGetFdInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264SessionParametersCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkFenceGetFdInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkFenceGetFdInfoKHR& meta_struct = *data; + const VkVideoDecodeH264SessionParametersCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH264SessionParametersCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["fence"], meta_struct.fence, options); - FieldToJson(jdata["handleType"], decoded_value.handleType, options); + FieldToJson(jdata["maxStdSPSCount"], decoded_value.maxStdSPSCount, options); + FieldToJson(jdata["maxStdPPSCount"], decoded_value.maxStdPPSCount, options); + FieldToJson(jdata["pParametersAddInfo"], meta_struct.pParametersAddInfo, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264PictureInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDevicePerformanceQueryFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR& meta_struct = *data; + const VkVideoDecodeH264PictureInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH264PictureInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["performanceCounterQueryPools"] = static_cast(decoded_value.performanceCounterQueryPools); - jdata["performanceCounterMultipleQueryPools"] = static_cast(decoded_value.performanceCounterMultipleQueryPools); + FieldToJson(jdata["pStdPictureInfo"], meta_struct.pStdPictureInfo, options); + FieldToJson(jdata["sliceCount"], decoded_value.sliceCount, options); + FieldToJson(jdata["pSliceOffsets"], meta_struct.pSliceOffsets, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264DpbSlotInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDevicePerformanceQueryPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR& meta_struct = *data; + const VkVideoDecodeH264DpbSlotInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH264DpbSlotInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["allowCommandBufferQueryCopies"] = static_cast(decoded_value.allowCommandBufferQueryCopies); + FieldToJson(jdata["pStdReferenceInfo"], meta_struct.pStdReferenceInfo, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPerformanceCounterKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderingFragmentShadingRateAttachmentInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPerformanceCounterKHR& decoded_value = *data->decoded_value; - const Decoded_VkPerformanceCounterKHR& meta_struct = *data; + const VkRenderingFragmentShadingRateAttachmentInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkRenderingFragmentShadingRateAttachmentInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["unit"], decoded_value.unit, options); - FieldToJson(jdata["scope"], decoded_value.scope, options); - FieldToJson(jdata["storage"], decoded_value.storage, options); - FieldToJson(jdata["uuid"], uuid_to_string(sizeof(decoded_value.uuid), decoded_value.uuid), options); + HandleToJson(jdata["imageView"], meta_struct.imageView, options); + FieldToJson(jdata["imageLayout"], decoded_value.imageLayout, options); + FieldToJson(jdata["shadingRateAttachmentTexelSize"], meta_struct.shadingRateAttachmentTexelSize, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPerformanceCounterDescriptionKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderingFragmentDensityMapAttachmentInfoEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPerformanceCounterDescriptionKHR& decoded_value = *data->decoded_value; - const Decoded_VkPerformanceCounterDescriptionKHR& meta_struct = *data; + const VkRenderingFragmentDensityMapAttachmentInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkRenderingFragmentDensityMapAttachmentInfoEXT& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkPerformanceCounterDescriptionFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["name"], &meta_struct.name, options); - FieldToJson(jdata["category"], &meta_struct.category, options); - FieldToJson(jdata["description"], &meta_struct.description, options); + HandleToJson(jdata["imageView"], meta_struct.imageView, options); + FieldToJson(jdata["imageLayout"], decoded_value.imageLayout, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkQueryPoolPerformanceCreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAttachmentSampleCountInfoAMD* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkQueryPoolPerformanceCreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkQueryPoolPerformanceCreateInfoKHR& meta_struct = *data; + const VkAttachmentSampleCountInfoAMD& decoded_value = *data->decoded_value; + const Decoded_VkAttachmentSampleCountInfoAMD& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["queueFamilyIndex"], decoded_value.queueFamilyIndex, options); - FieldToJson(jdata["counterIndexCount"], decoded_value.counterIndexCount, options); - FieldToJson(jdata["pCounterIndices"], meta_struct.pCounterIndices, options); + FieldToJson(jdata["colorAttachmentCount"], decoded_value.colorAttachmentCount, options); + FieldToJson(jdata["pColorAttachmentSamples"], meta_struct.pColorAttachmentSamples, options); + FieldToJson(jdata["depthStencilAttachmentSamples"], decoded_value.depthStencilAttachmentSamples, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAcquireProfilingLockInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMultiviewPerViewAttributesInfoNVX* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkAcquireProfilingLockInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkAcquireProfilingLockInfoKHR& meta_struct = *data; + const VkMultiviewPerViewAttributesInfoNVX& decoded_value = *data->decoded_value; + const Decoded_VkMultiviewPerViewAttributesInfoNVX& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkAcquireProfilingLockFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["timeout"], decoded_value.timeout, options); + jdata["perViewAttributes"] = static_cast(decoded_value.perViewAttributes); + jdata["perViewAttributesPositionXOnly"] = static_cast(decoded_value.perViewAttributesPositionXOnly); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPerformanceQuerySubmitInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportMemoryWin32HandleInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPerformanceQuerySubmitInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkPerformanceQuerySubmitInfoKHR& meta_struct = *data; + const VkImportMemoryWin32HandleInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkImportMemoryWin32HandleInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["counterPassIndex"], decoded_value.counterPassIndex, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); + FieldToJson(jdata["handle"], meta_struct.handle, options); + FieldToJson(jdata["name"], &meta_struct.name, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceSurfaceInfo2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkExportMemoryWin32HandleInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceSurfaceInfo2KHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceSurfaceInfo2KHR& meta_struct = *data; + const VkExportMemoryWin32HandleInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkExportMemoryWin32HandleInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["surface"], meta_struct.surface, options); + FieldToJson(jdata["pAttributes"], meta_struct.pAttributes, options); + FieldToJson(jdata["dwAccess"], decoded_value.dwAccess, options); + FieldToJson(jdata["name"], &meta_struct.name, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSurfaceCapabilities2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryWin32HandlePropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkSurfaceCapabilities2KHR& decoded_value = *data->decoded_value; - const Decoded_VkSurfaceCapabilities2KHR& meta_struct = *data; + const VkMemoryWin32HandlePropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkMemoryWin32HandlePropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["surfaceCapabilities"], meta_struct.surfaceCapabilities, options); + FieldToJson(jdata["memoryTypeBits"], decoded_value.memoryTypeBits, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSurfaceFormat2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryGetWin32HandleInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkSurfaceFormat2KHR& decoded_value = *data->decoded_value; - const Decoded_VkSurfaceFormat2KHR& meta_struct = *data; + const VkMemoryGetWin32HandleInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkMemoryGetWin32HandleInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["surfaceFormat"], meta_struct.surfaceFormat, options); + HandleToJson(jdata["memory"], meta_struct.memory, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayProperties2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportMemoryFdInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDisplayProperties2KHR& decoded_value = *data->decoded_value; - const Decoded_VkDisplayProperties2KHR& meta_struct = *data; + const VkImportMemoryFdInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkImportMemoryFdInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["displayProperties"], meta_struct.displayProperties, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); + FieldToJson(jdata["fd"], decoded_value.fd, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayPlaneProperties2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryFdPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDisplayPlaneProperties2KHR& decoded_value = *data->decoded_value; - const Decoded_VkDisplayPlaneProperties2KHR& meta_struct = *data; + const VkMemoryFdPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkMemoryFdPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["displayPlaneProperties"], meta_struct.displayPlaneProperties, options); + FieldToJson(jdata["memoryTypeBits"], decoded_value.memoryTypeBits, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayModeProperties2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryGetFdInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDisplayModeProperties2KHR& decoded_value = *data->decoded_value; - const Decoded_VkDisplayModeProperties2KHR& meta_struct = *data; + const VkMemoryGetFdInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkMemoryGetFdInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["displayModeProperties"], meta_struct.displayModeProperties, options); + HandleToJson(jdata["memory"], meta_struct.memory, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayPlaneInfo2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDisplayPlaneInfo2KHR& decoded_value = *data->decoded_value; - const Decoded_VkDisplayPlaneInfo2KHR& meta_struct = *data; + const VkWin32KeyedMutexAcquireReleaseInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["mode"], meta_struct.mode, options); - FieldToJson(jdata["planeIndex"], decoded_value.planeIndex, options); + FieldToJson(jdata["acquireCount"], decoded_value.acquireCount, options); + HandleToJson(jdata["pAcquireSyncs"], &meta_struct.pAcquireSyncs, options); + FieldToJson(jdata["pAcquireKeys"], meta_struct.pAcquireKeys, options); + FieldToJson(jdata["pAcquireTimeouts"], meta_struct.pAcquireTimeouts, options); + FieldToJson(jdata["releaseCount"], decoded_value.releaseCount, options); + HandleToJson(jdata["pReleaseSyncs"], &meta_struct.pReleaseSyncs, options); + FieldToJson(jdata["pReleaseKeys"], meta_struct.pReleaseKeys, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayPlaneCapabilities2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportSemaphoreWin32HandleInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDisplayPlaneCapabilities2KHR& decoded_value = *data->decoded_value; - const Decoded_VkDisplayPlaneCapabilities2KHR& meta_struct = *data; + const VkImportSemaphoreWin32HandleInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkImportSemaphoreWin32HandleInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["capabilities"], meta_struct.capabilities, options); + HandleToJson(jdata["semaphore"], meta_struct.semaphore, options); + FieldToJson(VkSemaphoreImportFlags_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); + FieldToJson(jdata["handle"], meta_struct.handle, options); + FieldToJson(jdata["name"], &meta_struct.name, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkExportSemaphoreWin32HandleInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDevicePortabilitySubsetFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR& meta_struct = *data; + const VkExportSemaphoreWin32HandleInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkExportSemaphoreWin32HandleInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["constantAlphaColorBlendFactors"] = static_cast(decoded_value.constantAlphaColorBlendFactors); - jdata["events"] = static_cast(decoded_value.events); - jdata["imageViewFormatReinterpretation"] = static_cast(decoded_value.imageViewFormatReinterpretation); - jdata["imageViewFormatSwizzle"] = static_cast(decoded_value.imageViewFormatSwizzle); - jdata["imageView2DOn3DImage"] = static_cast(decoded_value.imageView2DOn3DImage); - jdata["multisampleArrayImage"] = static_cast(decoded_value.multisampleArrayImage); - jdata["mutableComparisonSamplers"] = static_cast(decoded_value.mutableComparisonSamplers); - jdata["pointPolygons"] = static_cast(decoded_value.pointPolygons); - jdata["samplerMipLodBias"] = static_cast(decoded_value.samplerMipLodBias); - jdata["separateStencilMaskRef"] = static_cast(decoded_value.separateStencilMaskRef); - jdata["shaderSampleRateInterpolationFunctions"] = static_cast(decoded_value.shaderSampleRateInterpolationFunctions); - jdata["tessellationIsolines"] = static_cast(decoded_value.tessellationIsolines); - jdata["tessellationPointMode"] = static_cast(decoded_value.tessellationPointMode); - jdata["triangleFans"] = static_cast(decoded_value.triangleFans); - jdata["vertexAttributeAccessBeyondStride"] = static_cast(decoded_value.vertexAttributeAccessBeyondStride); + FieldToJson(jdata["pAttributes"], meta_struct.pAttributes, options); + FieldToJson(jdata["dwAccess"], decoded_value.dwAccess, options); + FieldToJson(jdata["name"], &meta_struct.name, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkD3D12FenceSubmitInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDevicePortabilitySubsetPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR& meta_struct = *data; + const VkD3D12FenceSubmitInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkD3D12FenceSubmitInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["minVertexInputBindingStrideAlignment"], decoded_value.minVertexInputBindingStrideAlignment, options); + FieldToJson(jdata["waitSemaphoreValuesCount"], decoded_value.waitSemaphoreValuesCount, options); + FieldToJson(jdata["pWaitSemaphoreValues"], meta_struct.pWaitSemaphoreValues, options); + FieldToJson(jdata["signalSemaphoreValuesCount"], decoded_value.signalSemaphoreValuesCount, options); + FieldToJson(jdata["pSignalSemaphoreValues"], meta_struct.pSignalSemaphoreValues, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderClockFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSemaphoreGetWin32HandleInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceShaderClockFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceShaderClockFeaturesKHR& meta_struct = *data; + const VkSemaphoreGetWin32HandleInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkSemaphoreGetWin32HandleInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["shaderSubgroupClock"] = static_cast(decoded_value.shaderSubgroupClock); - jdata["shaderDeviceClock"] = static_cast(decoded_value.shaderDeviceClock); + HandleToJson(jdata["semaphore"], meta_struct.semaphore, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265ProfileInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportSemaphoreFdInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH265ProfileInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH265ProfileInfoKHR& meta_struct = *data; + const VkImportSemaphoreFdInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkImportSemaphoreFdInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["stdProfileIdc"], decoded_value.stdProfileIdc, options); + HandleToJson(jdata["semaphore"], meta_struct.semaphore, options); + FieldToJson(VkSemaphoreImportFlags_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); + FieldToJson(jdata["fd"], decoded_value.fd, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265CapabilitiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSemaphoreGetFdInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH265CapabilitiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH265CapabilitiesKHR& meta_struct = *data; + const VkSemaphoreGetFdInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkSemaphoreGetFdInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); + HandleToJson(jdata["semaphore"], meta_struct.semaphore, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265SessionParametersAddInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH265SessionParametersAddInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH265SessionParametersAddInfoKHR& meta_struct = *data; + const VkPhysicalDevicePushDescriptorPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["stdVPSCount"], decoded_value.stdVPSCount, options); - FieldToJson(jdata["pStdVPSs"], meta_struct.pStdVPSs, options); - FieldToJson(jdata["stdSPSCount"], decoded_value.stdSPSCount, options); - FieldToJson(jdata["pStdSPSs"], meta_struct.pStdSPSs, options); - FieldToJson(jdata["stdPPSCount"], decoded_value.stdPPSCount, options); - FieldToJson(jdata["pStdPPSs"], meta_struct.pStdPPSs, options); + FieldToJson(jdata["maxPushDescriptors"], decoded_value.maxPushDescriptors, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265SessionParametersCreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRectLayerKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH265SessionParametersCreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH265SessionParametersCreateInfoKHR& meta_struct = *data; + const VkRectLayerKHR& decoded_value = *data->decoded_value; + const Decoded_VkRectLayerKHR& meta_struct = *data; - FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["maxStdVPSCount"], decoded_value.maxStdVPSCount, options); - FieldToJson(jdata["maxStdSPSCount"], decoded_value.maxStdSPSCount, options); - FieldToJson(jdata["maxStdPPSCount"], decoded_value.maxStdPPSCount, options); - FieldToJson(jdata["pParametersAddInfo"], meta_struct.pParametersAddInfo, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); + FieldToJson(jdata["offset"], meta_struct.offset, options); + FieldToJson(jdata["extent"], meta_struct.extent, options); + FieldToJson(jdata["layer"], decoded_value.layer, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265PictureInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPresentRegionKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH265PictureInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH265PictureInfoKHR& meta_struct = *data; + const VkPresentRegionKHR& decoded_value = *data->decoded_value; + const Decoded_VkPresentRegionKHR& meta_struct = *data; - FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pStdPictureInfo"], meta_struct.pStdPictureInfo, options); - FieldToJson(jdata["sliceSegmentCount"], decoded_value.sliceSegmentCount, options); - FieldToJson(jdata["pSliceSegmentOffsets"], meta_struct.pSliceSegmentOffsets, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); + FieldToJson(jdata["rectangleCount"], decoded_value.rectangleCount, options); + FieldToJson(jdata["pRectangles"], meta_struct.pRectangles, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265DpbSlotInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPresentRegionsKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoDecodeH265DpbSlotInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoDecodeH265DpbSlotInfoKHR& meta_struct = *data; + const VkPresentRegionsKHR& decoded_value = *data->decoded_value; + const Decoded_VkPresentRegionsKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pStdReferenceInfo"], meta_struct.pStdReferenceInfo, options); + FieldToJson(jdata["swapchainCount"], decoded_value.swapchainCount, options); + FieldToJson(jdata["pRegions"], meta_struct.pRegions, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSharedPresentSurfaceCapabilitiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDeviceQueueGlobalPriorityCreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR& meta_struct = *data; + const VkSharedPresentSurfaceCapabilitiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkSharedPresentSurfaceCapabilitiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["globalPriority"], decoded_value.globalPriority, options); + FieldToJson(VkImageUsageFlags_t(),jdata["sharedPresentSupportedUsageFlags"], decoded_value.sharedPresentSupportedUsageFlags, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportFenceWin32HandleInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& meta_struct = *data; + const VkImportFenceWin32HandleInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkImportFenceWin32HandleInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["globalPriorityQuery"] = static_cast(decoded_value.globalPriorityQuery); + HandleToJson(jdata["fence"], meta_struct.fence, options); + FieldToJson(VkFenceImportFlags_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); + FieldToJson(jdata["handle"], meta_struct.handle, options); + FieldToJson(jdata["name"], &meta_struct.name, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkExportFenceWin32HandleInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkQueueFamilyGlobalPriorityPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR& meta_struct = *data; + const VkExportFenceWin32HandleInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkExportFenceWin32HandleInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["priorityCount"], decoded_value.priorityCount, options); - FieldToJson(jdata["priorities"], &meta_struct.priorities, options); + FieldToJson(jdata["pAttributes"], meta_struct.pAttributes, options); + FieldToJson(jdata["dwAccess"], decoded_value.dwAccess, options); + FieldToJson(jdata["name"], &meta_struct.name, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkFragmentShadingRateAttachmentInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkFenceGetWin32HandleInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkFragmentShadingRateAttachmentInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkFragmentShadingRateAttachmentInfoKHR& meta_struct = *data; + const VkFenceGetWin32HandleInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkFenceGetWin32HandleInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pFragmentShadingRateAttachment"], meta_struct.pFragmentShadingRateAttachment, options); - FieldToJson(jdata["shadingRateAttachmentTexelSize"], meta_struct.shadingRateAttachmentTexelSize, options); + HandleToJson(jdata["fence"], meta_struct.fence, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineFragmentShadingRateStateCreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportFenceFdInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineFragmentShadingRateStateCreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkPipelineFragmentShadingRateStateCreateInfoKHR& meta_struct = *data; + const VkImportFenceFdInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkImportFenceFdInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["fragmentSize"], meta_struct.fragmentSize, options); - FieldToJson(jdata["combinerOps"], &meta_struct.combinerOps, options); + HandleToJson(jdata["fence"], meta_struct.fence, options); + FieldToJson(VkFenceImportFlags_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); + FieldToJson(jdata["fd"], decoded_value.fd, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkFenceGetFdInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& meta_struct = *data; + const VkFenceGetFdInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkFenceGetFdInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["pipelineFragmentShadingRate"] = static_cast(decoded_value.pipelineFragmentShadingRate); - jdata["primitiveFragmentShadingRate"] = static_cast(decoded_value.primitiveFragmentShadingRate); - jdata["attachmentFragmentShadingRate"] = static_cast(decoded_value.attachmentFragmentShadingRate); + HandleToJson(jdata["fence"], meta_struct.fence, options); + FieldToJson(jdata["handleType"], decoded_value.handleType, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& meta_struct = *data; + const VkPhysicalDevicePerformanceQueryFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["minFragmentShadingRateAttachmentTexelSize"], meta_struct.minFragmentShadingRateAttachmentTexelSize, options); - FieldToJson(jdata["maxFragmentShadingRateAttachmentTexelSize"], meta_struct.maxFragmentShadingRateAttachmentTexelSize, options); - FieldToJson(jdata["maxFragmentShadingRateAttachmentTexelSizeAspectRatio"], decoded_value.maxFragmentShadingRateAttachmentTexelSizeAspectRatio, options); - jdata["primitiveFragmentShadingRateWithMultipleViewports"] = static_cast(decoded_value.primitiveFragmentShadingRateWithMultipleViewports); - jdata["layeredShadingRateAttachments"] = static_cast(decoded_value.layeredShadingRateAttachments); - jdata["fragmentShadingRateNonTrivialCombinerOps"] = static_cast(decoded_value.fragmentShadingRateNonTrivialCombinerOps); - FieldToJson(jdata["maxFragmentSize"], meta_struct.maxFragmentSize, options); - FieldToJson(jdata["maxFragmentSizeAspectRatio"], decoded_value.maxFragmentSizeAspectRatio, options); - FieldToJson(jdata["maxFragmentShadingRateCoverageSamples"], decoded_value.maxFragmentShadingRateCoverageSamples, options); - FieldToJson(jdata["maxFragmentShadingRateRasterizationSamples"], decoded_value.maxFragmentShadingRateRasterizationSamples, options); - jdata["fragmentShadingRateWithShaderDepthStencilWrites"] = static_cast(decoded_value.fragmentShadingRateWithShaderDepthStencilWrites); - jdata["fragmentShadingRateWithSampleMask"] = static_cast(decoded_value.fragmentShadingRateWithSampleMask); - jdata["fragmentShadingRateWithShaderSampleMask"] = static_cast(decoded_value.fragmentShadingRateWithShaderSampleMask); - jdata["fragmentShadingRateWithConservativeRasterization"] = static_cast(decoded_value.fragmentShadingRateWithConservativeRasterization); - jdata["fragmentShadingRateWithFragmentShaderInterlock"] = static_cast(decoded_value.fragmentShadingRateWithFragmentShaderInterlock); - jdata["fragmentShadingRateWithCustomSampleLocations"] = static_cast(decoded_value.fragmentShadingRateWithCustomSampleLocations); - jdata["fragmentShadingRateStrictMultiplyCombiner"] = static_cast(decoded_value.fragmentShadingRateStrictMultiplyCombiner); + jdata["performanceCounterQueryPools"] = static_cast(decoded_value.performanceCounterQueryPools); + jdata["performanceCounterMultipleQueryPools"] = static_cast(decoded_value.performanceCounterMultipleQueryPools); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShadingRateKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceFragmentShadingRateKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceFragmentShadingRateKHR& meta_struct = *data; + const VkPhysicalDevicePerformanceQueryPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkSampleCountFlags_t(),jdata["sampleCounts"], decoded_value.sampleCounts, options); - FieldToJson(jdata["fragmentSize"], meta_struct.fragmentSize, options); + jdata["allowCommandBufferQueryCopies"] = static_cast(decoded_value.allowCommandBufferQueryCopies); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSurfaceProtectedCapabilitiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPerformanceCounterKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkSurfaceProtectedCapabilitiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkSurfaceProtectedCapabilitiesKHR& meta_struct = *data; + const VkPerformanceCounterKHR& decoded_value = *data->decoded_value; + const Decoded_VkPerformanceCounterKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["supportsProtected"] = static_cast(decoded_value.supportsProtected); + FieldToJson(jdata["unit"], decoded_value.unit, options); + FieldToJson(jdata["scope"], decoded_value.scope, options); + FieldToJson(jdata["storage"], decoded_value.storage, options); + FieldToJson(jdata["uuid"], uuid_to_string(sizeof(decoded_value.uuid), decoded_value.uuid), options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePresentWaitFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPerformanceCounterDescriptionKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDevicePresentWaitFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDevicePresentWaitFeaturesKHR& meta_struct = *data; + const VkPerformanceCounterDescriptionKHR& decoded_value = *data->decoded_value; + const Decoded_VkPerformanceCounterDescriptionKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["presentWait"] = static_cast(decoded_value.presentWait); + FieldToJson(VkPerformanceCounterDescriptionFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["name"], &meta_struct.name, options); + FieldToJson(jdata["category"], &meta_struct.category, options); + FieldToJson(jdata["description"], &meta_struct.description, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkQueryPoolPerformanceCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& meta_struct = *data; + const VkQueryPoolPerformanceCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkQueryPoolPerformanceCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["pipelineExecutableInfo"] = static_cast(decoded_value.pipelineExecutableInfo); + FieldToJson(jdata["queueFamilyIndex"], decoded_value.queueFamilyIndex, options); + FieldToJson(jdata["counterIndexCount"], decoded_value.counterIndexCount, options); + FieldToJson(jdata["pCounterIndices"], meta_struct.pCounterIndices, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAcquireProfilingLockInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkPipelineInfoKHR& meta_struct = *data; + const VkAcquireProfilingLockInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkAcquireProfilingLockInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["pipeline"], meta_struct.pipeline, options); + FieldToJson(VkAcquireProfilingLockFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["timeout"], decoded_value.timeout, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineExecutablePropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPerformanceQuerySubmitInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineExecutablePropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPipelineExecutablePropertiesKHR& meta_struct = *data; + const VkPerformanceQuerySubmitInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPerformanceQuerySubmitInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkShaderStageFlags_t(),jdata["stages"], decoded_value.stages, options); - FieldToJson(jdata["name"], &meta_struct.name, options); - FieldToJson(jdata["description"], &meta_struct.description, options); - FieldToJson(jdata["subgroupSize"], decoded_value.subgroupSize, options); + FieldToJson(jdata["counterPassIndex"], decoded_value.counterPassIndex, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineExecutableInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceSurfaceInfo2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineExecutableInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkPipelineExecutableInfoKHR& meta_struct = *data; + const VkPhysicalDeviceSurfaceInfo2KHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceSurfaceInfo2KHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["pipeline"], meta_struct.pipeline, options); - FieldToJson(jdata["executableIndex"], decoded_value.executableIndex, options); + HandleToJson(jdata["surface"], meta_struct.surface, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineExecutableInternalRepresentationKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSurfaceCapabilities2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineExecutableInternalRepresentationKHR& decoded_value = *data->decoded_value; - const Decoded_VkPipelineExecutableInternalRepresentationKHR& meta_struct = *data; + const VkSurfaceCapabilities2KHR& decoded_value = *data->decoded_value; + const Decoded_VkSurfaceCapabilities2KHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["name"], &meta_struct.name, options); - FieldToJson(jdata["description"], &meta_struct.description, options); - jdata["isText"] = static_cast(decoded_value.isText); - FieldToJson(jdata["dataSize"], decoded_value.dataSize, options); - FieldToJson(jdata["pData"], meta_struct.pData, options); + FieldToJson(jdata["surfaceCapabilities"], meta_struct.surfaceCapabilities, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryMapInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSurfaceFormat2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkMemoryMapInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkMemoryMapInfoKHR& meta_struct = *data; + const VkSurfaceFormat2KHR& decoded_value = *data->decoded_value; + const Decoded_VkSurfaceFormat2KHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkMemoryMapFlags_t(),jdata["flags"], decoded_value.flags, options); - HandleToJson(jdata["memory"], meta_struct.memory, options); - FieldToJson(jdata["offset"], decoded_value.offset, options); - FieldToJson(jdata["size"], decoded_value.size, options); + FieldToJson(jdata["surfaceFormat"], meta_struct.surfaceFormat, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryUnmapInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayProperties2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkMemoryUnmapInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkMemoryUnmapInfoKHR& meta_struct = *data; + const VkDisplayProperties2KHR& decoded_value = *data->decoded_value; + const Decoded_VkDisplayProperties2KHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkMemoryUnmapFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); - HandleToJson(jdata["memory"], meta_struct.memory, options); + FieldToJson(jdata["displayProperties"], meta_struct.displayProperties, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineLibraryCreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayPlaneProperties2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineLibraryCreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkPipelineLibraryCreateInfoKHR& meta_struct = *data; + const VkDisplayPlaneProperties2KHR& decoded_value = *data->decoded_value; + const Decoded_VkDisplayPlaneProperties2KHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["libraryCount"], decoded_value.libraryCount, options); - HandleToJson(jdata["pLibraries"], &meta_struct.pLibraries, options); + FieldToJson(jdata["displayPlaneProperties"], meta_struct.displayPlaneProperties, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPresentIdKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayModeProperties2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPresentIdKHR& decoded_value = *data->decoded_value; - const Decoded_VkPresentIdKHR& meta_struct = *data; + const VkDisplayModeProperties2KHR& decoded_value = *data->decoded_value; + const Decoded_VkDisplayModeProperties2KHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["swapchainCount"], decoded_value.swapchainCount, options); - FieldToJson(jdata["pPresentIds"], meta_struct.pPresentIds, options); + FieldToJson(jdata["displayModeProperties"], meta_struct.displayModeProperties, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePresentIdFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayPlaneInfo2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDevicePresentIdFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDevicePresentIdFeaturesKHR& meta_struct = *data; + const VkDisplayPlaneInfo2KHR& decoded_value = *data->decoded_value; + const Decoded_VkDisplayPlaneInfo2KHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["presentId"] = static_cast(decoded_value.presentId); + HandleToJson(jdata["mode"], meta_struct.mode, options); + FieldToJson(jdata["planeIndex"], decoded_value.planeIndex, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDisplayPlaneCapabilities2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeInfoKHR& meta_struct = *data; + const VkDisplayPlaneCapabilities2KHR& decoded_value = *data->decoded_value; + const Decoded_VkDisplayPlaneCapabilities2KHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); - HandleToJson(jdata["dstBuffer"], meta_struct.dstBuffer, options); - FieldToJson(jdata["dstBufferOffset"], decoded_value.dstBufferOffset, options); - FieldToJson(jdata["dstBufferRange"], decoded_value.dstBufferRange, options); - FieldToJson(jdata["srcPictureResource"], meta_struct.srcPictureResource, options); - FieldToJson(jdata["pSetupReferenceSlot"], meta_struct.pSetupReferenceSlot, options); - FieldToJson(jdata["referenceSlotCount"], decoded_value.referenceSlotCount, options); - FieldToJson(jdata["pReferenceSlots"], meta_struct.pReferenceSlots, options); - FieldToJson(jdata["precedingExternallyEncodedBytes"], decoded_value.precedingExternallyEncodedBytes, options); + FieldToJson(jdata["capabilities"], meta_struct.capabilities, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeCapabilitiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeCapabilitiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeCapabilitiesKHR& meta_struct = *data; + const VkPhysicalDevicePortabilitySubsetFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeCapabilityFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(VkVideoEncodeRateControlModeFlagsKHR_t(),jdata["rateControlModes"], decoded_value.rateControlModes, options); - FieldToJson(jdata["maxRateControlLayers"], decoded_value.maxRateControlLayers, options); - FieldToJson(jdata["maxBitrate"], decoded_value.maxBitrate, options); - FieldToJson(jdata["maxQualityLevels"], decoded_value.maxQualityLevels, options); - FieldToJson(jdata["encodeInputPictureGranularity"], meta_struct.encodeInputPictureGranularity, options); - FieldToJson(VkVideoEncodeFeedbackFlagsKHR_t(),jdata["supportedEncodeFeedbackFlags"], decoded_value.supportedEncodeFeedbackFlags, options); + jdata["constantAlphaColorBlendFactors"] = static_cast(decoded_value.constantAlphaColorBlendFactors); + jdata["events"] = static_cast(decoded_value.events); + jdata["imageViewFormatReinterpretation"] = static_cast(decoded_value.imageViewFormatReinterpretation); + jdata["imageViewFormatSwizzle"] = static_cast(decoded_value.imageViewFormatSwizzle); + jdata["imageView2DOn3DImage"] = static_cast(decoded_value.imageView2DOn3DImage); + jdata["multisampleArrayImage"] = static_cast(decoded_value.multisampleArrayImage); + jdata["mutableComparisonSamplers"] = static_cast(decoded_value.mutableComparisonSamplers); + jdata["pointPolygons"] = static_cast(decoded_value.pointPolygons); + jdata["samplerMipLodBias"] = static_cast(decoded_value.samplerMipLodBias); + jdata["separateStencilMaskRef"] = static_cast(decoded_value.separateStencilMaskRef); + jdata["shaderSampleRateInterpolationFunctions"] = static_cast(decoded_value.shaderSampleRateInterpolationFunctions); + jdata["tessellationIsolines"] = static_cast(decoded_value.tessellationIsolines); + jdata["tessellationPointMode"] = static_cast(decoded_value.tessellationPointMode); + jdata["triangleFans"] = static_cast(decoded_value.triangleFans); + jdata["vertexAttributeAccessBeyondStride"] = static_cast(decoded_value.vertexAttributeAccessBeyondStride); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& meta_struct = *data; + const VkPhysicalDevicePortabilitySubsetPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeFeedbackFlagsKHR_t(),jdata["encodeFeedbackFlags"], decoded_value.encodeFeedbackFlags, options); + FieldToJson(jdata["minVertexInputBindingStrideAlignment"], decoded_value.minVertexInputBindingStrideAlignment, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeUsageInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderClockFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeUsageInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeUsageInfoKHR& meta_struct = *data; + const VkPhysicalDeviceShaderClockFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceShaderClockFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeUsageFlagsKHR_t(),jdata["videoUsageHints"], decoded_value.videoUsageHints, options); - FieldToJson(VkVideoEncodeContentFlagsKHR_t(),jdata["videoContentHints"], decoded_value.videoContentHints, options); - FieldToJson(jdata["tuningMode"], decoded_value.tuningMode, options); + jdata["shaderSubgroupClock"] = static_cast(decoded_value.shaderSubgroupClock); + jdata["shaderDeviceClock"] = static_cast(decoded_value.shaderDeviceClock); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeRateControlLayerInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265ProfileInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeRateControlLayerInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeRateControlLayerInfoKHR& meta_struct = *data; + const VkVideoDecodeH265ProfileInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH265ProfileInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["averageBitrate"], decoded_value.averageBitrate, options); - FieldToJson(jdata["maxBitrate"], decoded_value.maxBitrate, options); - FieldToJson(jdata["frameRateNumerator"], decoded_value.frameRateNumerator, options); - FieldToJson(jdata["frameRateDenominator"], decoded_value.frameRateDenominator, options); + FieldToJson(jdata["stdProfileIdc"], decoded_value.stdProfileIdc, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeRateControlInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265CapabilitiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeRateControlInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeRateControlInfoKHR& meta_struct = *data; + const VkVideoDecodeH265CapabilitiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH265CapabilitiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeRateControlFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["rateControlMode"], decoded_value.rateControlMode, options); - FieldToJson(jdata["layerCount"], decoded_value.layerCount, options); - FieldToJson(jdata["pLayers"], meta_struct.pLayers, options); - FieldToJson(jdata["virtualBufferSizeInMs"], decoded_value.virtualBufferSizeInMs, options); - FieldToJson(jdata["initialVirtualBufferSizeInMs"], decoded_value.initialVirtualBufferSizeInMs, options); + FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265SessionParametersAddInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& meta_struct = *data; + const VkVideoDecodeH265SessionParametersAddInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH265SessionParametersAddInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pVideoProfile"], meta_struct.pVideoProfile, options); - FieldToJson(jdata["qualityLevel"], decoded_value.qualityLevel, options); + FieldToJson(jdata["stdVPSCount"], decoded_value.stdVPSCount, options); + FieldToJson(jdata["pStdVPSs"], meta_struct.pStdVPSs, options); + FieldToJson(jdata["stdSPSCount"], decoded_value.stdSPSCount, options); + FieldToJson(jdata["pStdSPSs"], meta_struct.pStdSPSs, options); + FieldToJson(jdata["stdPPSCount"], decoded_value.stdPPSCount, options); + FieldToJson(jdata["pStdPPSs"], meta_struct.pStdPPSs, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeQualityLevelPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265SessionParametersCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeQualityLevelPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeQualityLevelPropertiesKHR& meta_struct = *data; + const VkVideoDecodeH265SessionParametersCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH265SessionParametersCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["preferredRateControlMode"], decoded_value.preferredRateControlMode, options); - FieldToJson(jdata["preferredRateControlLayerCount"], decoded_value.preferredRateControlLayerCount, options); + FieldToJson(jdata["maxStdVPSCount"], decoded_value.maxStdVPSCount, options); + FieldToJson(jdata["maxStdSPSCount"], decoded_value.maxStdSPSCount, options); + FieldToJson(jdata["maxStdPPSCount"], decoded_value.maxStdPPSCount, options); + FieldToJson(jdata["pParametersAddInfo"], meta_struct.pParametersAddInfo, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeQualityLevelInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265PictureInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeQualityLevelInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeQualityLevelInfoKHR& meta_struct = *data; + const VkVideoDecodeH265PictureInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH265PictureInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["qualityLevel"], decoded_value.qualityLevel, options); + FieldToJson(jdata["pStdPictureInfo"], meta_struct.pStdPictureInfo, options); + FieldToJson(jdata["sliceSegmentCount"], decoded_value.sliceSegmentCount, options); + FieldToJson(jdata["pSliceSegmentOffsets"], meta_struct.pSliceSegmentOffsets, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeSessionParametersGetInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH265DpbSlotInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeSessionParametersGetInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeSessionParametersGetInfoKHR& meta_struct = *data; + const VkVideoDecodeH265DpbSlotInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoDecodeH265DpbSlotInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["videoSessionParameters"], meta_struct.videoSessionParameters, options); + FieldToJson(jdata["pStdReferenceInfo"], meta_struct.pStdReferenceInfo, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeSessionParametersFeedbackInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeSessionParametersFeedbackInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeSessionParametersFeedbackInfoKHR& meta_struct = *data; + const VkDeviceQueueGlobalPriorityCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["hasOverrides"] = static_cast(decoded_value.hasOverrides); + FieldToJson(jdata["globalPriority"], decoded_value.globalPriority, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkQueueFamilyCheckpointProperties2NV* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkQueueFamilyCheckpointProperties2NV& decoded_value = *data->decoded_value; - const Decoded_VkQueueFamilyCheckpointProperties2NV& meta_struct = *data; + const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkPipelineStageFlags2_t(),jdata["checkpointExecutionStageMask"], decoded_value.checkpointExecutionStageMask, options); + jdata["globalPriorityQuery"] = static_cast(decoded_value.globalPriorityQuery); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCheckpointData2NV* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkCheckpointData2NV& decoded_value = *data->decoded_value; - const Decoded_VkCheckpointData2NV& meta_struct = *data; + const VkQueueFamilyGlobalPriorityPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkPipelineStageFlags2_t(),jdata["stage"], decoded_value.stage, options); - FieldToJson(jdata["pCheckpointMarker"], meta_struct.pCheckpointMarker, options); + FieldToJson(jdata["priorityCount"], decoded_value.priorityCount, options); + FieldToJson(jdata["priorities"], &meta_struct.priorities, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkFragmentShadingRateAttachmentInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& meta_struct = *data; + const VkFragmentShadingRateAttachmentInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkFragmentShadingRateAttachmentInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["fragmentShaderBarycentric"] = static_cast(decoded_value.fragmentShaderBarycentric); + FieldToJson(jdata["pFragmentShadingRateAttachment"], meta_struct.pFragmentShadingRateAttachment, options); + FieldToJson(jdata["shadingRateAttachmentTexelSize"], meta_struct.shadingRateAttachmentTexelSize, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineFragmentShadingRateStateCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& meta_struct = *data; + const VkPipelineFragmentShadingRateStateCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineFragmentShadingRateStateCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["triStripVertexOrderIndependentOfProvokingVertex"] = static_cast(decoded_value.triStripVertexOrderIndependentOfProvokingVertex); + FieldToJson(jdata["fragmentSize"], meta_struct.fragmentSize, options); + FieldToJson(jdata["combinerOps"], &meta_struct.combinerOps, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& meta_struct = *data; + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceFragmentShadingRateFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["shaderSubgroupUniformControlFlow"] = static_cast(decoded_value.shaderSubgroupUniformControlFlow); + jdata["pipelineFragmentShadingRate"] = static_cast(decoded_value.pipelineFragmentShadingRate); + jdata["primitiveFragmentShadingRate"] = static_cast(decoded_value.primitiveFragmentShadingRate); + jdata["attachmentFragmentShadingRate"] = static_cast(decoded_value.attachmentFragmentShadingRate); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& meta_struct = *data; + const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceFragmentShadingRatePropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["workgroupMemoryExplicitLayout"] = static_cast(decoded_value.workgroupMemoryExplicitLayout); - jdata["workgroupMemoryExplicitLayoutScalarBlockLayout"] = static_cast(decoded_value.workgroupMemoryExplicitLayoutScalarBlockLayout); - jdata["workgroupMemoryExplicitLayout8BitAccess"] = static_cast(decoded_value.workgroupMemoryExplicitLayout8BitAccess); - jdata["workgroupMemoryExplicitLayout16BitAccess"] = static_cast(decoded_value.workgroupMemoryExplicitLayout16BitAccess); + FieldToJson(jdata["minFragmentShadingRateAttachmentTexelSize"], meta_struct.minFragmentShadingRateAttachmentTexelSize, options); + FieldToJson(jdata["maxFragmentShadingRateAttachmentTexelSize"], meta_struct.maxFragmentShadingRateAttachmentTexelSize, options); + FieldToJson(jdata["maxFragmentShadingRateAttachmentTexelSizeAspectRatio"], decoded_value.maxFragmentShadingRateAttachmentTexelSizeAspectRatio, options); + jdata["primitiveFragmentShadingRateWithMultipleViewports"] = static_cast(decoded_value.primitiveFragmentShadingRateWithMultipleViewports); + jdata["layeredShadingRateAttachments"] = static_cast(decoded_value.layeredShadingRateAttachments); + jdata["fragmentShadingRateNonTrivialCombinerOps"] = static_cast(decoded_value.fragmentShadingRateNonTrivialCombinerOps); + FieldToJson(jdata["maxFragmentSize"], meta_struct.maxFragmentSize, options); + FieldToJson(jdata["maxFragmentSizeAspectRatio"], decoded_value.maxFragmentSizeAspectRatio, options); + FieldToJson(jdata["maxFragmentShadingRateCoverageSamples"], decoded_value.maxFragmentShadingRateCoverageSamples, options); + FieldToJson(jdata["maxFragmentShadingRateRasterizationSamples"], decoded_value.maxFragmentShadingRateRasterizationSamples, options); + jdata["fragmentShadingRateWithShaderDepthStencilWrites"] = static_cast(decoded_value.fragmentShadingRateWithShaderDepthStencilWrites); + jdata["fragmentShadingRateWithSampleMask"] = static_cast(decoded_value.fragmentShadingRateWithSampleMask); + jdata["fragmentShadingRateWithShaderSampleMask"] = static_cast(decoded_value.fragmentShadingRateWithShaderSampleMask); + jdata["fragmentShadingRateWithConservativeRasterization"] = static_cast(decoded_value.fragmentShadingRateWithConservativeRasterization); + jdata["fragmentShadingRateWithFragmentShaderInterlock"] = static_cast(decoded_value.fragmentShadingRateWithFragmentShaderInterlock); + jdata["fragmentShadingRateWithCustomSampleLocations"] = static_cast(decoded_value.fragmentShadingRateWithCustomSampleLocations); + jdata["fragmentShadingRateStrictMultiplyCombiner"] = static_cast(decoded_value.fragmentShadingRateStrictMultiplyCombiner); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShadingRateKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& meta_struct = *data; + const VkPhysicalDeviceFragmentShadingRateKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceFragmentShadingRateKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["rayTracingMaintenance1"] = static_cast(decoded_value.rayTracingMaintenance1); - jdata["rayTracingPipelineTraceRaysIndirect2"] = static_cast(decoded_value.rayTracingPipelineTraceRaysIndirect2); + FieldToJson(VkSampleCountFlags_t(),jdata["sampleCounts"], decoded_value.sampleCounts, options); + FieldToJson(jdata["fragmentSize"], meta_struct.fragmentSize, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkTraceRaysIndirectCommand2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSurfaceProtectedCapabilitiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkTraceRaysIndirectCommand2KHR& decoded_value = *data->decoded_value; - const Decoded_VkTraceRaysIndirectCommand2KHR& meta_struct = *data; + const VkSurfaceProtectedCapabilitiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkSurfaceProtectedCapabilitiesKHR& meta_struct = *data; - FieldToJson(jdata["raygenShaderRecordAddress"], to_hex_variable_width(decoded_value.raygenShaderRecordAddress), options); - FieldToJson(jdata["raygenShaderRecordSize"], decoded_value.raygenShaderRecordSize, options); - FieldToJson(jdata["missShaderBindingTableAddress"], to_hex_variable_width(decoded_value.missShaderBindingTableAddress), options); - FieldToJson(jdata["missShaderBindingTableSize"], decoded_value.missShaderBindingTableSize, options); - FieldToJson(jdata["missShaderBindingTableStride"], decoded_value.missShaderBindingTableStride, options); - FieldToJson(jdata["hitShaderBindingTableAddress"], to_hex_variable_width(decoded_value.hitShaderBindingTableAddress), options); - FieldToJson(jdata["hitShaderBindingTableSize"], decoded_value.hitShaderBindingTableSize, options); - FieldToJson(jdata["hitShaderBindingTableStride"], decoded_value.hitShaderBindingTableStride, options); - FieldToJson(jdata["callableShaderBindingTableAddress"], to_hex_variable_width(decoded_value.callableShaderBindingTableAddress), options); - FieldToJson(jdata["callableShaderBindingTableSize"], decoded_value.callableShaderBindingTableSize, options); - FieldToJson(jdata["callableShaderBindingTableStride"], decoded_value.callableShaderBindingTableStride, options); - FieldToJson(jdata["width"], decoded_value.width, options); - FieldToJson(jdata["height"], decoded_value.height, options); - FieldToJson(jdata["depth"], decoded_value.depth, options); + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["supportsProtected"] = static_cast(decoded_value.supportsProtected); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePresentWaitFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceMaintenance5FeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR& meta_struct = *data; + const VkPhysicalDevicePresentWaitFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDevicePresentWaitFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["maintenance5"] = static_cast(decoded_value.maintenance5); + jdata["presentWait"] = static_cast(decoded_value.presentWait); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceMaintenance5PropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR& meta_struct = *data; + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["earlyFragmentMultisampleCoverageAfterSampleCounting"] = static_cast(decoded_value.earlyFragmentMultisampleCoverageAfterSampleCounting); - jdata["earlyFragmentSampleMaskTestBeforeSampleCounting"] = static_cast(decoded_value.earlyFragmentSampleMaskTestBeforeSampleCounting); - jdata["depthStencilSwizzleOneSupport"] = static_cast(decoded_value.depthStencilSwizzleOneSupport); - jdata["polygonModePointSize"] = static_cast(decoded_value.polygonModePointSize); - jdata["nonStrictSinglePixelWideLinesUseParallelogram"] = static_cast(decoded_value.nonStrictSinglePixelWideLinesUseParallelogram); - jdata["nonStrictWideLinesUseParallelogram"] = static_cast(decoded_value.nonStrictWideLinesUseParallelogram); + jdata["pipelineExecutableInfo"] = static_cast(decoded_value.pipelineExecutableInfo); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderingAreaInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkRenderingAreaInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkRenderingAreaInfoKHR& meta_struct = *data; + const VkPipelineInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["viewMask"], decoded_value.viewMask, options); - FieldToJson(jdata["colorAttachmentCount"], decoded_value.colorAttachmentCount, options); - FieldToJson(jdata["pColorAttachmentFormats"], meta_struct.pColorAttachmentFormats, options); - FieldToJson(jdata["depthAttachmentFormat"], decoded_value.depthAttachmentFormat, options); - FieldToJson(jdata["stencilAttachmentFormat"], decoded_value.stencilAttachmentFormat, options); + HandleToJson(jdata["pipeline"], meta_struct.pipeline, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageSubresource2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineExecutablePropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkImageSubresource2KHR& decoded_value = *data->decoded_value; - const Decoded_VkImageSubresource2KHR& meta_struct = *data; + const VkPipelineExecutablePropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineExecutablePropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["imageSubresource"], meta_struct.imageSubresource, options); + FieldToJson(VkShaderStageFlags_t(),jdata["stages"], decoded_value.stages, options); + FieldToJson(jdata["name"], &meta_struct.name, options); + FieldToJson(jdata["description"], &meta_struct.description, options); + FieldToJson(jdata["subgroupSize"], decoded_value.subgroupSize, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDeviceImageSubresourceInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineExecutableInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDeviceImageSubresourceInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkDeviceImageSubresourceInfoKHR& meta_struct = *data; + const VkPipelineExecutableInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineExecutableInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pCreateInfo"], meta_struct.pCreateInfo, options); - FieldToJson(jdata["pSubresource"], meta_struct.pSubresource, options); + HandleToJson(jdata["pipeline"], meta_struct.pipeline, options); + FieldToJson(jdata["executableIndex"], decoded_value.executableIndex, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSubresourceLayout2KHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineExecutableInternalRepresentationKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPipelineExecutableInternalRepresentationKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineExecutableInternalRepresentationKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["name"], &meta_struct.name, options); + FieldToJson(jdata["description"], &meta_struct.description, options); + jdata["isText"] = static_cast(decoded_value.isText); + FieldToJson(jdata["dataSize"], decoded_value.dataSize, options); + FieldToJson(jdata["pData"], meta_struct.pData, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryMapInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkMemoryMapInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkMemoryMapInfoKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkMemoryMapFlags_t(),jdata["flags"], decoded_value.flags, options); + HandleToJson(jdata["memory"], meta_struct.memory, options); + FieldToJson(jdata["offset"], decoded_value.offset, options); + FieldToJson(jdata["size"], decoded_value.size, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryUnmapInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkMemoryUnmapInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkMemoryUnmapInfoKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkMemoryUnmapFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + HandleToJson(jdata["memory"], meta_struct.memory, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineLibraryCreateInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPipelineLibraryCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineLibraryCreateInfoKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["libraryCount"], decoded_value.libraryCount, options); + HandleToJson(jdata["pLibraries"], &meta_struct.pLibraries, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPresentIdKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPresentIdKHR& decoded_value = *data->decoded_value; + const Decoded_VkPresentIdKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["swapchainCount"], decoded_value.swapchainCount, options); + FieldToJson(jdata["pPresentIds"], meta_struct.pPresentIds, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePresentIdFeaturesKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDevicePresentIdFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDevicePresentIdFeaturesKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["presentId"] = static_cast(decoded_value.presentId); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkVideoEncodeInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeInfoKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkVideoEncodeFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + HandleToJson(jdata["dstBuffer"], meta_struct.dstBuffer, options); + FieldToJson(jdata["dstBufferOffset"], decoded_value.dstBufferOffset, options); + FieldToJson(jdata["dstBufferRange"], decoded_value.dstBufferRange, options); + FieldToJson(jdata["srcPictureResource"], meta_struct.srcPictureResource, options); + FieldToJson(jdata["pSetupReferenceSlot"], meta_struct.pSetupReferenceSlot, options); + FieldToJson(jdata["referenceSlotCount"], decoded_value.referenceSlotCount, options); + FieldToJson(jdata["pReferenceSlots"], meta_struct.pReferenceSlots, options); + FieldToJson(jdata["precedingExternallyEncodedBytes"], decoded_value.precedingExternallyEncodedBytes, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeCapabilitiesKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkVideoEncodeCapabilitiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeCapabilitiesKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkVideoEncodeCapabilityFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(VkVideoEncodeRateControlModeFlagsKHR_t(),jdata["rateControlModes"], decoded_value.rateControlModes, options); + FieldToJson(jdata["maxRateControlLayers"], decoded_value.maxRateControlLayers, options); + FieldToJson(jdata["maxBitrate"], decoded_value.maxBitrate, options); + FieldToJson(jdata["maxQualityLevels"], decoded_value.maxQualityLevels, options); + FieldToJson(jdata["encodeInputPictureGranularity"], meta_struct.encodeInputPictureGranularity, options); + FieldToJson(VkVideoEncodeFeedbackFlagsKHR_t(),jdata["supportedEncodeFeedbackFlags"], decoded_value.supportedEncodeFeedbackFlags, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkSubresourceLayout2KHR& decoded_value = *data->decoded_value; - const Decoded_VkSubresourceLayout2KHR& meta_struct = *data; + const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["subresourceLayout"], meta_struct.subresourceLayout, options); + FieldToJson(VkVideoEncodeFeedbackFlagsKHR_t(),jdata["encodeFeedbackFlags"], decoded_value.encodeFeedbackFlags, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineCreateFlags2CreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeUsageInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineCreateFlags2CreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkPipelineCreateFlags2CreateInfoKHR& meta_struct = *data; + const VkVideoEncodeUsageInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeUsageInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkPipelineCreateFlags2KHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(VkVideoEncodeUsageFlagsKHR_t(),jdata["videoUsageHints"], decoded_value.videoUsageHints, options); + FieldToJson(VkVideoEncodeContentFlagsKHR_t(),jdata["videoContentHints"], decoded_value.videoContentHints, options); + FieldToJson(jdata["tuningMode"], decoded_value.tuningMode, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBufferUsageFlags2CreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeRateControlLayerInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkBufferUsageFlags2CreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkBufferUsageFlags2CreateInfoKHR& meta_struct = *data; + const VkVideoEncodeRateControlLayerInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeRateControlLayerInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkBufferUsageFlags2KHR_t(),jdata["usage"], decoded_value.usage, options); + FieldToJson(jdata["averageBitrate"], decoded_value.averageBitrate, options); + FieldToJson(jdata["maxBitrate"], decoded_value.maxBitrate, options); + FieldToJson(jdata["frameRateNumerator"], decoded_value.frameRateNumerator, options); + FieldToJson(jdata["frameRateDenominator"], decoded_value.frameRateDenominator, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeRateControlInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& meta_struct = *data; + const VkVideoEncodeRateControlInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeRateControlInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["rayTracingPositionFetch"] = static_cast(decoded_value.rayTracingPositionFetch); + FieldToJson(VkVideoEncodeRateControlFlagsKHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["rateControlMode"], decoded_value.rateControlMode, options); + FieldToJson(jdata["layerCount"], decoded_value.layerCount, options); + FieldToJson(jdata["pLayers"], meta_struct.pLayers, options); + FieldToJson(jdata["virtualBufferSizeInMs"], decoded_value.virtualBufferSizeInMs, options); + FieldToJson(jdata["initialVirtualBufferSizeInMs"], decoded_value.initialVirtualBufferSizeInMs, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCooperativeMatrixPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkCooperativeMatrixPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkCooperativeMatrixPropertiesKHR& meta_struct = *data; + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["MSize"], decoded_value.MSize, options); - FieldToJson(jdata["NSize"], decoded_value.NSize, options); - FieldToJson(jdata["KSize"], decoded_value.KSize, options); - FieldToJson(jdata["AType"], decoded_value.AType, options); - FieldToJson(jdata["BType"], decoded_value.BType, options); - FieldToJson(jdata["CType"], decoded_value.CType, options); - FieldToJson(jdata["ResultType"], decoded_value.ResultType, options); - jdata["saturatingAccumulation"] = static_cast(decoded_value.saturatingAccumulation); - FieldToJson(jdata["scope"], decoded_value.scope, options); + FieldToJson(jdata["pVideoProfile"], meta_struct.pVideoProfile, options); + FieldToJson(jdata["qualityLevel"], decoded_value.qualityLevel, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeQualityLevelPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& meta_struct = *data; + const VkVideoEncodeQualityLevelPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeQualityLevelPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["cooperativeMatrix"] = static_cast(decoded_value.cooperativeMatrix); - jdata["cooperativeMatrixRobustBufferAccess"] = static_cast(decoded_value.cooperativeMatrixRobustBufferAccess); + FieldToJson(jdata["preferredRateControlMode"], decoded_value.preferredRateControlMode, options); + FieldToJson(jdata["preferredRateControlLayerCount"], decoded_value.preferredRateControlLayerCount, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeQualityLevelInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& meta_struct = *data; + const VkVideoEncodeQualityLevelInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeQualityLevelInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkShaderStageFlags_t(),jdata["cooperativeMatrixSupportedStages"], decoded_value.cooperativeMatrixSupportedStages, options); + FieldToJson(jdata["qualityLevel"], decoded_value.qualityLevel, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeSessionParametersGetInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& meta_struct = *data; + const VkVideoEncodeSessionParametersGetInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeSessionParametersGetInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["maxVertexAttribDivisor"], decoded_value.maxVertexAttribDivisor, options); - jdata["supportsNonZeroFirstInstance"] = static_cast(decoded_value.supportsNonZeroFirstInstance); + HandleToJson(jdata["videoSessionParameters"], meta_struct.videoSessionParameters, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVertexInputBindingDivisorDescriptionKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeSessionParametersFeedbackInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVertexInputBindingDivisorDescriptionKHR& decoded_value = *data->decoded_value; - const Decoded_VkVertexInputBindingDivisorDescriptionKHR& meta_struct = *data; + const VkVideoEncodeSessionParametersFeedbackInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoEncodeSessionParametersFeedbackInfoKHR& meta_struct = *data; - FieldToJson(jdata["binding"], decoded_value.binding, options); - FieldToJson(jdata["divisor"], decoded_value.divisor, options); + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["hasOverrides"] = static_cast(decoded_value.hasOverrides); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkQueueFamilyCheckpointProperties2NV* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineVertexInputDivisorStateCreateInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR& meta_struct = *data; + const VkQueueFamilyCheckpointProperties2NV& decoded_value = *data->decoded_value; + const Decoded_VkQueueFamilyCheckpointProperties2NV& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["vertexBindingDivisorCount"], decoded_value.vertexBindingDivisorCount, options); - FieldToJson(jdata["pVertexBindingDivisors"], meta_struct.pVertexBindingDivisors, options); + FieldToJson(VkPipelineStageFlags2_t(),jdata["checkpointExecutionStageMask"], decoded_value.checkpointExecutionStageMask, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCheckpointData2NV* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& meta_struct = *data; + const VkCheckpointData2NV& decoded_value = *data->decoded_value; + const Decoded_VkCheckpointData2NV& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["vertexAttributeInstanceRateDivisor"] = static_cast(decoded_value.vertexAttributeInstanceRateDivisor); - jdata["vertexAttributeInstanceRateZeroDivisor"] = static_cast(decoded_value.vertexAttributeInstanceRateZeroDivisor); + FieldToJson(VkPipelineStageFlags2_t(),jdata["stage"], decoded_value.stage, options); + FieldToJson(jdata["pCheckpointMarker"], meta_struct.pCheckpointMarker, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCalibratedTimestampInfoKHR* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkCalibratedTimestampInfoKHR& decoded_value = *data->decoded_value; - const Decoded_VkCalibratedTimestampInfoKHR& meta_struct = *data; + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["timeDomain"], decoded_value.timeDomain, options); + jdata["fragmentShaderBarycentric"] = static_cast(decoded_value.fragmentShaderBarycentric); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugReportCallbackCreateInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDebugReportCallbackCreateInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkDebugReportCallbackCreateInfoEXT& meta_struct = *data; + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkDebugReportFlagsEXT_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["pfnCallback"], to_hex_variable_width(meta_struct.pfnCallback), options); - FieldToJson(jdata["pUserData"], to_hex_variable_width(meta_struct.pUserData), options); + jdata["triStripVertexOrderIndependentOfProvokingVertex"] = static_cast(decoded_value.triStripVertexOrderIndependentOfProvokingVertex); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineRasterizationStateRasterizationOrderAMD* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineRasterizationStateRasterizationOrderAMD& decoded_value = *data->decoded_value; - const Decoded_VkPipelineRasterizationStateRasterizationOrderAMD& meta_struct = *data; + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["rasterizationOrder"], decoded_value.rasterizationOrder, options); + jdata["shaderSubgroupUniformControlFlow"] = static_cast(decoded_value.shaderSubgroupUniformControlFlow); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugMarkerObjectNameInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDebugMarkerObjectNameInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkDebugMarkerObjectNameInfoEXT& meta_struct = *data; + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["objectType"], decoded_value.objectType, options); - FieldToJson(jdata["object"], decoded_value.object, options); - FieldToJson(jdata["pObjectName"], &meta_struct.pObjectName, options); + jdata["workgroupMemoryExplicitLayout"] = static_cast(decoded_value.workgroupMemoryExplicitLayout); + jdata["workgroupMemoryExplicitLayoutScalarBlockLayout"] = static_cast(decoded_value.workgroupMemoryExplicitLayoutScalarBlockLayout); + jdata["workgroupMemoryExplicitLayout8BitAccess"] = static_cast(decoded_value.workgroupMemoryExplicitLayout8BitAccess); + jdata["workgroupMemoryExplicitLayout16BitAccess"] = static_cast(decoded_value.workgroupMemoryExplicitLayout16BitAccess); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugMarkerObjectTagInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDebugMarkerObjectTagInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkDebugMarkerObjectTagInfoEXT& meta_struct = *data; + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["objectType"], decoded_value.objectType, options); - FieldToJson(jdata["object"], decoded_value.object, options); - FieldToJson(jdata["tagName"], decoded_value.tagName, options); - FieldToJson(jdata["tagSize"], decoded_value.tagSize, options); - FieldToJson(jdata["pTag"], meta_struct.pTag, options); + jdata["rayTracingMaintenance1"] = static_cast(decoded_value.rayTracingMaintenance1); + jdata["rayTracingPipelineTraceRaysIndirect2"] = static_cast(decoded_value.rayTracingPipelineTraceRaysIndirect2); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugMarkerMarkerInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkTraceRaysIndirectCommand2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDebugMarkerMarkerInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkDebugMarkerMarkerInfoEXT& meta_struct = *data; + const VkTraceRaysIndirectCommand2KHR& decoded_value = *data->decoded_value; + const Decoded_VkTraceRaysIndirectCommand2KHR& meta_struct = *data; - FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pMarkerName"], &meta_struct.pMarkerName, options); - FieldToJson(jdata["color"], &meta_struct.color, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); + FieldToJson(jdata["raygenShaderRecordAddress"], to_hex_variable_width(decoded_value.raygenShaderRecordAddress), options); + FieldToJson(jdata["raygenShaderRecordSize"], decoded_value.raygenShaderRecordSize, options); + FieldToJson(jdata["missShaderBindingTableAddress"], to_hex_variable_width(decoded_value.missShaderBindingTableAddress), options); + FieldToJson(jdata["missShaderBindingTableSize"], decoded_value.missShaderBindingTableSize, options); + FieldToJson(jdata["missShaderBindingTableStride"], decoded_value.missShaderBindingTableStride, options); + FieldToJson(jdata["hitShaderBindingTableAddress"], to_hex_variable_width(decoded_value.hitShaderBindingTableAddress), options); + FieldToJson(jdata["hitShaderBindingTableSize"], decoded_value.hitShaderBindingTableSize, options); + FieldToJson(jdata["hitShaderBindingTableStride"], decoded_value.hitShaderBindingTableStride, options); + FieldToJson(jdata["callableShaderBindingTableAddress"], to_hex_variable_width(decoded_value.callableShaderBindingTableAddress), options); + FieldToJson(jdata["callableShaderBindingTableSize"], decoded_value.callableShaderBindingTableSize, options); + FieldToJson(jdata["callableShaderBindingTableStride"], decoded_value.callableShaderBindingTableStride, options); + FieldToJson(jdata["width"], decoded_value.width, options); + FieldToJson(jdata["height"], decoded_value.height, options); + FieldToJson(jdata["depth"], decoded_value.depth, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDedicatedAllocationImageCreateInfoNV* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDedicatedAllocationImageCreateInfoNV& decoded_value = *data->decoded_value; - const Decoded_VkDedicatedAllocationImageCreateInfoNV& meta_struct = *data; + const VkPhysicalDeviceMaintenance5FeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["dedicatedAllocation"] = static_cast(decoded_value.dedicatedAllocation); + jdata["maintenance5"] = static_cast(decoded_value.maintenance5); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDedicatedAllocationBufferCreateInfoNV* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDedicatedAllocationBufferCreateInfoNV& decoded_value = *data->decoded_value; - const Decoded_VkDedicatedAllocationBufferCreateInfoNV& meta_struct = *data; + const VkPhysicalDeviceMaintenance5PropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["dedicatedAllocation"] = static_cast(decoded_value.dedicatedAllocation); + jdata["earlyFragmentMultisampleCoverageAfterSampleCounting"] = static_cast(decoded_value.earlyFragmentMultisampleCoverageAfterSampleCounting); + jdata["earlyFragmentSampleMaskTestBeforeSampleCounting"] = static_cast(decoded_value.earlyFragmentSampleMaskTestBeforeSampleCounting); + jdata["depthStencilSwizzleOneSupport"] = static_cast(decoded_value.depthStencilSwizzleOneSupport); + jdata["polygonModePointSize"] = static_cast(decoded_value.polygonModePointSize); + jdata["nonStrictSinglePixelWideLinesUseParallelogram"] = static_cast(decoded_value.nonStrictSinglePixelWideLinesUseParallelogram); + jdata["nonStrictWideLinesUseParallelogram"] = static_cast(decoded_value.nonStrictWideLinesUseParallelogram); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDedicatedAllocationMemoryAllocateInfoNV* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderingAreaInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkDedicatedAllocationMemoryAllocateInfoNV& decoded_value = *data->decoded_value; - const Decoded_VkDedicatedAllocationMemoryAllocateInfoNV& meta_struct = *data; + const VkRenderingAreaInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkRenderingAreaInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["image"], meta_struct.image, options); - HandleToJson(jdata["buffer"], meta_struct.buffer, options); + FieldToJson(jdata["viewMask"], decoded_value.viewMask, options); + FieldToJson(jdata["colorAttachmentCount"], decoded_value.colorAttachmentCount, options); + FieldToJson(jdata["pColorAttachmentFormats"], meta_struct.pColorAttachmentFormats, options); + FieldToJson(jdata["depthAttachmentFormat"], decoded_value.depthAttachmentFormat, options); + FieldToJson(jdata["stencilAttachmentFormat"], decoded_value.stencilAttachmentFormat, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageSubresource2KHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceTransformFeedbackFeaturesEXT& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT& meta_struct = *data; + const VkImageSubresource2KHR& decoded_value = *data->decoded_value; + const Decoded_VkImageSubresource2KHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["transformFeedback"] = static_cast(decoded_value.transformFeedback); - jdata["geometryStreams"] = static_cast(decoded_value.geometryStreams); + FieldToJson(jdata["imageSubresource"], meta_struct.imageSubresource, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDeviceImageSubresourceInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPhysicalDeviceTransformFeedbackPropertiesEXT& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT& meta_struct = *data; + const VkDeviceImageSubresourceInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkDeviceImageSubresourceInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["maxTransformFeedbackStreams"], decoded_value.maxTransformFeedbackStreams, options); - FieldToJson(jdata["maxTransformFeedbackBuffers"], decoded_value.maxTransformFeedbackBuffers, options); - FieldToJson(jdata["maxTransformFeedbackBufferSize"], decoded_value.maxTransformFeedbackBufferSize, options); - FieldToJson(jdata["maxTransformFeedbackStreamDataSize"], decoded_value.maxTransformFeedbackStreamDataSize, options); - FieldToJson(jdata["maxTransformFeedbackBufferDataSize"], decoded_value.maxTransformFeedbackBufferDataSize, options); - FieldToJson(jdata["maxTransformFeedbackBufferDataStride"], decoded_value.maxTransformFeedbackBufferDataStride, options); - jdata["transformFeedbackQueries"] = static_cast(decoded_value.transformFeedbackQueries); - jdata["transformFeedbackStreamsLinesTriangles"] = static_cast(decoded_value.transformFeedbackStreamsLinesTriangles); - jdata["transformFeedbackRasterizationStreamSelect"] = static_cast(decoded_value.transformFeedbackRasterizationStreamSelect); - jdata["transformFeedbackDraw"] = static_cast(decoded_value.transformFeedbackDraw); + FieldToJson(jdata["pCreateInfo"], meta_struct.pCreateInfo, options); + FieldToJson(jdata["pSubresource"], meta_struct.pSubresource, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSubresourceLayout2KHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkSubresourceLayout2KHR& decoded_value = *data->decoded_value; + const Decoded_VkSubresourceLayout2KHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["subresourceLayout"], meta_struct.subresourceLayout, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineCreateFlags2CreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkPipelineRasterizationStateStreamCreateInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT& meta_struct = *data; + const VkPipelineCreateFlags2CreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineCreateFlags2CreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkPipelineRasterizationStateStreamCreateFlagsEXT_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["rasterizationStream"], decoded_value.rasterizationStream, options); + FieldToJson(VkPipelineCreateFlags2KHR_t(),jdata["flags"], decoded_value.flags, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageViewHandleInfoNVX* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBufferUsageFlags2CreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkImageViewHandleInfoNVX& decoded_value = *data->decoded_value; - const Decoded_VkImageViewHandleInfoNVX& meta_struct = *data; + const VkBufferUsageFlags2CreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkBufferUsageFlags2CreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - HandleToJson(jdata["imageView"], meta_struct.imageView, options); - FieldToJson(jdata["descriptorType"], decoded_value.descriptorType, options); - HandleToJson(jdata["sampler"], meta_struct.sampler, options); + FieldToJson(VkBufferUsageFlags2KHR_t(),jdata["usage"], decoded_value.usage, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageViewAddressPropertiesNVX* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkImageViewAddressPropertiesNVX& decoded_value = *data->decoded_value; - const Decoded_VkImageViewAddressPropertiesNVX& meta_struct = *data; + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["deviceAddress"], to_hex_variable_width(decoded_value.deviceAddress), options); - FieldToJson(jdata["size"], decoded_value.size, options); + jdata["rayTracingPositionFetch"] = static_cast(decoded_value.rayTracingPositionFetch); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264CapabilitiesEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCooperativeMatrixPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264CapabilitiesEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264CapabilitiesEXT& meta_struct = *data; + const VkCooperativeMatrixPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkCooperativeMatrixPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeH264CapabilityFlagsEXT_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); - FieldToJson(jdata["maxSliceCount"], decoded_value.maxSliceCount, options); - FieldToJson(jdata["maxPPictureL0ReferenceCount"], decoded_value.maxPPictureL0ReferenceCount, options); - FieldToJson(jdata["maxBPictureL0ReferenceCount"], decoded_value.maxBPictureL0ReferenceCount, options); - FieldToJson(jdata["maxL1ReferenceCount"], decoded_value.maxL1ReferenceCount, options); - FieldToJson(jdata["maxTemporalLayerCount"], decoded_value.maxTemporalLayerCount, options); - jdata["expectDyadicTemporalLayerPattern"] = static_cast(decoded_value.expectDyadicTemporalLayerPattern); - FieldToJson(jdata["minQp"], decoded_value.minQp, options); - FieldToJson(jdata["maxQp"], decoded_value.maxQp, options); - jdata["prefersGopRemainingFrames"] = static_cast(decoded_value.prefersGopRemainingFrames); - jdata["requiresGopRemainingFrames"] = static_cast(decoded_value.requiresGopRemainingFrames); - FieldToJson(VkVideoEncodeH264StdFlagsEXT_t(),jdata["stdSyntaxFlags"], decoded_value.stdSyntaxFlags, options); + FieldToJson(jdata["MSize"], decoded_value.MSize, options); + FieldToJson(jdata["NSize"], decoded_value.NSize, options); + FieldToJson(jdata["KSize"], decoded_value.KSize, options); + FieldToJson(jdata["AType"], decoded_value.AType, options); + FieldToJson(jdata["BType"], decoded_value.BType, options); + FieldToJson(jdata["CType"], decoded_value.CType, options); + FieldToJson(jdata["ResultType"], decoded_value.ResultType, options); + jdata["saturatingAccumulation"] = static_cast(decoded_value.saturatingAccumulation); + FieldToJson(jdata["scope"], decoded_value.scope, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264QpEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264QpEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264QpEXT& meta_struct = *data; + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR& meta_struct = *data; - FieldToJson(jdata["qpI"], decoded_value.qpI, options); - FieldToJson(jdata["qpP"], decoded_value.qpP, options); - FieldToJson(jdata["qpB"], decoded_value.qpB, options); + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["cooperativeMatrix"] = static_cast(decoded_value.cooperativeMatrix); + jdata["cooperativeMatrixRobustBufferAccess"] = static_cast(decoded_value.cooperativeMatrixRobustBufferAccess); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264QualityLevelPropertiesEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264QualityLevelPropertiesEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264QualityLevelPropertiesEXT& meta_struct = *data; + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeH264RateControlFlagsEXT_t(),jdata["preferredRateControlFlags"], decoded_value.preferredRateControlFlags, options); - FieldToJson(jdata["preferredGopFrameCount"], decoded_value.preferredGopFrameCount, options); - FieldToJson(jdata["preferredIdrPeriod"], decoded_value.preferredIdrPeriod, options); - FieldToJson(jdata["preferredConsecutiveBFrameCount"], decoded_value.preferredConsecutiveBFrameCount, options); - FieldToJson(jdata["preferredTemporalLayerCount"], decoded_value.preferredTemporalLayerCount, options); - FieldToJson(jdata["preferredConstantQp"], meta_struct.preferredConstantQp, options); - FieldToJson(jdata["preferredMaxL0ReferenceCount"], decoded_value.preferredMaxL0ReferenceCount, options); - FieldToJson(jdata["preferredMaxL1ReferenceCount"], decoded_value.preferredMaxL1ReferenceCount, options); - jdata["preferredStdEntropyCodingModeFlag"] = static_cast(decoded_value.preferredStdEntropyCodingModeFlag); + FieldToJson(VkShaderStageFlags_t(),jdata["cooperativeMatrixSupportedStages"], decoded_value.cooperativeMatrixSupportedStages, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionCreateInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264SessionCreateInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264SessionCreateInfoEXT& meta_struct = *data; + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["useMaxLevelIdc"] = static_cast(decoded_value.useMaxLevelIdc); - FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); + jdata["videoMaintenance1"] = static_cast(decoded_value.videoMaintenance1); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersAddInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoInlineQueryInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264SessionParametersAddInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264SessionParametersAddInfoEXT& meta_struct = *data; + const VkVideoInlineQueryInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkVideoInlineQueryInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["stdSPSCount"], decoded_value.stdSPSCount, options); - FieldToJson(jdata["pStdSPSs"], meta_struct.pStdSPSs, options); - FieldToJson(jdata["stdPPSCount"], decoded_value.stdPPSCount, options); - FieldToJson(jdata["pStdPPSs"], meta_struct.pStdPPSs, options); + HandleToJson(jdata["queryPool"], meta_struct.queryPool, options); + FieldToJson(jdata["firstQuery"], decoded_value.firstQuery, options); + FieldToJson(jdata["queryCount"], decoded_value.queryCount, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersCreateInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264SessionParametersCreateInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264SessionParametersCreateInfoEXT& meta_struct = *data; + const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["maxStdSPSCount"], decoded_value.maxStdSPSCount, options); - FieldToJson(jdata["maxStdPPSCount"], decoded_value.maxStdPPSCount, options); - FieldToJson(jdata["pParametersAddInfo"], meta_struct.pParametersAddInfo, options); + FieldToJson(jdata["maxVertexAttribDivisor"], decoded_value.maxVertexAttribDivisor, options); + jdata["supportsNonZeroFirstInstance"] = static_cast(decoded_value.supportsNonZeroFirstInstance); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersGetInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVertexInputBindingDivisorDescriptionKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264SessionParametersGetInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264SessionParametersGetInfoEXT& meta_struct = *data; + const VkVertexInputBindingDivisorDescriptionKHR& decoded_value = *data->decoded_value; + const Decoded_VkVertexInputBindingDivisorDescriptionKHR& meta_struct = *data; - FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["writeStdSPS"] = static_cast(decoded_value.writeStdSPS); - jdata["writeStdPPS"] = static_cast(decoded_value.writeStdPPS); - FieldToJson(jdata["stdSPSId"], decoded_value.stdSPSId, options); - FieldToJson(jdata["stdPPSId"], decoded_value.stdPPSId, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); + FieldToJson(jdata["binding"], decoded_value.binding, options); + FieldToJson(jdata["divisor"], decoded_value.divisor, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264SessionParametersFeedbackInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoEXT& meta_struct = *data; + const VkPipelineVertexInputDivisorStateCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["hasStdSPSOverrides"] = static_cast(decoded_value.hasStdSPSOverrides); - jdata["hasStdPPSOverrides"] = static_cast(decoded_value.hasStdPPSOverrides); + FieldToJson(jdata["vertexBindingDivisorCount"], decoded_value.vertexBindingDivisorCount, options); + FieldToJson(jdata["pVertexBindingDivisors"], meta_struct.pVertexBindingDivisors, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264NaluSliceInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264NaluSliceInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264NaluSliceInfoEXT& meta_struct = *data; + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["constantQp"], decoded_value.constantQp, options); - FieldToJson(jdata["pStdSliceHeader"], meta_struct.pStdSliceHeader, options); + jdata["vertexAttributeInstanceRateDivisor"] = static_cast(decoded_value.vertexAttributeInstanceRateDivisor); + jdata["vertexAttributeInstanceRateZeroDivisor"] = static_cast(decoded_value.vertexAttributeInstanceRateZeroDivisor); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264PictureInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCalibratedTimestampInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264PictureInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264PictureInfoEXT& meta_struct = *data; + const VkCalibratedTimestampInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkCalibratedTimestampInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["naluSliceEntryCount"], decoded_value.naluSliceEntryCount, options); - FieldToJson(jdata["pNaluSliceEntries"], meta_struct.pNaluSliceEntries, options); - FieldToJson(jdata["pStdPictureInfo"], meta_struct.pStdPictureInfo, options); - jdata["generatePrefixNalu"] = static_cast(decoded_value.generatePrefixNalu); + FieldToJson(jdata["timeDomain"], decoded_value.timeDomain, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264DpbSlotInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264DpbSlotInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264DpbSlotInfoEXT& meta_struct = *data; + const VkPhysicalDeviceMaintenance6FeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pStdReferenceInfo"], meta_struct.pStdReferenceInfo, options); + jdata["maintenance6"] = static_cast(decoded_value.maintenance6); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264ProfileInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264ProfileInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264ProfileInfoEXT& meta_struct = *data; + const VkPhysicalDeviceMaintenance6PropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["stdProfileIdc"], decoded_value.stdProfileIdc, options); + jdata["blockTexelViewCompatibleMultipleLayers"] = static_cast(decoded_value.blockTexelViewCompatibleMultipleLayers); + FieldToJson(jdata["maxCombinedImageSamplerDescriptorCount"], decoded_value.maxCombinedImageSamplerDescriptorCount, options); + jdata["fragmentShadingRateClampCombinerInputs"] = static_cast(decoded_value.fragmentShadingRateClampCombinerInputs); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264RateControlInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindMemoryStatusKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264RateControlInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264RateControlInfoEXT& meta_struct = *data; + const VkBindMemoryStatusKHR& decoded_value = *data->decoded_value; + const Decoded_VkBindMemoryStatusKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeH264RateControlFlagsEXT_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["gopFrameCount"], decoded_value.gopFrameCount, options); - FieldToJson(jdata["idrPeriod"], decoded_value.idrPeriod, options); - FieldToJson(jdata["consecutiveBFrameCount"], decoded_value.consecutiveBFrameCount, options); - FieldToJson(jdata["temporalLayerCount"], decoded_value.temporalLayerCount, options); + FieldToJson(jdata["pResult"], meta_struct.pResult, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264FrameSizeEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindDescriptorSetsInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264FrameSizeEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264FrameSizeEXT& meta_struct = *data; + const VkBindDescriptorSetsInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkBindDescriptorSetsInfoKHR& meta_struct = *data; - FieldToJson(jdata["frameISize"], decoded_value.frameISize, options); - FieldToJson(jdata["framePSize"], decoded_value.framePSize, options); - FieldToJson(jdata["frameBSize"], decoded_value.frameBSize, options); + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkShaderStageFlags_t(),jdata["stageFlags"], decoded_value.stageFlags, options); + HandleToJson(jdata["layout"], meta_struct.layout, options); + FieldToJson(jdata["firstSet"], decoded_value.firstSet, options); + FieldToJson(jdata["descriptorSetCount"], decoded_value.descriptorSetCount, options); + HandleToJson(jdata["pDescriptorSets"], &meta_struct.pDescriptorSets, options); + FieldToJson(jdata["dynamicOffsetCount"], decoded_value.dynamicOffsetCount, options); + FieldToJson(jdata["pDynamicOffsets"], meta_struct.pDynamicOffsets, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264RateControlLayerInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPushConstantsInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264RateControlLayerInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264RateControlLayerInfoEXT& meta_struct = *data; + const VkPushConstantsInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPushConstantsInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["useMinQp"] = static_cast(decoded_value.useMinQp); - FieldToJson(jdata["minQp"], meta_struct.minQp, options); - jdata["useMaxQp"] = static_cast(decoded_value.useMaxQp); - FieldToJson(jdata["maxQp"], meta_struct.maxQp, options); - jdata["useMaxFrameSize"] = static_cast(decoded_value.useMaxFrameSize); - FieldToJson(jdata["maxFrameSize"], meta_struct.maxFrameSize, options); + HandleToJson(jdata["layout"], meta_struct.layout, options); + FieldToJson(VkShaderStageFlags_t(),jdata["stageFlags"], decoded_value.stageFlags, options); + FieldToJson(jdata["offset"], decoded_value.offset, options); + FieldToJson(jdata["size"], decoded_value.size, options); + FieldToJson(jdata["pValues"], meta_struct.pValues, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264GopRemainingFrameInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPushDescriptorSetInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH264GopRemainingFrameInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH264GopRemainingFrameInfoEXT& meta_struct = *data; + const VkPushDescriptorSetInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPushDescriptorSetInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["useGopRemainingFrames"] = static_cast(decoded_value.useGopRemainingFrames); - FieldToJson(jdata["gopRemainingI"], decoded_value.gopRemainingI, options); - FieldToJson(jdata["gopRemainingP"], decoded_value.gopRemainingP, options); - FieldToJson(jdata["gopRemainingB"], decoded_value.gopRemainingB, options); + FieldToJson(VkShaderStageFlags_t(),jdata["stageFlags"], decoded_value.stageFlags, options); + HandleToJson(jdata["layout"], meta_struct.layout, options); + FieldToJson(jdata["set"], decoded_value.set, options); + FieldToJson(jdata["descriptorWriteCount"], decoded_value.descriptorWriteCount, options); + FieldToJson(jdata["pDescriptorWrites"], meta_struct.pDescriptorWrites, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265CapabilitiesEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPushDescriptorSetWithTemplateInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265CapabilitiesEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265CapabilitiesEXT& meta_struct = *data; + const VkPushDescriptorSetWithTemplateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPushDescriptorSetWithTemplateInfoKHR& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeH265CapabilityFlagsEXT_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); - FieldToJson(jdata["maxSliceSegmentCount"], decoded_value.maxSliceSegmentCount, options); - FieldToJson(jdata["maxTiles"], meta_struct.maxTiles, options); - FieldToJson(VkVideoEncodeH265CtbSizeFlagsEXT_t(),jdata["ctbSizes"], decoded_value.ctbSizes, options); - FieldToJson(VkVideoEncodeH265TransformBlockSizeFlagsEXT_t(),jdata["transformBlockSizes"], decoded_value.transformBlockSizes, options); - FieldToJson(jdata["maxPPictureL0ReferenceCount"], decoded_value.maxPPictureL0ReferenceCount, options); - FieldToJson(jdata["maxBPictureL0ReferenceCount"], decoded_value.maxBPictureL0ReferenceCount, options); - FieldToJson(jdata["maxL1ReferenceCount"], decoded_value.maxL1ReferenceCount, options); - FieldToJson(jdata["maxSubLayerCount"], decoded_value.maxSubLayerCount, options); - jdata["expectDyadicTemporalSubLayerPattern"] = static_cast(decoded_value.expectDyadicTemporalSubLayerPattern); - FieldToJson(jdata["minQp"], decoded_value.minQp, options); - FieldToJson(jdata["maxQp"], decoded_value.maxQp, options); - jdata["prefersGopRemainingFrames"] = static_cast(decoded_value.prefersGopRemainingFrames); - jdata["requiresGopRemainingFrames"] = static_cast(decoded_value.requiresGopRemainingFrames); - FieldToJson(VkVideoEncodeH265StdFlagsEXT_t(),jdata["stdSyntaxFlags"], decoded_value.stdSyntaxFlags, options); + HandleToJson(jdata["descriptorUpdateTemplate"], meta_struct.descriptorUpdateTemplate, options); + HandleToJson(jdata["layout"], meta_struct.layout, options); + FieldToJson(jdata["set"], decoded_value.set, options); + FieldToJson(jdata["pData"], meta_struct.pData, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionCreateInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSetDescriptorBufferOffsetsInfoEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265SessionCreateInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265SessionCreateInfoEXT& meta_struct = *data; + const VkSetDescriptorBufferOffsetsInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkSetDescriptorBufferOffsetsInfoEXT& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["useMaxLevelIdc"] = static_cast(decoded_value.useMaxLevelIdc); - FieldToJson(jdata["maxLevelIdc"], decoded_value.maxLevelIdc, options); + FieldToJson(VkShaderStageFlags_t(),jdata["stageFlags"], decoded_value.stageFlags, options); + HandleToJson(jdata["layout"], meta_struct.layout, options); + FieldToJson(jdata["firstSet"], decoded_value.firstSet, options); + FieldToJson(jdata["setCount"], decoded_value.setCount, options); + FieldToJson(jdata["pBufferIndices"], meta_struct.pBufferIndices, options); + FieldToJson(jdata["pOffsets"], meta_struct.pOffsets, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265QpEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265QpEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265QpEXT& meta_struct = *data; + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT& meta_struct = *data; - FieldToJson(jdata["qpI"], decoded_value.qpI, options); - FieldToJson(jdata["qpP"], decoded_value.qpP, options); - FieldToJson(jdata["qpB"], decoded_value.qpB, options); + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkShaderStageFlags_t(),jdata["stageFlags"], decoded_value.stageFlags, options); + HandleToJson(jdata["layout"], meta_struct.layout, options); + FieldToJson(jdata["set"], decoded_value.set, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265QualityLevelPropertiesEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugReportCallbackCreateInfoEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265QualityLevelPropertiesEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265QualityLevelPropertiesEXT& meta_struct = *data; + const VkDebugReportCallbackCreateInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkDebugReportCallbackCreateInfoEXT& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeH265RateControlFlagsEXT_t(),jdata["preferredRateControlFlags"], decoded_value.preferredRateControlFlags, options); - FieldToJson(jdata["preferredGopFrameCount"], decoded_value.preferredGopFrameCount, options); - FieldToJson(jdata["preferredIdrPeriod"], decoded_value.preferredIdrPeriod, options); - FieldToJson(jdata["preferredConsecutiveBFrameCount"], decoded_value.preferredConsecutiveBFrameCount, options); - FieldToJson(jdata["preferredSubLayerCount"], decoded_value.preferredSubLayerCount, options); - FieldToJson(jdata["preferredConstantQp"], meta_struct.preferredConstantQp, options); - FieldToJson(jdata["preferredMaxL0ReferenceCount"], decoded_value.preferredMaxL0ReferenceCount, options); - FieldToJson(jdata["preferredMaxL1ReferenceCount"], decoded_value.preferredMaxL1ReferenceCount, options); + FieldToJson(VkDebugReportFlagsEXT_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["pfnCallback"], to_hex_variable_width(meta_struct.pfnCallback), options); + FieldToJson(jdata["pUserData"], to_hex_variable_width(meta_struct.pUserData), options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersAddInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineRasterizationStateRasterizationOrderAMD* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265SessionParametersAddInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265SessionParametersAddInfoEXT& meta_struct = *data; + const VkPipelineRasterizationStateRasterizationOrderAMD& decoded_value = *data->decoded_value; + const Decoded_VkPipelineRasterizationStateRasterizationOrderAMD& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["stdVPSCount"], decoded_value.stdVPSCount, options); - FieldToJson(jdata["pStdVPSs"], meta_struct.pStdVPSs, options); - FieldToJson(jdata["stdSPSCount"], decoded_value.stdSPSCount, options); - FieldToJson(jdata["pStdSPSs"], meta_struct.pStdSPSs, options); - FieldToJson(jdata["stdPPSCount"], decoded_value.stdPPSCount, options); - FieldToJson(jdata["pStdPPSs"], meta_struct.pStdPPSs, options); + FieldToJson(jdata["rasterizationOrder"], decoded_value.rasterizationOrder, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersCreateInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugMarkerObjectNameInfoEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265SessionParametersCreateInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265SessionParametersCreateInfoEXT& meta_struct = *data; + const VkDebugMarkerObjectNameInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkDebugMarkerObjectNameInfoEXT& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["maxStdVPSCount"], decoded_value.maxStdVPSCount, options); - FieldToJson(jdata["maxStdSPSCount"], decoded_value.maxStdSPSCount, options); - FieldToJson(jdata["maxStdPPSCount"], decoded_value.maxStdPPSCount, options); - FieldToJson(jdata["pParametersAddInfo"], meta_struct.pParametersAddInfo, options); + FieldToJson(jdata["objectType"], decoded_value.objectType, options); + FieldToJson(jdata["object"], decoded_value.object, options); + FieldToJson(jdata["pObjectName"], &meta_struct.pObjectName, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersGetInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugMarkerObjectTagInfoEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265SessionParametersGetInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265SessionParametersGetInfoEXT& meta_struct = *data; + const VkDebugMarkerObjectTagInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkDebugMarkerObjectTagInfoEXT& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["writeStdVPS"] = static_cast(decoded_value.writeStdVPS); - jdata["writeStdSPS"] = static_cast(decoded_value.writeStdSPS); - jdata["writeStdPPS"] = static_cast(decoded_value.writeStdPPS); - FieldToJson(jdata["stdVPSId"], decoded_value.stdVPSId, options); - FieldToJson(jdata["stdSPSId"], decoded_value.stdSPSId, options); - FieldToJson(jdata["stdPPSId"], decoded_value.stdPPSId, options); + FieldToJson(jdata["objectType"], decoded_value.objectType, options); + FieldToJson(jdata["object"], decoded_value.object, options); + FieldToJson(jdata["tagName"], decoded_value.tagName, options); + FieldToJson(jdata["tagSize"], decoded_value.tagSize, options); + FieldToJson(jdata["pTag"], meta_struct.pTag, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugMarkerMarkerInfoEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265SessionParametersFeedbackInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoEXT& meta_struct = *data; + const VkDebugMarkerMarkerInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkDebugMarkerMarkerInfoEXT& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["hasStdVPSOverrides"] = static_cast(decoded_value.hasStdVPSOverrides); - jdata["hasStdSPSOverrides"] = static_cast(decoded_value.hasStdSPSOverrides); - jdata["hasStdPPSOverrides"] = static_cast(decoded_value.hasStdPPSOverrides); + FieldToJson(jdata["pMarkerName"], &meta_struct.pMarkerName, options); + FieldToJson(jdata["color"], &meta_struct.color, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265NaluSliceSegmentInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDedicatedAllocationImageCreateInfoNV* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265NaluSliceSegmentInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265NaluSliceSegmentInfoEXT& meta_struct = *data; + const VkDedicatedAllocationImageCreateInfoNV& decoded_value = *data->decoded_value; + const Decoded_VkDedicatedAllocationImageCreateInfoNV& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["constantQp"], decoded_value.constantQp, options); - FieldToJson(jdata["pStdSliceSegmentHeader"], meta_struct.pStdSliceSegmentHeader, options); + jdata["dedicatedAllocation"] = static_cast(decoded_value.dedicatedAllocation); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265PictureInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDedicatedAllocationBufferCreateInfoNV* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265PictureInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265PictureInfoEXT& meta_struct = *data; + const VkDedicatedAllocationBufferCreateInfoNV& decoded_value = *data->decoded_value; + const Decoded_VkDedicatedAllocationBufferCreateInfoNV& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["naluSliceSegmentEntryCount"], decoded_value.naluSliceSegmentEntryCount, options); - FieldToJson(jdata["pNaluSliceSegmentEntries"], meta_struct.pNaluSliceSegmentEntries, options); - FieldToJson(jdata["pStdPictureInfo"], meta_struct.pStdPictureInfo, options); + jdata["dedicatedAllocation"] = static_cast(decoded_value.dedicatedAllocation); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265DpbSlotInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDedicatedAllocationMemoryAllocateInfoNV* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265DpbSlotInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265DpbSlotInfoEXT& meta_struct = *data; + const VkDedicatedAllocationMemoryAllocateInfoNV& decoded_value = *data->decoded_value; + const Decoded_VkDedicatedAllocationMemoryAllocateInfoNV& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["pStdReferenceInfo"], meta_struct.pStdReferenceInfo, options); + HandleToJson(jdata["image"], meta_struct.image, options); + HandleToJson(jdata["buffer"], meta_struct.buffer, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265ProfileInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265ProfileInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265ProfileInfoEXT& meta_struct = *data; + const VkPhysicalDeviceTransformFeedbackFeaturesEXT& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["stdProfileIdc"], decoded_value.stdProfileIdc, options); + jdata["transformFeedback"] = static_cast(decoded_value.transformFeedback); + jdata["geometryStreams"] = static_cast(decoded_value.geometryStreams); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265RateControlInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265RateControlInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265RateControlInfoEXT& meta_struct = *data; + const VkPhysicalDeviceTransformFeedbackPropertiesEXT& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(VkVideoEncodeH265RateControlFlagsEXT_t(),jdata["flags"], decoded_value.flags, options); - FieldToJson(jdata["gopFrameCount"], decoded_value.gopFrameCount, options); - FieldToJson(jdata["idrPeriod"], decoded_value.idrPeriod, options); - FieldToJson(jdata["consecutiveBFrameCount"], decoded_value.consecutiveBFrameCount, options); - FieldToJson(jdata["subLayerCount"], decoded_value.subLayerCount, options); + FieldToJson(jdata["maxTransformFeedbackStreams"], decoded_value.maxTransformFeedbackStreams, options); + FieldToJson(jdata["maxTransformFeedbackBuffers"], decoded_value.maxTransformFeedbackBuffers, options); + FieldToJson(jdata["maxTransformFeedbackBufferSize"], decoded_value.maxTransformFeedbackBufferSize, options); + FieldToJson(jdata["maxTransformFeedbackStreamDataSize"], decoded_value.maxTransformFeedbackStreamDataSize, options); + FieldToJson(jdata["maxTransformFeedbackBufferDataSize"], decoded_value.maxTransformFeedbackBufferDataSize, options); + FieldToJson(jdata["maxTransformFeedbackBufferDataStride"], decoded_value.maxTransformFeedbackBufferDataStride, options); + jdata["transformFeedbackQueries"] = static_cast(decoded_value.transformFeedbackQueries); + jdata["transformFeedbackStreamsLinesTriangles"] = static_cast(decoded_value.transformFeedbackStreamsLinesTriangles); + jdata["transformFeedbackRasterizationStreamSelect"] = static_cast(decoded_value.transformFeedbackRasterizationStreamSelect); + jdata["transformFeedbackDraw"] = static_cast(decoded_value.transformFeedbackDraw); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265FrameSizeEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265FrameSizeEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265FrameSizeEXT& meta_struct = *data; + const VkPipelineRasterizationStateStreamCreateInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT& meta_struct = *data; - FieldToJson(jdata["frameISize"], decoded_value.frameISize, options); - FieldToJson(jdata["framePSize"], decoded_value.framePSize, options); - FieldToJson(jdata["frameBSize"], decoded_value.frameBSize, options); + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkPipelineRasterizationStateStreamCreateFlagsEXT_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["rasterizationStream"], decoded_value.rasterizationStream, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265RateControlLayerInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageViewHandleInfoNVX* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265RateControlLayerInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265RateControlLayerInfoEXT& meta_struct = *data; + const VkImageViewHandleInfoNVX& decoded_value = *data->decoded_value; + const Decoded_VkImageViewHandleInfoNVX& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["useMinQp"] = static_cast(decoded_value.useMinQp); - FieldToJson(jdata["minQp"], meta_struct.minQp, options); - jdata["useMaxQp"] = static_cast(decoded_value.useMaxQp); - FieldToJson(jdata["maxQp"], meta_struct.maxQp, options); - jdata["useMaxFrameSize"] = static_cast(decoded_value.useMaxFrameSize); - FieldToJson(jdata["maxFrameSize"], meta_struct.maxFrameSize, options); + HandleToJson(jdata["imageView"], meta_struct.imageView, options); + FieldToJson(jdata["descriptorType"], decoded_value.descriptorType, options); + HandleToJson(jdata["sampler"], meta_struct.sampler, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265GopRemainingFrameInfoEXT* data, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageViewAddressPropertiesNVX* data, const JsonOptions& options) { if (data && data->decoded_value) { - const VkVideoEncodeH265GopRemainingFrameInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkVideoEncodeH265GopRemainingFrameInfoEXT& meta_struct = *data; + const VkImageViewAddressPropertiesNVX& decoded_value = *data->decoded_value; + const Decoded_VkImageViewAddressPropertiesNVX& meta_struct = *data; FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["useGopRemainingFrames"] = static_cast(decoded_value.useGopRemainingFrames); - FieldToJson(jdata["gopRemainingI"], decoded_value.gopRemainingI, options); - FieldToJson(jdata["gopRemainingP"], decoded_value.gopRemainingP, options); - FieldToJson(jdata["gopRemainingB"], decoded_value.gopRemainingB, options); + FieldToJson(jdata["deviceAddress"], to_hex_variable_width(decoded_value.deviceAddress), options); + FieldToJson(jdata["size"], decoded_value.size, options); FieldToJson(jdata["pNext"], meta_struct.pNext, options); } } @@ -14559,6 +14730,20 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMultiviewPerView } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["perStageDescriptorSet"] = static_cast(decoded_value.perStageDescriptorSet); + jdata["dynamicPipelineLayout"] = static_cast(decoded_value.dynamicPipelineLayout); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -15170,6 +15355,13 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); @@ -15718,273 +15910,455 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } @@ -16437,261 +16811,114 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT: + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT: + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); FieldToJson(jdata, pnext, options); break; } @@ -18586,6 +18813,13 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); diff --git a/framework/generated/generated_vulkan_struct_to_json.h b/framework/generated/generated_vulkan_struct_to_json.h index 3709294f5..248162d89 100644 --- a/framework/generated/generated_vulkan_struct_to_json.h +++ b/framework/generated/generated_vulkan_struct_to_json.h @@ -409,6 +409,38 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoCodingContr void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeCapabilitiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeUsageInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264CapabilitiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264QpKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264QualityLevelPropertiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionCreateInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersAddInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersGetInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264NaluSliceInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264PictureInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264DpbSlotInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264ProfileInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264RateControlInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264FrameSizeKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264RateControlLayerInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264GopRemainingFrameInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265CapabilitiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionCreateInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265QpKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265PictureInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265DpbSlotInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265ProfileInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265RateControlInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265FrameSizeKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265RateControlLayerInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264ProfileInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264CapabilitiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); @@ -518,11 +550,22 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRa void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCooperativeMatrixPropertiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoInlineQueryInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVertexInputBindingDivisorDescriptionKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCalibratedTimestampInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindMemoryStatusKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindDescriptorSetsInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPushConstantsInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPushDescriptorSetInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPushDescriptorSetWithTemplateInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSetDescriptorBufferOffsetsInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugReportCallbackCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineRasterizationStateRasterizationOrderAMD* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugMarkerObjectNameInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); @@ -536,38 +579,6 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceTr void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageViewHandleInfoNVX* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageViewAddressPropertiesNVX* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264CapabilitiesEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264QpEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264QualityLevelPropertiesEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersAddInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersGetInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264NaluSliceInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264PictureInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264DpbSlotInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264ProfileInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264RateControlInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264FrameSizeEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264RateControlLayerInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH264GopRemainingFrameInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265CapabilitiesEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265QpEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265QualityLevelPropertiesEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersAddInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersGetInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265NaluSliceSegmentInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265PictureInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265DpbSlotInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265ProfileInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265RateControlInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265FrameSizeEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265RateControlLayerInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVideoEncodeH265GopRemainingFrameInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkTextureLODGatherFormatPropertiesAMD* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkShaderResourceUsageAMD* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkShaderStatisticsInfoAMD* data, const util::JsonOptions& options = util::JsonOptions()); @@ -965,6 +976,7 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePi void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceImageProcessing2PropertiesQCOM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSamplerBlockMatchWindowCreateInfoQCOM* data, const util::JsonOptions& options = util::JsonOptions()); diff --git a/framework/generated/vulkan_generators/vulkan_struct_handle_mappers_header_generator.py b/framework/generated/vulkan_generators/vulkan_struct_handle_mappers_header_generator.py index aedbb3bba..eb97bff96 100644 --- a/framework/generated/vulkan_generators/vulkan_struct_handle_mappers_header_generator.py +++ b/framework/generated/vulkan_generators/vulkan_struct_handle_mappers_header_generator.py @@ -93,6 +93,10 @@ def beginFile(self, gen_opts): '#include "decode/vulkan_object_info_table.h"', file=self.outFile ) write('#include "format/platform_types.h"', file=self.outFile) + write( + '#include "decode/custom_vulkan_struct_handle_mappers.h"', + file=self.outFile + ) write( '#include "generated/generated_vulkan_struct_decoders_forward.h"', file=self.outFile