diff --git a/android/framework/decode/CMakeLists.txt b/android/framework/decode/CMakeLists.txt index 3889eab031..b6b2faedba 100644 --- a/android/framework/decode/CMakeLists.txt +++ b/android/framework/decode/CMakeLists.txt @@ -19,6 +19,16 @@ target_sources(gfxrecon_decode ${GFXRECON_SOURCE_DIR}/framework/decode/file_processor.cpp ${GFXRECON_SOURCE_DIR}/framework/decode/preload_file_processor.h ${GFXRECON_SOURCE_DIR}/framework/decode/preload_file_processor.cpp + ${GFXRECON_SOURCE_DIR}/framework/decode/preload_decode_allocator.h + ${GFXRECON_SOURCE_DIR}/framework/decode/preload_decode_allocator.cpp + ${GFXRECON_SOURCE_DIR}/framework/decode/preload_allocator.h + ${GFXRECON_SOURCE_DIR}/framework/decode/preload_allocator.cpp + ${GFXRECON_SOURCE_DIR}/framework/decode/vulkan_preload_replayer_base.h + ${GFXRECON_SOURCE_DIR}/framework/decode/vulkan_preload_replayer_base.cpp + ${GFXRECON_SOURCE_DIR}/framework/decode/vulkan_preload_decoder_base.h + ${GFXRECON_SOURCE_DIR}/framework/decode/vulkan_preload_decoder_base.cpp + ${GFXRECON_SOURCE_DIR}/framework/decode/vulkan_preload_file_processor.h + ${GFXRECON_SOURCE_DIR}/framework/decode/vulkan_preload_file_processor.cpp ${GFXRECON_SOURCE_DIR}/framework/decode/file_transformer.h ${GFXRECON_SOURCE_DIR}/framework/decode/file_transformer.cpp ${GFXRECON_SOURCE_DIR}/framework/decode/handle_pointer_decoder.h @@ -115,6 +125,12 @@ target_sources(gfxrecon_decode ${GFXRECON_SOURCE_DIR}/framework/generated/generated_vulkan_struct_handle_mappers.cpp ${GFXRECON_SOURCE_DIR}/framework/generated/generated_decode_pnext_struct.cpp ${GFXRECON_SOURCE_DIR}/framework/generated/generated_vulkan_object_info_table_base2.h + ${GFXRECON_SOURCE_DIR}/framework/generated/generated_vulkan_struct_packet.h + ${GFXRECON_SOURCE_DIR}/framework/generated/generated_vulkan_preload_decoder.h + ${GFXRECON_SOURCE_DIR}/framework/generated/generated_vulkan_preload_decoder.cpp + ${GFXRECON_SOURCE_DIR}/framework/generated/generated_vulkan_preload_replayer.h + ${GFXRECON_SOURCE_DIR}/framework/generated/generated_vulkan_preload_replayer.cpp + ${GFXRECON_SOURCE_DIR}/framework/generated/generated_vulkan_preload_decode_pnext_struct.cpp ) target_include_directories(gfxrecon_decode diff --git a/android/framework/format/CMakeLists.txt b/android/framework/format/CMakeLists.txt index 65a2ea58fd..0d857cfc8c 100644 --- a/android/framework/format/CMakeLists.txt +++ b/android/framework/format/CMakeLists.txt @@ -7,6 +7,7 @@ target_sources(gfxrecon_format ${GFXRECON_SOURCE_DIR}/framework/format/format_util.h ${GFXRECON_SOURCE_DIR}/framework/format/format_util.cpp ${GFXRECON_SOURCE_DIR}/framework/format/platform_types.h + ${GFXRECON_SOURCE_DIR}/framework/format/packet_call_id.h ) target_include_directories(gfxrecon_format diff --git a/framework/application/application.cpp b/framework/application/application.cpp index be616984d7..6c9b5c5ecc 100644 --- a/framework/application/application.cpp +++ b/framework/application/application.cpp @@ -25,6 +25,9 @@ #include "util/logging.h" #include "util/platform.h" #include "decode/preload_file_processor.h" +#include "decode/vulkan_preload_file_processor.h" + +#include "decode/preload_decode_allocator.h" #if defined(VK_USE_PLATFORM_WIN32_KHR) #include "application/win32_context.h" @@ -155,9 +158,25 @@ void Application::Run() auto preload_frames_count = fps_info_->ShouldPreloadFrames(frame_number); if (preload_frames_count > 0U) { - auto* preload_processor = dynamic_cast(file_processor_); - GFXRECON_ASSERT(preload_processor) - preload_processor->PreloadNextFrames(preload_frames_count); + if (detected_vulkan_) + { + auto* preload_processor = dynamic_cast(file_processor_); + GFXRECON_ASSERT(preload_processor) + decode::PreloadDecodeAllocator::Begin(); + preload_processor->PreloadNextFrames(preload_frames_count); + + fps_info_->BeginFrame(frame_number); + preload_processor->ReplayPreloadedPackets(); + fps_info_->EndFrame(frame_number); + + decode::PreloadDecodeAllocator::End(); + } + else + { + auto* preload_processor = dynamic_cast(file_processor_); + GFXRECON_ASSERT(preload_processor) + preload_processor->PreloadNextFrames(preload_frames_count); + } } fps_info_->BeginFrame(frame_number); diff --git a/framework/application/application.h b/framework/application/application.h index 03e6c2a224..2f70413053 100644 --- a/framework/application/application.h +++ b/framework/application/application.h @@ -89,6 +89,12 @@ class Application final return file_processor_->GetCurrentFrameNumber(); } + void SetAPIDetected(bool detected_d3d12, bool detected_vulkan) + { + detected_d3d12_ = detected_d3d12; + detected_vulkan_ = detected_vulkan; + } + private: // clang-format off std::string name_; ///< Application name to display in window title bar. @@ -99,6 +105,8 @@ class Application final std::unordered_map> wsi_contexts_; ///< Loaded WSI contexts from CLI and VkInstanceCreateInfo std::string cli_wsi_extension_; ///< WSI extension selected on CLI, empty string if no CLI selection graphics::FpsInfo* fps_info_; ///< A optional FPS info object that logs the FPS across a configured framerange. + bool detected_d3d12_; ///:${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_cpp_consumer.h> $<$:${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_cpp_consumer.cpp> $<$:${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_cpp_structs.h> @@ -227,6 +237,12 @@ target_sources(gfxrecon_decode ${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_struct_to_json.h ${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_struct_to_json.cpp ${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_object_info_table_base2.h + ${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_struct_packet.h + ${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_preload_decoder.h + ${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_preload_decoder.cpp + ${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_preload_replayer.h + ${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_preload_replayer.cpp + ${CMAKE_SOURCE_DIR}/framework/generated/generated_vulkan_preload_decode_pnext_struct.cpp $<$:${CMAKE_SOURCE_DIR}/framework/generated/generated_dx12_decoder.h> $<$:${CMAKE_SOURCE_DIR}/framework/generated/generated_dx12_decoder.cpp> $<$:${CMAKE_SOURCE_DIR}/framework/generated/generated_dx12_struct_decoders_forward.h> diff --git a/framework/decode/custom_vulkan_struct_decoders.cpp b/framework/decode/custom_vulkan_struct_decoders.cpp index 6a70ecd473..a0e592fa89 100644 --- a/framework/decode/custom_vulkan_struct_decoders.cpp +++ b/framework/decode/custom_vulkan_struct_decoders.cpp @@ -35,6 +35,7 @@ GFXRECON_BEGIN_NAMESPACE(gfxrecon) GFXRECON_BEGIN_NAMESPACE(decode) size_t DecodePNextStruct(const uint8_t* buffer, size_t buffer_size, PNextNode** pNext); +size_t PreloadDecodePNextStruct(const uint8_t* buffer, size_t buffer_size, PNextNode** pNext); size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearColorValue* wrapper) { @@ -386,5 +387,345 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_SECURITY_ return bytes_read; } +// Preload +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearColorValue* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkClearColorValue* value = wrapper->decoded_value; + + wrapper->uint32.SetExternalMemory(value->uint32, 4); + bytes_read += wrapper->uint32.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearValue* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkClearValue* value = wrapper->decoded_value; + + wrapper->color = PreloadDecodeAllocator::Allocate(); + wrapper->color->decoded_value = &(value->color); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->color); + + return bytes_read; +} + +size_t +PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableStatisticValueKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineExecutableStatisticValueKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->u64)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceOrHostAddressKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceOrHostAddressKHR* value = wrapper->decoded_value; + + bytes_read += + ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); + wrapper->hostAddress = value->deviceAddress; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceOrHostAddressConstKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceOrHostAddressConstKHR* value = wrapper->decoded_value; + + bytes_read += + ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); + wrapper->hostAddress = value->deviceAddress; + + return bytes_read; +} + +size_t +PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryDataKHR* wrapper) +{ + // TODO + GFXRECON_LOG_ERROR("VkAccelerationStructureGeometryDataKHR is not supported"); + return 0; +} + +size_t +PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureMotionInstanceNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAccelerationStructureMotionInstanceNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + + switch (value->type) + { + case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV: + wrapper->staticInstance = PreloadDecodeAllocator::Allocate(); + wrapper->staticInstance->decoded_value = &value->data.staticInstance; + bytes_read += + PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->staticInstance); + break; + case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV: + wrapper->matrixMotionInstance = + PreloadDecodeAllocator::Allocate(); + wrapper->matrixMotionInstance->decoded_value = &value->data.matrixMotionInstance; + bytes_read += + PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->matrixMotionInstance); + break; + case VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV: + wrapper->srtMotionInstance = + PreloadDecodeAllocator::Allocate(); + wrapper->srtMotionInstance->decoded_value = &value->data.srtMotionInstance; + bytes_read += + PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srtMotionInstance); + break; + default: + break; + } + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorImageInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorImageInfo* value = wrapper->decoded_value; + + bytes_read += + ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->sampler)); + value->sampler = VK_NULL_HANDLE; + 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSet* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWriteDescriptorSet* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dstSet)); + value->dstSet = VK_NULL_HANDLE; + bytes_read += + ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBinding)); + bytes_read += + ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstArrayElement)); + bytes_read += + ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorCount)); + bytes_read += + ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorType)); + + wrapper->pImageInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pImageInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImageInfo = wrapper->pImageInfo->GetPointer(); + + wrapper->pBufferInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pBufferInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBufferInfo = wrapper->pBufferInfo->GetPointer(); + + bytes_read += wrapper->pTexelBufferView.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTexelBufferView = wrapper->pTexelBufferView.GetHandlePointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceValueINTEL* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPerformanceValueINTEL* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + + wrapper->data = PreloadDecodeAllocator::Allocate(); + wrapper->data->decoded_value = &(value->data); + + if (value->type == VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL) + { + bytes_read += wrapper->data->valueString.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->data.valueString = wrapper->data->valueString.GetPointer(); + } + else + { + bytes_read += + ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->data.value64)); + } + + return bytes_read; +} + +size_t +PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAccelerationStructureGeometryKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->geometryType)); + + wrapper->geometry = PreloadDecodeAllocator::Allocate(); + + switch (value->geometryType) + { + case VK_GEOMETRY_TYPE_TRIANGLES_KHR: + wrapper->geometry->triangles = + PreloadDecodeAllocator::Allocate(); + wrapper->geometry->triangles->decoded_value = &(value->geometry.triangles); + bytes_read += + PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->geometry->triangles); + break; + case VK_GEOMETRY_TYPE_AABBS_KHR: + wrapper->geometry->aabbs = + PreloadDecodeAllocator::Allocate(); + wrapper->geometry->aabbs->decoded_value = &(value->geometry.aabbs); + bytes_read += + PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->geometry->aabbs); + break; + case VK_GEOMETRY_TYPE_INSTANCES_KHR: + wrapper->geometry->instances = + PreloadDecodeAllocator::Allocate(); + wrapper->geometry->instances->decoded_value = &(value->geometry.instances); + bytes_read += + PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->geometry->instances); + break; + default: + break; + } + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + + return bytes_read; +} + +size_t +PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushDescriptorSetWithTemplateInfoKHR* wrapper) +{ + GFXRECON_ASSERT((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPushDescriptorSetWithTemplateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &value->sType); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &wrapper->pNext); + bytes_read += ValueDecoder::DecodeHandleIdValue( + (buffer + bytes_read), (buffer_size - bytes_read), &wrapper->descriptorUpdateTemplate); + bytes_read += + ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &wrapper->layout); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &value->set); + + if (wrapper->pNext != nullptr) + value->pNext = wrapper->pNext->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_ACL* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + ACL* value = wrapper->decoded_value; + + bytes_read += + ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->AclRevision)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->Sbz1)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->AclSize)); + bytes_read += + ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->AceCount)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->Sbz2)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_SECURITY_DESCRIPTOR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + SECURITY_DESCRIPTOR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->Revision)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->Sbz1)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->Control)); + + // The SID structure has a variable size, so has been packed into an array of bytes. + bytes_read += wrapper->PackedOwner.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->Owner = unpack_sid_struct(wrapper->PackedOwner); + value->Owner = wrapper->Owner; + + bytes_read += wrapper->PackedGroup.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->Group = unpack_sid_struct(wrapper->PackedOwner); + value->Group = wrapper->Group; + + wrapper->Sacl = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->Sacl->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->Sacl = wrapper->Sacl->GetPointer(); + + wrapper->Dacl = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->Dacl->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->Dacl = wrapper->Dacl->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_SECURITY_ATTRIBUTES* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + SECURITY_ATTRIBUTES* value = wrapper->decoded_value; + + uint32_t nLength = 0; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &nLength); + value->nLength = nLength; + + wrapper->lpSecurityDescriptor = + PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->lpSecurityDescriptor->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->lpSecurityDescriptor = wrapper->lpSecurityDescriptor->GetPointer(); + + bytes_read += + ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bInheritHandle)); + + return bytes_read; +} + GFXRECON_END_NAMESPACE(decode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/custom_vulkan_struct_decoders_forward.h b/framework/decode/custom_vulkan_struct_decoders_forward.h index 01f921f02b..0dde66d7b1 100644 --- a/framework/decode/custom_vulkan_struct_decoders_forward.h +++ b/framework/decode/custom_vulkan_struct_decoders_forward.h @@ -71,6 +71,32 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_ACL* wrap size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_SECURITY_DESCRIPTOR* wrapper); size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_SECURITY_ATTRIBUTES* wrapper); +// Preload +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearColorValue* wrapper); +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearValue* wrapper); +size_t +PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableStatisticValueKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceOrHostAddressKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceOrHostAddressConstKHR* wrapper); +size_t +PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryDataKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* buffer, + size_t buffer_size, + Decoded_VkAccelerationStructureMotionInstanceNV* wrapper); + +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorImageInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWriteDescriptorSet* wrapper); +size_t +PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceValueINTEL* wrapper); +size_t +PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryKHR* wrapper); +size_t +PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushDescriptorSetWithTemplateInfoKHR* wrapper); + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_ACL* wrapper); +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_SECURITY_DESCRIPTOR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_SECURITY_ATTRIBUTES* wrapper); + GFXRECON_END_NAMESPACE(decode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/descriptor_update_template_decoder.cpp b/framework/decode/descriptor_update_template_decoder.cpp index 489db47ff1..6bdf972b8c 100644 --- a/framework/decode/descriptor_update_template_decoder.cpp +++ b/framework/decode/descriptor_update_template_decoder.cpp @@ -268,5 +268,230 @@ size_t DescriptorUpdateTemplateDecoder::Decode(const uint8_t* buffer, size_t buf return bytes_read; } +size_t DescriptorUpdateTemplateDecoder::PreloadDecode(const uint8_t* buffer, size_t buffer_size) +{ + size_t bytes_read = DecodeAttributes(buffer, buffer_size); + + // The update template should identify as a struct pointer. + assert(((GetAttributeMask() & format::PointerAttributes::kIsStruct) == format::PointerAttributes::kIsStruct) && + ((GetAttributeMask() & format::PointerAttributes::kIsSingle) == format::PointerAttributes::kIsSingle)); + + if (!IsNull() && HasData()) + { + // Get the total number of encoded values and allocate memory. + bytes_read += + ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &image_info_count_); + bytes_read += + ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &buffer_info_count_); + bytes_read += ValueDecoder::DecodeSizeTValue( + (buffer + bytes_read), (buffer_size - bytes_read), &texel_buffer_view_count_); + + // Offsets of the various result structures in the allocated block that is used to store the decoded + // descriptor template information. + const size_t buffer_info_offset = image_info_count_ * sizeof(VkDescriptorImageInfo); + const size_t texel_buffer_view_offset = + buffer_info_offset + (buffer_info_count_ * sizeof(VkDescriptorBufferInfo)); + size_t total_size = texel_buffer_view_offset + (texel_buffer_view_count_ * sizeof(VkBufferView)); + + // Calculate how many bytes we will read for obligatory information. + // - Image descriptors are composed of 2 handle IDs and an enum + // (see "DecodeStruct" for Decoded_VkDescriptorBufferInfo in generated_custom_vulkan_struct_decoders.cpp) + // - Buffer descriptors are composed of 1 handle ID and 2 sizes + // (see "DecodeStruct" for Decoded_VkDescriptorImageInfo in custom_vulkan_struct_decoder.cpp) + // - Texture descriptors are composed of 1 handle ID (for the VkBufferView) + size_t bytes_to_read = image_info_count_ * ((sizeof(format::HandleId) * 2) + sizeof(format::EnumEncodeType)); + bytes_to_read += buffer_info_count_ * (sizeof(format::HandleId) + (2 * sizeof(format::DeviceSizeEncodeType))); + bytes_to_read += texel_buffer_view_count_ * sizeof(format::HandleId); + + // If there is room still left, then it indicates that there might be optional descriptor types in the capture + // file. It is easier to look forward now and calculate all the memory that is needed to allocate the storage + // memory for all the descriptor templates. + struct OptionalDescriptorInfo + { + VkDescriptorType type; + size_t offset; + size_t count; + }; + std::vector optional_info{}; + while ((bytes_read + bytes_to_read) < buffer_size) + { + // Calculate the size of the optional data and make sure we don't exceed + const size_t optional_start = bytes_read + bytes_to_read; + size_t required_alloc_memory_size = 0; + size_t required_read_memory_size = 0; + size_t optional_data_count = 0; + size_t optional_read_len = ValueDecoder::DecodeSizeTValue( + (buffer + optional_start), (buffer_size - optional_start), &optional_data_count); + if (optional_start + optional_read_len == buffer_size) + { + optional_data_count = 0; + // A few captures in the wild were written with an uninitialized + // struct_count and no additional bytes. Commit 7d190ac9 fixed the encoding format. + GFXRECON_LOG_WARNING_ONCE( + "A deprecated incorrect encoding of DescriptorUpdateTemplate was detected. This " + "capture is probably invalid. Replay may subsequently fail or crash."); + break; + } + else if (optional_data_count > 0) + { + OptionalDescriptorInfo cur_type{}; + cur_type.count = optional_data_count; + + const size_t offset_to_type = optional_start + optional_read_len; + optional_read_len += ValueDecoder::DecodeEnumValue( + (buffer + offset_to_type), (buffer_size - offset_to_type), &cur_type.type); + bool invalid_optional_desc = false; + switch (cur_type.type) + { + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + // The start of the data in the allocated block will be at the end of all the + // previous data. + cur_type.offset = total_size; + + // We will read HandleIds but produce VkAccelerationStructureKHR in the allocated + // memory block. They should be the same, but just make sure that the calculations + // are correct. + required_read_memory_size = sizeof(format::HandleId) * cur_type.count; + required_alloc_memory_size = sizeof(VkAccelerationStructureKHR) * cur_type.count; + break; + case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: + { + cur_type.offset = total_size; + uint32_t num_bytes = cur_type.count; + + // We will read/write raw bytes in the allocated memory block, they should be the same + required_read_memory_size = num_bytes; + required_alloc_memory_size = num_bytes; + break; + } + default: + invalid_optional_desc = true; + // If descriptor_type is not recognized, it is possible the capture file was created with a + // newer version of the capture layer that had support for additional optional descriptor types. + // Display a warning and exit the processing loop. + GFXRECON_LOG_ERROR_ONCE( + "Unrecognized VkDescriptorType %d found when decoding data for descriptor " + "update with template.", + static_cast(cur_type.type)); + break; + } + + if (invalid_optional_desc) + { + // We can not continue because we don't know how large the actual unknown block is. + break; + } + + // Update the total size of what we need to allocate + total_size += required_alloc_memory_size; + + // Update the bytes to read to include this block of data so we can get to the next block. + bytes_to_read += optional_read_len + required_read_memory_size; + + // Save the new optional info to the end of the vector so it stays in order + optional_info.push_back(cur_type); + } + } + + assert(template_memory_ == nullptr); + template_memory_ = PreloadDecodeAllocator::Allocate(total_size); + // Read each value type. + if (image_info_count_ > 0) + { + image_info_ = reinterpret_cast(template_memory_); + decoded_image_info_ = PreloadDecodeAllocator::Allocate(image_info_count_); + + for (size_t i = 0; i < image_info_count_; ++i) + { + decoded_image_info_[i].decoded_value = &image_info_[i]; + bytes_read += + PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), &decoded_image_info_[i]); + } + } + + if (buffer_info_count_ > 0) + { + buffer_info_ = reinterpret_cast(template_memory_ + buffer_info_offset); + decoded_buffer_info_ = PreloadDecodeAllocator::Allocate(buffer_info_count_); + + for (size_t i = 0; i < buffer_info_count_; ++i) + { + decoded_buffer_info_[i].decoded_value = &buffer_info_[i]; + bytes_read += + PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), &decoded_buffer_info_[i]); + } + } + + if (texel_buffer_view_count_ > 0) + { + texel_buffer_views_ = reinterpret_cast(template_memory_ + texel_buffer_view_offset); + decoded_texel_buffer_view_handle_ids_ = + PreloadDecodeAllocator::Allocate(texel_buffer_view_count_); + + bytes_read += ValueDecoder::DecodeHandleIdArray((buffer + bytes_read), + (buffer_size - bytes_read), + decoded_texel_buffer_view_handle_ids_, + texel_buffer_view_count_); + } + + // If we discovered valid optional descriptor types after the standard ones, handle them appropriately. + // They have to be in order because if the above code hits an invalid one, it and anything after + // the invalid block will not be appended to the vector. + for (auto& cur_type : optional_info) + { + // Read the descriptor count and type again and verify it matches what was pre-read. + // This is just to make sure the previous read actual read the data properly. + size_t current_count = 0; + bytes_read += + ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), ¤t_count); + VkDescriptorType current_descriptor_type; + bytes_read += ValueDecoder::DecodeEnumValue( + (buffer + bytes_read), (buffer_size - bytes_read), ¤t_descriptor_type); + assert(current_count == cur_type.count); + assert(current_descriptor_type == cur_type.type); + + switch (cur_type.type) + { + case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: + { + // Just double check that we haven't already created an acceleration struct section + assert(acceleration_structure_khr_count_ == 0); + + acceleration_structure_khr_count_ = cur_type.count; + acceleration_structures_khr_ = + reinterpret_cast(template_memory_ + cur_type.offset); + decoded_acceleration_structure_khr_handle_ids_ = + PreloadDecodeAllocator::Allocate(acceleration_structure_khr_count_); + + bytes_read += ValueDecoder::DecodeHandleIdArray((buffer + bytes_read), + (buffer_size - bytes_read), + decoded_acceleration_structure_khr_handle_ids_, + acceleration_structure_khr_count_); + break; + } + case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: + { + // double check that we haven't already created an inline-uniform-block section + assert(inline_uniform_block_count_ == 0); + inline_uniform_block_count_ = cur_type.count; + inline_uniform_block_ = template_memory_ + cur_type.offset; + + bytes_read += ValueDecoder::DecodeUInt8Array((buffer + bytes_read), + (buffer_size - bytes_read), + inline_uniform_block_, + inline_uniform_block_count_); + break; + } + default: + // This should only trigger if someone added a type to the above while loop and not down here. + assert(false); + break; + } + } + } + assert(bytes_read <= buffer_size); + return bytes_read; +} + GFXRECON_END_NAMESPACE(decode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/descriptor_update_template_decoder.h b/framework/decode/descriptor_update_template_decoder.h index 348e3a1f5f..af6e7c743b 100644 --- a/framework/decode/descriptor_update_template_decoder.h +++ b/framework/decode/descriptor_update_template_decoder.h @@ -82,6 +82,7 @@ class DescriptorUpdateTemplateDecoder : public PointerDecoderBase const uint8_t* GetInlineUniformBlockPointer() const { return inline_uniform_block_; } size_t Decode(const uint8_t* buffer, size_t buffer_size); + size_t PreloadDecode(const uint8_t* buffer, size_t buffer_size); private: uint8_t* template_memory_; diff --git a/framework/decode/file_processor.cpp b/framework/decode/file_processor.cpp index 304fe3bc2f..fa4fc09291 100644 --- a/framework/decode/file_processor.cpp +++ b/framework/decode/file_processor.cpp @@ -30,6 +30,9 @@ #include "util/logging.h" #include "util/platform.h" +#include "decode/preload_decode_allocator.h" +#include "generated/generated_vulkan_struct_packet.h" + #include #include diff --git a/framework/decode/file_processor.h b/framework/decode/file_processor.h index 8b8a9fb6c4..3188a950f7 100644 --- a/framework/decode/file_processor.h +++ b/framework/decode/file_processor.h @@ -87,7 +87,7 @@ class FileProcessor // Returns true if there are more frames to process, false if all frames have been processed or an error has // occurred. Use GetErrorState() to determine error condition. - bool ProcessNextFrame(); + virtual bool ProcessNextFrame(); // Returns false if processing failed. Use GetErrorState() to determine error condition for failure case. bool ProcessAllFrames(); @@ -153,37 +153,39 @@ class FileProcessor /// @brief Incremented at the end of every block successfully processed. uint64_t block_index_; - - private: - bool ProcessFileHeader(); - - virtual bool ProcessBlocks(); - bool ReadParameterBuffer(size_t buffer_size); bool ReadCompressedParameterBuffer(size_t compressed_buffer_size, size_t expected_uncompressed_size, size_t* uncompressed_buffer_size); + private: + bool ProcessFileHeader(); + + virtual bool ProcessBlocks(); + bool IsFileHeaderValid() const { return (file_header_.fourcc == GFXRECON_FOURCC); } bool IsFileValid() const { return (file_descriptor_ && !feof(file_descriptor_) && !ferror(file_descriptor_)); } + protected: + virtual bool IsFileValid() const; + std::vector parameter_buffer_; + std::vector compressed_parameter_buffer_; + uint64_t first_frame_; + bool enable_print_block_info_{ false }; + int64_t block_index_from_{ 0 }; + int64_t block_index_to_{ 0 }; + private: std::string filename_; format::FileHeader file_header_; std::vector file_options_; format::EnabledOptions enabled_options_; - std::vector parameter_buffer_; - std::vector compressed_parameter_buffer_; util::Compressor* compressor_; uint64_t api_call_index_; uint64_t block_limit_; bool capture_uses_frame_markers_; - uint64_t first_frame_; - bool enable_print_block_info_{ false }; - int64_t block_index_from_{ 0 }; - int64_t block_index_to_{ 0 }; }; GFXRECON_END_NAMESPACE(decode) diff --git a/framework/decode/handle_pointer_decoder.h b/framework/decode/handle_pointer_decoder.h index 76436e2c8c..93b4fe572d 100644 --- a/framework/decode/handle_pointer_decoder.h +++ b/framework/decode/handle_pointer_decoder.h @@ -90,6 +90,10 @@ class HandlePointerDecoder const T* GetHandlePointer() const { return handle_data_; } size_t Decode(const uint8_t* buffer, size_t buffer_size) { return decoder_.DecodeHandleId(buffer, buffer_size); } + size_t PreloadDecode(const uint8_t* buffer, size_t buffer_size) + { + return decoder_.PreloadDecodeHandleId(buffer, buffer_size); + } // The value returned is only guaranteed to be valid if the current consumer has called SetConsumerData. void* GetConsumerData(size_t index) const diff --git a/framework/decode/pointer_decoder.h b/framework/decode/pointer_decoder.h index fbe126324c..d3cf6a32fd 100644 --- a/framework/decode/pointer_decoder.h +++ b/framework/decode/pointer_decoder.h @@ -26,6 +26,7 @@ #include "decode/pointer_decoder_base.h" #include "decode/decode_allocator.h" +#include "decode/preload_decode_allocator.h" #include "decode/value_decoder.h" #include "format/format.h" #include "util/defines.h" @@ -136,6 +137,33 @@ class PointerDecoder : public PointerDecoderBase size_t DecodeVkDeviceSize(const uint8_t* buffer, size_t buffer_size) { return DecodeFrom(buffer, buffer_size); } size_t DecodeVkDeviceAddress(const uint8_t* buffer, size_t buffer_size) { return DecodeFrom(buffer, buffer_size); } size_t DecodeSizeT(const uint8_t* buffer, size_t buffer_size) { return DecodeFrom(buffer, buffer_size); } + + // Preload: Decode + size_t PreloadDecodeInt8(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeInt16(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeUInt16(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeInt32(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeUInt32(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeInt64(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeUInt64(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeFloat(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + + // Preload: Decode pointer to a void pointer, encoded with ParameterEncoder::EncodeVoidPtrPtr. + size_t PreloadDecodeVoidPtr(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + + // Preload: Decode for array of bytes. + size_t PreloadDecodeUInt8(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeVoid(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + + // Decode for special types that may require conversion. + size_t PreloadDecodeEnum(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeFlags(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeVkSampleMask(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeHandleId(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeVkDeviceSize(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeVkDeviceAddress(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeSizeT(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + // clang-format on private: @@ -222,6 +250,55 @@ class PointerDecoder : public PointerDecoderBase return bytes_read; } + template + size_t PreloadDecodeFrom(const uint8_t* buffer, size_t buffer_size) + { + size_t bytes_read = DecodeAttributes(buffer, buffer_size); + + // We should not be decoding string arrays or structs. + assert((GetAttributeMask() & (format::PointerAttributes::kIsString | format::PointerAttributes::kIsArray)) != + (format::PointerAttributes::kIsString | format::PointerAttributes::kIsArray)); + assert((GetAttributeMask() & (format::PointerAttributes::kIsWString | format::PointerAttributes::kIsArray)) != + (format::PointerAttributes::kIsWString | format::PointerAttributes::kIsArray)); + assert((GetAttributeMask() & format::PointerAttributes::kIsStruct) != format::PointerAttributes::kIsStruct); + + if (!IsNull()) + { + if (!is_memory_external_) + { + bytes_read += PreloadDecodeInternal((buffer + bytes_read), (buffer_size - bytes_read)); + } + else + { + bytes_read += DecodeExternal((buffer + bytes_read), (buffer_size - bytes_read)); + } + } + + return bytes_read; + } + + template + size_t PreloadDecodeInternal(const uint8_t* buffer, size_t buffer_size) + { + assert(data_ == nullptr); + + size_t bytes_read = 0; + size_t len = GetLength(); + + if (HasData()) + { + data_ = PreloadDecodeAllocator::Allocate(len, false); + bytes_read = ValueDecoder::DecodeArrayFrom(buffer, buffer_size, data_, len); + } + else + { + // Allocate and default initialize + data_ = PreloadDecodeAllocator::Allocate(len); + } + + return bytes_read; + } + private: /// Memory to hold decoded data. Points to an internal allocation when #is_memory_external_ is false and /// to an externally provided allocation when #is_memory_external_ is true. @@ -273,6 +350,29 @@ class PointerDecoder : public PointerDecoderBase size_t DecodeVkDeviceSize(const uint8_t* buffer, size_t buffer_size) { return DecodeFrom(buffer, buffer_size); } size_t DecodeVkDeviceAddress(const uint8_t* buffer, size_t buffer_size) { return DecodeFrom(buffer, buffer_size); } size_t DecodeSizeT(const uint8_t* buffer, size_t buffer_size) { return DecodeFrom(buffer, buffer_size); } + + // Preload: Decode + size_t PreloadDecodeInt32(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeUInt32(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeInt64(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeUInt64(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeFloat(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + + // Preload: Decode pointer to a void pointer, encoded with ParameterEncoder::EncodeVoidPtrPtr. + size_t PreloadDecodeVoidPtr(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + + // Preload: Decode for array of bytes. + size_t PreloadDecodeUInt8(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeVoid(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + + // Preload: Decode for special types that may require conversion. + size_t PreloadDecodeEnum(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeFlags(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeVkSampleMask(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeHandleId(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeVkDeviceSize(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeVkDeviceAddress(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } + size_t PreloadDecodeSizeT(const uint8_t* buffer, size_t buffer_size) { return PreloadDecodeFrom(buffer, buffer_size); } // clang-format on private: @@ -352,6 +452,82 @@ class PointerDecoder : public PointerDecoderBase return bytes_read; } + template + size_t PreloadDecodeFrom(const uint8_t* buffer, size_t buffer_size) + { + size_t bytes_read = DecodeAttributes(buffer, buffer_size); + + // We should not be decoding pointers, arrays, or structs. + assert((GetAttributeMask() & format::PointerAttributes::kIsSingle) != format::PointerAttributes::kIsSingle); + assert((GetAttributeMask() & format::PointerAttributes::kIsArray) != format::PointerAttributes::kIsArray); + assert((GetAttributeMask() & format::PointerAttributes::kIsStruct) != format::PointerAttributes::kIsStruct); + + // We should only be decoding 2D arrays + assert((GetAttributeMask() & format::PointerAttributes::kIsArray2D) == format::PointerAttributes::kIsArray2D); + + if (!IsNull() && HasData()) + { + bytes_read += PreloadDecodeInternal((buffer + bytes_read), (buffer_size - bytes_read)); + } + + return bytes_read; + } + + template + size_t PreloadDecodeInternal(const uint8_t* buffer, size_t buffer_size) + { + assert(data_ == nullptr); + + size_t bytes_read = 0; + size_t len = GetLength(); + + data_ = PreloadDecodeAllocator::Allocate(len, false); + inner_lengths_ = PreloadDecodeAllocator::Allocate(len); + + for (size_t i = 0; i < len; ++i) + { + uint32_t attrib = 0; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &attrib); + + if ((attrib & format::PointerAttributes::kIsNull) != format::PointerAttributes::kIsNull) + { + if ((attrib & format::PointerAttributes::kHasAddress) == format::PointerAttributes::kHasAddress) + { + uint64_t address; + bytes_read += + ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &address); + } + + // We should not be decoding string arrays or structs. + assert((GetAttributeMask() & + (format::PointerAttributes::kIsString | format::PointerAttributes::kIsArray)) != + (format::PointerAttributes::kIsString | format::PointerAttributes::kIsArray)); + assert((GetAttributeMask() & + (format::PointerAttributes::kIsWString | format::PointerAttributes::kIsArray)) != + (format::PointerAttributes::kIsWString | format::PointerAttributes::kIsArray)); + assert((GetAttributeMask() & format::PointerAttributes::kIsStruct) != + format::PointerAttributes::kIsStruct); + + size_t inner_len = 0; + bytes_read += + ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &inner_len); + + T* inner_data = PreloadDecodeAllocator::Allocate(inner_len); + bytes_read += ValueDecoder::DecodeArrayFrom( + (buffer + bytes_read), (buffer_size - bytes_read), inner_data, inner_len); + + data_[i] = inner_data; + inner_lengths_[i] = inner_len; + } + else + { + data_[i] = nullptr; + } + } + + return bytes_read; + } + private: T** data_; ///< Memory to hold decoded data size_t* inner_lengths_; diff --git a/framework/decode/preload_allocator.cpp b/framework/decode/preload_allocator.cpp new file mode 100644 index 0000000000..aaeebd9d00 --- /dev/null +++ b/framework/decode/preload_allocator.cpp @@ -0,0 +1,181 @@ + +/* +** Copyright (c) 2020 LunarG, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#include "decode/preload_allocator.h" +#include +#if defined(WIN32) +#include +#endif + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +static size_t GetAvailableMemorySize() +{ + size_t available_memory_size = 0; +#if defined(ANDROID) || defined(__linux__) + std::string token; + std::ifstream file("/proc/meminfo"); + while (file >> token) + { + if (token == "MemFree:") + { + size_t memory_size; + if (file >> memory_size) + { + available_memory_size += memory_size; + } + } + else if (token == "Buffers:") + { + size_t buffers_size; + if (file >> buffers_size) + { + available_memory_size += buffers_size; + } + } + else if (token == "Cached:") + { + size_t cached_size; + if (file >> cached_size) + { + available_memory_size += cached_size; + } + } + // ignore rest of the line + file.ignore(std::numeric_limits::max(), '\n'); + } + available_memory_size *= 1024; // To bytes +#elif defined(_WIN32) + MEMORYSTATUSEX memory_status; + memory_status.dwLength = sizeof(memory_status); + GlobalMemoryStatusEx(&memory_status); + available_memory_size = static_cast(memory_status.ullAvailPhys); +#else + GFXRECON_LOG_ERROR("Unsupported platform! Failed to get available memory for preload"); + +#endif + return available_memory_size; +} + +PreloadAllocator::PreloadAllocator() : + preload_memory_(nullptr), preload_memory_offset_record_(0), preload_memory_offset_replay_(0), + preload_memory_capacity_(0), preload_memory_free_bytes_(0) +{ + Initialize(); +} + +PreloadAllocator::~PreloadAllocator() +{ + if (preload_memory_ != nullptr) + { + delete[] preload_memory_; + preload_memory_ = nullptr; + } +} + +void PreloadAllocator::AllocateMemory(size_t size) +{ + try + { + preload_memory_ = new char[size]; + preload_memory_capacity_ = size; + preload_memory_free_bytes_ = size; + } + catch (const std::exception& e) + { + GFXRECON_LOG_ERROR("Failed to allocate memory for preload"); + } +} + +void PreloadAllocator::Initialize() +{ + Reset(); + size_t system_available_memory_size = GetAvailableMemorySize(); + AllocateMemory(system_available_memory_size / 2); +} + +void PreloadAllocator::Reset() +{ + // Call destructors of allocated objects + for (auto destructor : destructors_) + { + destructor.destroy(destructor.obj); + } + destructors_.clear(); + + if (preload_memory_ != nullptr) + { + delete[] preload_memory_; + preload_memory_ = nullptr; + } + + preload_memory_offset_record_ = 0; + preload_memory_offset_replay_ = 0; + preload_memory_capacity_ = 0; + preload_memory_free_bytes_ = 0; +} + +void PreloadAllocator::Clear() +{ + Reset(); +} + +void* PreloadAllocator::Allocate(size_t object_bytes, size_t alignment_bytes) +{ + void* result = nullptr; + + // Don't allocate 0 bytes + assert(object_bytes + alignment_bytes > 0); + if (object_bytes + alignment_bytes == 0) + { + return nullptr; + } + + // Find the start position + if (object_bytes < preload_memory_free_bytes_) + { + result = AllocateToBlock(object_bytes, alignment_bytes); + } + else + { + PrintPreloadMemoryError(); + } + + return result; +} + +void* PreloadAllocator::AllocateToBlock(size_t object_bytes, size_t alignment_bytes) +{ + void* block_ptr = reinterpret_cast(preload_memory_ + preload_memory_offset_record_); + void* result = std::align(alignment_bytes, object_bytes, block_ptr, preload_memory_free_bytes_); + if (result != nullptr) + { + preload_memory_free_bytes_ -= object_bytes; + preload_memory_offset_record_ = preload_memory_capacity_ - preload_memory_free_bytes_; + } + return result; +} + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/preload_allocator.h b/framework/decode/preload_allocator.h new file mode 100644 index 0000000000..f3b878ba8d --- /dev/null +++ b/framework/decode/preload_allocator.h @@ -0,0 +1,124 @@ + +/* +** Copyright (c) 2020 LunarG, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#ifndef GFXRECON_DECODE_PRELOAD_ALLOCATOR_H +#define GFXRECON_DECODE_PRELOAD_ALLOCATOR_H + +#include "util/defines.h" +#include "format/format_util.h" + +#include "util/logging.h" + +#include +#include + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +class PreloadAllocator +{ + public: + PreloadAllocator(); + ~PreloadAllocator(); + + void Initialize(); + + template + void Add(T* data) + { + if (IsCopyMemorySafe(sizeof(T))) + { + Save(data); + } + else + { + PrintPreloadMemoryError(); + } + } + + template + T* Allocate(size_t count, bool initialize = true) + { + T* result = reinterpret_cast(Allocate(sizeof(T) * count, alignof(T))); + if ((result != nullptr) && initialize) + { + for (size_t i = 0; i < count; ++i) + { + T* obj = new (result + i) T(); + if (!std::is_trivially_destructible()) + { + destructors_.push_back({ obj, [](const void* x) { static_cast(x)->~T(); } }); + } + } + } + + return result; + } + + void Reset(); + void Clear(); + + private: + inline bool IsCopyMemorySafe(size_t data_size) + { + if (preload_memory_offset_record_ + data_size > preload_memory_capacity_) + return false; + return true; + } + + inline void PrintPreloadMemoryError() + { + GFXRECON_LOG_FATAL("Preload memory is not enough! Run again without preload."); + exit(-1); + } + + template + inline void Save(T* data) + { + memcpy(preload_memory_ + preload_memory_offset_record_, reinterpret_cast(data), sizeof(T)); + preload_memory_offset_record_ += sizeof(T); + } + + void AllocateMemory(size_t size); + void* Allocate(size_t object_bytes, size_t alignment_bytes); + void* AllocateToBlock(size_t object_bytes, size_t alignment_bytes); + + private: + struct Destructor + { + void* obj; + void (*destroy)(const void*); + }; + std::vector destructors_; + + char* preload_memory_; + size_t preload_memory_offset_record_; + size_t preload_memory_offset_replay_; + size_t preload_memory_capacity_; + size_t preload_memory_free_bytes_; +}; + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) + +#endif // GFXRECON_PRELOAD_DECODE_DECODE_ALLOCATOR_H diff --git a/framework/decode/preload_decode_allocator.cpp b/framework/decode/preload_decode_allocator.cpp new file mode 100644 index 0000000000..28bd3e32c5 --- /dev/null +++ b/framework/decode/preload_decode_allocator.cpp @@ -0,0 +1,45 @@ + +/* +** Copyright (c) 2020 LunarG, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#include "decode/preload_decode_allocator.h" + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +PreloadDecodeAllocator* PreloadDecodeAllocator::instance_{ nullptr }; + +void PreloadDecodeAllocator::Begin() +{ + if (instance_ == nullptr) + { + instance_ = new PreloadDecodeAllocator(); + } +} + +void PreloadDecodeAllocator::End() +{ + instance_->allocator_.Clear(); +} + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/preload_decode_allocator.h b/framework/decode/preload_decode_allocator.h new file mode 100644 index 0000000000..1508d28f63 --- /dev/null +++ b/framework/decode/preload_decode_allocator.h @@ -0,0 +1,66 @@ + +/* +** Copyright (c) 2020 LunarG, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#ifndef GFXRECON_DECODE_PRELOAD_DECODE_ALLOCATOR_H +#define GFXRECON_DECODE_PRELOAD_DECODE_ALLOCATOR_H + +#include "util/defines.h" +#include "util/monotonic_allocator.h" + +#include "util/logging.h" +#include "decode/preload_allocator.h" + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +class PreloadDecodeAllocator +{ + public: + // Begin must be called before any calls to Allocate (either initially or since End was called). This ensures + // allocations are not made outside the intended scope. Also creates the allocator instance if it is nullptr. + static void Begin(); + + template + static T* Allocate(size_t count = 1, bool initialize = true) + { + return instance_->allocator_.Allocate(count, initialize); + } + + // // End must be called to release any allocations made since last call to Begin. Currently allocated system memory + // // is re-used for future allocations. + static void End(); + + private: + PreloadDecodeAllocator() : allocator_() {} + + private: + static const size_t kAllocatorBlockSize{ 64 * 1024 }; + static PreloadDecodeAllocator* instance_; + + PreloadAllocator allocator_; +}; + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) + +#endif // GFXRECON_PRELOAD_DECODE_DECODE_ALLOCATOR_H diff --git a/framework/decode/string_array_decoder.h b/framework/decode/string_array_decoder.h index c2cda2f373..ea5468ba1b 100644 --- a/framework/decode/string_array_decoder.h +++ b/framework/decode/string_array_decoder.h @@ -117,6 +117,72 @@ class BasicStringArrayDecoder : public PointerDecoderBase return bytes_read; } + size_t PreloadDecode(const uint8_t* buffer, size_t buffer_size) + { + size_t bytes_read = DecodeAttributes(buffer, buffer_size); + + // We should only be decoding string arrays. + assert((GetAttributeMask() & (DecodeAttrib | format::PointerAttributes::kIsArray)) == + (DecodeAttrib | format::PointerAttributes::kIsArray)); + + if (!IsNull() && HasData()) + { + size_t len = GetLength(); + strings_ = PreloadDecodeAllocator::Allocate(len); + string_attributes_ = PreloadDecodeAllocator::Allocate(len); + string_addresses_ = PreloadDecodeAllocator::Allocate(len); + string_lengths_ = PreloadDecodeAllocator::Allocate(len); + + for (size_t i = 0; i < len; ++i) + { + uint32_t attrib = 0; + bytes_read += + ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &attrib); + + if ((attrib & format::PointerAttributes::kIsNull) != format::PointerAttributes::kIsNull) + { + if ((attrib & format::PointerAttributes::kHasAddress) == format::PointerAttributes::kHasAddress) + { + bytes_read += ValueDecoder::DecodeAddress( + (buffer + bytes_read), (buffer_size - bytes_read), &string_addresses_[i]); + } + + assert((attrib & DecodeAttrib) == DecodeAttrib); + + size_t slen = 0; + bytes_read += + ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &slen); + + CharT* value = PreloadDecodeAllocator::Allocate(slen + 1, false); + + if (((attrib & format::PointerAttributes::kHasData) == format::PointerAttributes::kHasData)) + { + bytes_read += ValueDecoder::DecodeArrayFrom( + (buffer + bytes_read), (buffer_size - bytes_read), value, slen); + value[slen] = '\0'; + } + else + { + value[0] = '\0'; + } + + strings_[i] = value; + string_lengths_[i] = slen; + } + else + { + strings_[i] = nullptr; + string_addresses_[i] = 0; + string_lengths_[i] = 0; + } + + string_attributes_[i] = attrib; + } + } + + return bytes_read; + } + private: CharT** strings_{ nullptr }; uint32_t* string_attributes_{ nullptr }; diff --git a/framework/decode/string_decoder.h b/framework/decode/string_decoder.h index a6c18a52a8..92137d1c02 100644 --- a/framework/decode/string_decoder.h +++ b/framework/decode/string_decoder.h @@ -116,6 +116,62 @@ class BasicStringDecoder : public PointerDecoderBase return bytes_read; } + size_t PreloadDecode(const uint8_t* buffer, size_t buffer_size) + { + size_t bytes_read = DecodeAttributes(buffer, buffer_size); + + // We should only be decoding individual strings. + assert((GetAttributeMask() & DecodeAttrib) == DecodeAttrib); + assert((GetAttributeMask() & format::PointerAttributes::kIsArray) != format::PointerAttributes::kIsArray); + + if (!IsNull() && HasData()) + { + size_t string_len = GetLength(); + size_t alloc_len = string_len + 1; + + if (!is_memory_external_) + { + assert(data_ == nullptr); + + data_ = PreloadDecodeAllocator::Allocate(alloc_len, false); + capacity_ = alloc_len; + bytes_read += ValueDecoder::DecodeArrayFrom( + (buffer + bytes_read), (buffer_size - bytes_read), data_, string_len); + data_[string_len] = '\0'; + } + else + { + assert(data_ != nullptr); + + if (alloc_len <= capacity_) + { + ValueDecoder::DecodeArrayFrom( + (buffer + bytes_read), (buffer_size - bytes_read), data_, string_len); + data_[string_len] = '\0'; + } + else + { + size_t truncate_len = capacity_ - 1; + ValueDecoder::DecodeArrayFrom( + (buffer + bytes_read), (buffer_size - bytes_read), data_, truncate_len); + data_[truncate_len] = '\0'; + + GFXRECON_LOG_WARNING("String decoder's external memory capacity (%" PRIuPTR + ") is smaller than the decoded string size (%" PRIuPTR + "); data will be truncated", + capacity_, + alloc_len); + } + + // We always need to advance the position within the buffer by the amount of data that was expected to + // be decoded, not the actual amount of data decoded if capacity is too small to hold all of the data. + bytes_read += string_len * sizeof(EncodeT); + } + } + + return bytes_read; + } + private: CharT* data_; size_t capacity_; diff --git a/framework/decode/struct_pointer_decoder.h b/framework/decode/struct_pointer_decoder.h index 8d8d51d021..b3d66c3749 100644 --- a/framework/decode/struct_pointer_decoder.h +++ b/framework/decode/struct_pointer_decoder.h @@ -27,6 +27,7 @@ #include "decode/custom_vulkan_struct_decoders_forward.h" #include "decode/pointer_decoder_base.h" #include "decode/decode_allocator.h" +#include "decode/preload_decode_allocator.h" #include "decode/value_decoder.h" #include "format/format.h" #include "generated/generated_vulkan_struct_decoders_forward.h" @@ -155,6 +156,63 @@ class StructPointerDecoder : public PointerDecoderBase return bytes_read; } + size_t PreloadDecode(const uint8_t* buffer, size_t buffer_size) + { + size_t bytes_read = DecodeAttributes(buffer, buffer_size); + + // We should only be decoding structs. + assert((GetAttributeMask() & format::PointerAttributes::kIsStruct) == format::PointerAttributes::kIsStruct); + + if (!IsNull()) + { + size_t len = GetLength(); + + if (!is_memory_external_) + { + assert(struct_memory_ == nullptr); + + struct_memory_ = PreloadDecodeAllocator::Allocate(len); + capacity_ = len; + } + else + { + assert(struct_memory_ != nullptr); + assert(len <= capacity_); + + if ((struct_memory_ == nullptr) || (len > capacity_)) + { + GFXRECON_LOG_WARNING("Struct pointer decoder's external memory capacity (%" PRIuPTR + ") is smaller than the decoded array size (%" PRIuPTR + "); an internal memory allocation will be used instead", + capacity_, + len); + + is_memory_external_ = false; + struct_memory_ = PreloadDecodeAllocator::Allocate(len); + capacity_ = len; + } + } + + decoded_structs_ = PreloadDecodeAllocator::Allocate(len); + + if (HasData()) + { + for (size_t i = 0; i < len; ++i) + { + decoded_structs_[i].decoded_value = &struct_memory_[i]; + + // Note: We only expect this class to be used with structs that have a decode_struct function. + // If an error is encoutered here due to a new struct type, the struct decoders need to be + // updated to support the new type. + bytes_read += + PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), &decoded_structs_[i]); + } + } + } + + return bytes_read; + } + private: /// Memory to hold decoded data. Points to an internal allocation when #is_memory_external_ is false and /// to an externally provided allocation when #is_memory_external_ is true. @@ -184,6 +242,70 @@ class StructPointerDecoder : public PointerDecoderBase const typename T::struct_type** GetPointer() const { return struct_memory_; } + size_t PreloadDecode(const uint8_t* buffer, size_t buffer_size) + { + size_t bytes_read = DecodeAttributes(buffer, buffer_size); + + // We should only be decoding 2D struct arrays. + assert((GetAttributeMask() & (format::PointerAttributes::kIsStruct | format::PointerAttributes::kIsArray2D)) == + (format::PointerAttributes::kIsStruct | format::PointerAttributes::kIsArray2D)); + + if (!IsNull() && HasData()) + { + assert(struct_memory_ == nullptr); + + size_t len = GetLength(); + struct_memory_ = PreloadDecodeAllocator::Allocate(len, false); + decoded_structs_ = PreloadDecodeAllocator::Allocate(len, false); + inner_lens_.resize(len); + for (size_t i = 0; i < len; ++i) + { + uint32_t attrib = 0; + bytes_read += + ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &attrib); + + if ((attrib & format::PointerAttributes::kIsNull) != format::PointerAttributes::kIsNull) + { + if ((attrib & format::PointerAttributes::kHasAddress) == format::PointerAttributes::kHasAddress) + { + uint64_t address; + bytes_read += + ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &address); + } + + assert((attrib & format::PointerAttributes::kIsStruct) == format::PointerAttributes::kIsStruct); + + bytes_read += ValueDecoder::DecodeSizeTValue( + (buffer + bytes_read), (buffer_size - bytes_read), &inner_lens_[i]); + + typename T::struct_type* inner_struct_memory = + PreloadDecodeAllocator::Allocate(inner_lens_[i]); + T* inner_decoded_structs = PreloadDecodeAllocator::Allocate(inner_lens_[i]); + + for (size_t j = 0; j < inner_lens_[i]; ++j) + { + inner_decoded_structs[j].decoded_value = &inner_struct_memory[j]; + // Note: We only expect this class to be used with structs that have a decode_struct function. + // If an error is encoutered here due to a new struct type, the struct decoders need to be + // updated to support the new type. + bytes_read += PreloadDecodeStruct( + (buffer + bytes_read), (buffer_size - bytes_read), &inner_decoded_structs[j]); + } + + struct_memory_[i] = inner_struct_memory; + decoded_structs_[i] = inner_decoded_structs; + } + else + { + struct_memory_[i] = nullptr; + decoded_structs_[i] = nullptr; + } + } + } + + return bytes_read; + } + size_t Decode(const uint8_t* buffer, size_t buffer_size) { size_t bytes_read = DecodeAttributes(buffer, buffer_size); diff --git a/framework/decode/vulkan_detection_consumer.h b/framework/decode/vulkan_detection_consumer.h index b04c6d2d88..f7fe474ed3 100644 --- a/framework/decode/vulkan_detection_consumer.h +++ b/framework/decode/vulkan_detection_consumer.h @@ -43,6 +43,14 @@ class VulkanDetectionConsumer : public VulkanConsumer block_limit_(block_limit), vulkan_consumer_usage_(false) {} bool WasVulkanAPIDetected() { return vulkan_consumer_usage_; } + virtual void Process_vkCreateInstance(const ApiCallInfo& call_info, + VkResult returnValue, + StructPointerDecoder*, + StructPointerDecoder*, + HandlePointerDecoder*) override + { + vulkan_consumer_usage_ = true; + } virtual void Process_vkCreateDevice(const ApiCallInfo& call_info, VkResult returnValue, gfxrecon::format::HandleId physicalDevice, diff --git a/framework/decode/vulkan_pnext_node.h b/framework/decode/vulkan_pnext_node.h index 229c51a047..a8a375e434 100644 --- a/framework/decode/vulkan_pnext_node.h +++ b/framework/decode/vulkan_pnext_node.h @@ -53,6 +53,8 @@ class PNextNode virtual const void* GetMetaStructPointer() const = 0; virtual size_t Decode(const uint8_t* buffer, size_t buffer_size) = 0; + + virtual size_t PreloadDecode(const uint8_t* buffer, size_t buffer_size) = 0; }; template diff --git a/framework/decode/vulkan_pnext_typed_node.h b/framework/decode/vulkan_pnext_typed_node.h index ed1ca22f3d..4283b32016 100644 --- a/framework/decode/vulkan_pnext_typed_node.h +++ b/framework/decode/vulkan_pnext_typed_node.h @@ -59,6 +59,11 @@ class PNextTypedNode : public PNextNode return struct_pointer_.Decode(buffer, buffer_size); } + virtual size_t PreloadDecode(const uint8_t* buffer, size_t buffer_size) override + { + return struct_pointer_.PreloadDecode(buffer, buffer_size); + } + private: StructPointerDecoder struct_pointer_; }; diff --git a/framework/decode/vulkan_preload_decoder_base.cpp b/framework/decode/vulkan_preload_decoder_base.cpp new file mode 100644 index 0000000000..38a12d0753 --- /dev/null +++ b/framework/decode/vulkan_preload_decoder_base.cpp @@ -0,0 +1,733 @@ +/* +** Copyright (c) 2018-2020 Valve Corporation +** Copyright (c) 2018-2020 LunarG, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#include "decode/vulkan_preload_decoder_base.h" +#include "decode/vulkan_struct_packet.h" +#include "generated/generated_vulkan_struct_packet.h" + +#include "decode/descriptor_update_template_decoder.h" +#include "decode/pointer_decoder.h" +#include "decode/value_decoder.h" +#include "format/format.h" + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +template +inline T* VulkanPreloadDecoderBase::SavePointer(void* buffer, size_t size) +{ + T* data_ = reinterpret_cast(PreloadDecodeAllocator::Allocate(size)); + memcpy(data_, buffer, size); + return data_; +} + +void VulkanPreloadDecoderBase::WaitIdle() +{ + for (auto consumer : consumers_) + { + consumer->WaitDevicesIdle(); + } +} + +void VulkanPreloadDecoderBase::DispatchStateBeginMarker(uint64_t frame_number) +{ + for (auto consumer : consumers_) + { + consumer->ProcessStateBeginMarker(frame_number); + } +} + +void VulkanPreloadDecoderBase::DispatchStateEndMarker(uint64_t frame_number) +{ + for (auto consumer : consumers_) + { + consumer->ProcessStateEndMarker(frame_number); + } +} + +void VulkanPreloadDecoderBase::DispatchFrameEndMarker(uint64_t frame_number) +{ + for (auto consumer : consumers_) + { + consumer->ProcessFrameEndMarker(frame_number); + } +} + +void VulkanPreloadDecoderBase::DispatchDisplayMessageCommand(format::ThreadId thread_id, const std::string& message) +{ + Packet_DispatchDisplayMessageCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchDisplayMessageCommand; + packet->thread_id = thread_id; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchFillMemoryCommand( + format::ThreadId thread_id, uint64_t memory_id, uint64_t offset, uint64_t size, const uint8_t* data) +{ + Packet_DispatchFillMemoryCommand* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchFillMemoryCommand; + packet->thread_id = thread_id; + packet->memory_id = memory_id; + packet->offset = offset; + packet->size = size; + + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, size); + packet->data = SavePointer(const_cast(data), size); + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchFixDeviceAddresCommand(const format::FixDeviceAddressCommandHeader& header, + const format::AddressLocationInfo* infos) +{ + Packet_DispatchFixDeviceAddresCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchFixDeviceAddresCommand; + packet->header = header; + packet->infos = SavePointer( + const_cast(infos), header.num_of_locations * sizeof(format::AddressLocationInfo)); + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchExeFileInfo(format::ThreadId thread_id, format::ExeFileInfoBlock& info) +{ + // DX + GFXRECON_UNREFERENCED_PARAMETER(thread_id); + GFXRECON_UNREFERENCED_PARAMETER(info); +} + +void VulkanPreloadDecoderBase::DispatchFillMemoryResourceValueCommand( + const format::FillMemoryResourceValueCommandHeader& command_header, const uint8_t* data) +{ + // DX + GFXRECON_UNREFERENCED_PARAMETER(command_header); + GFXRECON_UNREFERENCED_PARAMETER(data); +} + +void VulkanPreloadDecoderBase::DispatchResizeWindowCommand(format::ThreadId thread_id, + format::HandleId surface_id, + uint32_t width, + uint32_t height) +{ + Packet_DispatchResizeWindowCommand* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchResizeWindowCommand; + packet->thread_id = thread_id; + packet->surface_id = surface_id; + packet->width = width; + packet->height = height; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchResizeWindowCommand2( + format::ThreadId thread_id, format::HandleId surface_id, uint32_t width, uint32_t height, uint32_t pre_transform) +{ + Packet_DispatchResizeWindowCommand2* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchResizeWindowCommand2; + packet->thread_id = thread_id; + packet->surface_id = surface_id; + packet->width = width; + packet->height = height; + packet->pre_transform = pre_transform; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchCreateHardwareBufferCommand( + format::ThreadId thread_id, + format::HandleId memory_id, + uint64_t buffer_id, + uint32_t format, + uint32_t width, + uint32_t height, + uint32_t stride, + uint64_t usage, + uint32_t layers, + const std::vector& plane_info) +{ + Packet_DispatchCreateHardwareBufferCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchCreateHardwareBufferCommand; + packet->thread_id = thread_id; + packet->memory_id = memory_id; + packet->buffer_id = buffer_id; + packet->format = format; + packet->width = width; + packet->height = height; + packet->stride = stride; + packet->usage = usage; + packet->layers = layers; + packet->plane_info = plane_info; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchDestroyHardwareBufferCommand(format::ThreadId thread_id, uint64_t buffer_id) +{ + Packet_DispatchDestroyHardwareBufferCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchDestroyHardwareBufferCommand; + packet->thread_id = thread_id; + packet->buffer_id = buffer_id; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchCreateHeapAllocationCommand(format::ThreadId thread_id, + uint64_t allocation_id, + uint64_t allocation_size) +{ + // DX + GFXRECON_UNREFERENCED_PARAMETER(thread_id); + GFXRECON_UNREFERENCED_PARAMETER(allocation_id); + GFXRECON_UNREFERENCED_PARAMETER(allocation_size); +} + +void VulkanPreloadDecoderBase::DispatchSetDevicePropertiesCommand(format::ThreadId thread_id, + format::HandleId physical_device_id, + uint32_t api_version, + uint32_t driver_version, + uint32_t vendor_id, + uint32_t device_id, + uint32_t device_type, + const uint8_t pipeline_cache_uuid[format::kUuidSize], + const std::string& device_name) +{ + Packet_DispatchSetDevicePropertiesCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchSetDevicePropertiesCommand; + packet->thread_id = thread_id; + packet->physical_device_id = physical_device_id; + packet->api_version = api_version; + packet->driver_version = driver_version; + packet->vendor_id = vendor_id; + packet->device_id = device_id; + packet->device_type = device_type; + for (int i = 0; i < format::kUuidSize; i++) + { + packet->pipeline_cache_uuid[i] = pipeline_cache_uuid[i]; + } + packet->device_name = device_name; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchSetDeviceMemoryPropertiesCommand( + format::ThreadId thread_id, + format::HandleId physical_device_id, + const std::vector& memory_types, + const std::vector& memory_heaps) +{ + Packet_DispatchSetDeviceMemoryPropertiesCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchSetDeviceMemoryPropertiesCommand; + packet->thread_id = thread_id; + packet->physical_device_id = physical_device_id; + packet->memory_types = memory_types; + packet->memory_heaps = memory_heaps; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchSetOpaqueAddressCommand(format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId object_id, + uint64_t address) +{ + Packet_DispatchSetOpaqueAddressCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchSetOpaqueAddressCommand; + packet->thread_id = thread_id; + packet->device_id = device_id; + packet->object_id = object_id; + packet->address = address; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchSetRayTracingShaderGroupHandlesCommand(format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId pipeline_id, + size_t data_size, + const uint8_t* data) +{ + Packet_DispatchSetRayTracingShaderGroupHandlesCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchSetRayTracingShaderGroupHandlesCommand; + packet->thread_id = thread_id; + packet->device_id = device_id; + packet->pipeline_id = pipeline_id; + packet->data_size = data_size; + + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, data_size); + packet->data = SavePointer(const_cast(data), data_size); + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchSetSwapchainImageStateCommand( + format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId swapchain_id, + uint32_t last_presented_image, + const std::vector& image_state) +{ + Packet_DispatchSetSwapchainImageStateCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchSetSwapchainImageStateCommand; + packet->thread_id = thread_id; + packet->device_id = device_id; + packet->swapchain_id = swapchain_id; + packet->last_presented_image = last_presented_image; + packet->image_state = image_state; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchBeginResourceInitCommand(format::ThreadId thread_id, + format::HandleId device_id, + uint64_t max_resource_size, + uint64_t max_copy_size) +{ + Packet_DispatchBeginResourceInitCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchBeginResourceInitCommand; + packet->thread_id = thread_id; + packet->device_id = device_id; + packet->max_resource_size = max_resource_size; + packet->max_copy_size = max_copy_size; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchEndResourceInitCommand(format::ThreadId thread_id, format::HandleId device_id) +{ + Packet_DispatchEndResourceInitCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchEndResourceInitCommand; + packet->thread_id = thread_id; + packet->device_id = device_id; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchInitBufferCommand(format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId buffer_id, + uint64_t data_size, + const uint8_t* data) +{ + Packet_DispatchInitBufferCommand* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchInitBufferCommand; + packet->thread_id = thread_id; + packet->device_id = device_id; + packet->buffer_id = buffer_id; + packet->data_size = data_size; + + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, data_size); + packet->data = SavePointer(const_cast(data), data_size); + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchInitImageCommand(format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId image_id, + uint64_t data_size, + uint32_t aspect, + uint32_t layout, + const std::vector& level_sizes, + const uint8_t* data) +{ + Packet_DispatchInitImageCommand* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchInitImageCommand; + packet->thread_id = thread_id; + packet->device_id = device_id; + packet->image_id = image_id; + packet->aspect = aspect; + packet->layout = layout; + packet->level_sizes = level_sizes; + + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, data_size); + packet->data = SavePointer(const_cast(data), data_size); + + AddPacket(reinterpret_cast(packet)); +} + +/// @note Dead code, never called. +/// @note The Vulkan Layer does not encode this and no Vulkan consumers process it. It is one of several DX12-specific +/// metablocks which could have stubbed ({}) versions of their dispatch functions in ApiDecoder. +void VulkanPreloadDecoderBase::DispatchInitSubresourceCommand( + const format::InitSubresourceCommandHeader& command_header, const uint8_t* data) +{ + // DX + GFXRECON_UNREFERENCED_PARAMETER(command_header); + GFXRECON_UNREFERENCED_PARAMETER(data); +} + +size_t VulkanPreloadDecoderBase::PreloadDecode_vkUpdateDescriptorSetWithTemplate(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId descriptorSet; + format::HandleId descriptorUpdateTemplate; + DescriptorUpdateTemplateDecoder pData; + + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorSet); + bytes_read += ValueDecoder::DecodeHandleIdValue( + (parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorUpdateTemplate); + bytes_read += pData.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkUpdateDescriptorSetWithTemplate* packet = new Packet_vkUpdateDescriptorSetWithTemplate; + packet->packet_id = gfxrecon::format::PacketCall_vkUpdateDescriptorSetWithTemplate; + packet->call_info = call_info; + packet->device = device; + packet->descriptorSet = descriptorSet; + packet->descriptorUpdateTemplate = descriptorUpdateTemplate; + packet->pData = pData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoderBase::PreloadDecode_vkCmdPushDescriptorSetWithTemplateKHR(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId descriptorUpdateTemplate; + format::HandleId layout; + uint32_t set; + DescriptorUpdateTemplateDecoder pData; + + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue( + (parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorUpdateTemplate); + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &layout); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &set); + bytes_read += pData.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPushDescriptorSetWithTemplateKHR* packet = new Packet_vkCmdPushDescriptorSetWithTemplateKHR; + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPushDescriptorSetWithTemplateKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->descriptorUpdateTemplate = descriptorUpdateTemplate; + packet->layout = layout; + packet->set = set; + packet->pData = pData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoderBase::PreloadDecode_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)); + bytes_read += pPushDescriptorSetWithTemplateInfo.GetMetaStructPointer()->pData.PreloadDecode( + (parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPushDescriptorSetWithTemplate2KHR* packet = new Packet_vkCmdPushDescriptorSetWithTemplate2KHR; + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPushDescriptorSetWithTemplate2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pPushDescriptorSetWithTemplateInfo = pPushDescriptorSetWithTemplateInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoderBase::PreloadDecode_vkUpdateDescriptorSetWithTemplateKHR(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId descriptorSet; + format::HandleId descriptorUpdateTemplate; + DescriptorUpdateTemplateDecoder pData; + + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorSet); + bytes_read += ValueDecoder::DecodeHandleIdValue( + (parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorUpdateTemplate); + bytes_read += pData.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkUpdateDescriptorSetWithTemplateKHR* packet = new Packet_vkUpdateDescriptorSetWithTemplateKHR; + packet->packet_id = gfxrecon::format::PacketCall_vkUpdateDescriptorSetWithTemplateKHR; + packet->call_info = call_info; + packet->device = device; + packet->descriptorSet = descriptorSet; + packet->descriptorUpdateTemplate = descriptorUpdateTemplate; + packet->pData = pData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoderBase::PreloadDecode_vkCreateRayTracingPipelinesKHR(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId deferredOperation; + format::HandleId pipelineCache; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; + VkResult return_value; + + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue( + (parameter_buffer + bytes_read), (buffer_size - bytes_read), &deferredOperation); + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineCache); + bytes_read += + ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &createInfoCount); + bytes_read += pCreateInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPipelines.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += + ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateRayTracingPipelinesKHR* packet = new Packet_vkCreateRayTracingPipelinesKHR; + packet->packet_id = gfxrecon::format::PacketCall_vkCreateRayTracingPipelinesKHR; + packet->call_info = call_info; + packet->returnValue = return_value; + packet->device = device; + packet->deferredOperation = deferredOperation; + packet->pipelineCache = pipelineCache; + packet->createInfoCount = createInfoCount; + packet->pCreateInfos = pCreateInfos; + packet->pAllocator = pAllocator; + packet->pPipelines = pPipelines; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoderBase::PreloadDecode_vkDeferredOperationJoinKHR(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId operation; + VkResult return_value; + + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += + ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &operation); + bytes_read += + ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkDeferredOperationJoinKHR* packet = new Packet_vkDeferredOperationJoinKHR; + packet->packet_id = gfxrecon::format::PacketCall_vkDeferredOperationJoinKHR; + packet->call_info = call_info; + packet->return_value = return_value; + packet->device = device; + packet->operation = operation; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +void VulkanPreloadDecoderBase::DecodeFunctionCall(format::ApiCallId call_id, + const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size) +{ + GFXRECON_UNREFERENCED_PARAMETER(call_info); + + switch (call_id) + { + case format::ApiCallId::ApiCall_vkUpdateDescriptorSetWithTemplate: + PreloadDecode_vkUpdateDescriptorSetWithTemplate(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPushDescriptorSetWithTemplateKHR: + PreloadDecode_vkCmdPushDescriptorSetWithTemplateKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkUpdateDescriptorSetWithTemplateKHR: + PreloadDecode_vkUpdateDescriptorSetWithTemplateKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateRayTracingPipelinesKHR: + PreloadDecode_vkCreateRayTracingPipelinesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPushDescriptorSetWithTemplate2KHR: + PreloadDecode_vkCmdPushDescriptorSetWithTemplate2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDeferredOperationJoinKHR: + PreloadDecode_vkDeferredOperationJoinKHR(call_info, parameter_buffer, buffer_size); + break; + default: + break; + } +} + +void VulkanPreloadDecoderBase::DispatchSetTlasToBlasDependencyCommand(format::HandleId tlas, + const std::vector& blases) +{ + Packet_DispatchSetTlasToBlasDependencyCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchSetTlasToBlasDependencyCommand; + packet->tlas = tlas; + packet->blases = blases; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchVulkanAccelerationStructuresBuildMetaCommand(const uint8_t* parameter_buffer, + size_t buffer_size) +{ + + format::HandleId device_id; + StructPointerDecoder pInfos; + StructPointerDecoder ppRangeInfos; + + std::size_t bytes_read = ValueDecoder::DecodeHandleIdValue(parameter_buffer, buffer_size, &device_id); + bytes_read += pInfos.PreloadDecode(parameter_buffer + bytes_read, buffer_size - bytes_read); + bytes_read += ppRangeInfos.PreloadDecode(parameter_buffer + bytes_read, buffer_size - bytes_read); + + std::vector> instance_buffers; + if (bytes_read < buffer_size) + { + for (uint32_t i = 0; i < pInfos.GetLength(); ++i) + { + if (pInfos.GetPointer()[i].type != VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR) + { + continue; + } + + uint32_t geometry_count = pInfos.GetPointer()[i].geometryCount; + for (uint32_t g = 0; g < geometry_count; ++g) + { + instance_buffers.emplace_back( + std::vector(ppRangeInfos.GetPointer()[g]->primitiveCount)); + util::platform::MemoryCopy(instance_buffers.back().data(), + instance_buffers.back().size() * sizeof(VkAccelerationStructureInstanceKHR), + parameter_buffer + bytes_read, + instance_buffers.back().size() * sizeof(VkAccelerationStructureInstanceKHR)); + bytes_read += instance_buffers.back().size() * sizeof(VkAccelerationStructureInstanceKHR); + } + } + } + + Packet_DispatchVulkanAccelerationStructuresBuildMetaCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchVulkanAccelerationStructuresBuildMetaCommand; + packet->device = device_id; + packet->info_count = pInfos.GetLength(); + packet->pInfos = pInfos; + packet->ppRangeInfos = ppRangeInfos; + packet->instance_buffers_data = instance_buffers; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchVulkanAccelerationStructuresCopyMetaCommand(const uint8_t* parameter_buffer, + size_t buffer_size) +{ + format::HandleId device_id; + StructPointerDecoder pInfos; + + std::size_t bytes_read = ValueDecoder::DecodeHandleIdValue(parameter_buffer, buffer_size, &device_id); + bytes_read += pInfos.PreloadDecode(parameter_buffer + bytes_read, buffer_size - bytes_read); + + Packet_DispatchVulkanAccelerationStructuresCopyMetaCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchVulkanAccelerationStructuresCopyMetaCommand; + packet->device = device_id; + packet->copy_infos = pInfos; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand( + const uint8_t* parameter_buffer, size_t buffer_size) +{ + format::HandleId device_id; + VkQueryType query_type; + format::HandleId acceleration_structure_id; + + std::size_t bytes_read = ValueDecoder::DecodeHandleIdValue(parameter_buffer, sizeof(format::HandleId), &device_id); + bytes_read += ValueDecoder::DecodeEnumValue(parameter_buffer + bytes_read, sizeof(VkQueryType), &query_type); + bytes_read += ValueDecoder::DecodeHandleIdValue( + parameter_buffer + bytes_read, sizeof(format::HandleId), &acceleration_structure_id); + + Packet_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand* packet = + PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand; + packet->copy_query_typeinfos = query_type; + packet->acceleration_structure_id = acceleration_structure_id; + + AddPacket(reinterpret_cast(packet)); +} + +void VulkanPreloadDecoderBase::SetCurrentBlockIndex(uint64_t block_index) +{ + for (auto consumer : consumers_) + { + consumer->SetCurrentBlockIndex(block_index); + } +} + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/vulkan_preload_decoder_base.h b/framework/decode/vulkan_preload_decoder_base.h new file mode 100644 index 0000000000..9fbb20acf3 --- /dev/null +++ b/framework/decode/vulkan_preload_decoder_base.h @@ -0,0 +1,261 @@ +/* +** Copyright (c) 2018-2020 Valve Corporation +** Copyright (c) 2018-2020 LunarG, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#ifndef GFXRECON_DECODE_VULKAN_PRELOAD_DECODER_BASE_H +#define GFXRECON_DECODE_VULKAN_PRELOAD_DECODER_BASE_H + +#include "decode/api_decoder.h" +#include "format/api_call_id.h" +#include "format/format.h" +#include "format/platform_types.h" +#include "generated/generated_vulkan_consumer.h" +#include "util/defines.h" +#include "decoder_util.h" + +#include "vulkan/vulkan.h" + +#include +#include +#include + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +class VulkanPreloadDecoderBase : public ApiDecoder +{ + public: + VulkanPreloadDecoderBase() {} + + virtual ~VulkanPreloadDecoderBase() override {} + + std::vector& GetPackets() { return container_; } + + void AddConsumer(VulkanConsumer* consumer) { consumers_.push_back(consumer); } + + void RemoveConsumer(VulkanConsumer* consumer) + { + consumers_.erase(std::remove(consumers_.begin(), consumers_.end(), consumer)); + } + + virtual void WaitIdle() override; + + virtual bool IsComplete(uint64_t block_index) override + { + return decode::IsComplete(consumers_, block_index); + } + + virtual bool SupportsApiCall(format::ApiCallId call_id) override + { + return (format::GetApiCallFamily(call_id) == format::ApiFamilyId::ApiFamily_Vulkan); + } + + virtual bool SupportsMetaDataId(format::MetaDataId meta_data_id) override + { + // For backwards compatibility, an encoded API of ApiFamily_None indicates the Vulkan API. + format::ApiFamilyId api = format::GetMetaDataApi(meta_data_id); + return (api == format::ApiFamilyId::ApiFamily_None) || (api == format::ApiFamilyId::ApiFamily_Vulkan); + } + + virtual void DecodeFunctionCall(format::ApiCallId call_id, + const ApiCallInfo& call_options, + const uint8_t* parameter_buffer, + size_t buffer_size) override; + + virtual void DispatchStateBeginMarker(uint64_t frame_number) override; + + virtual void DispatchStateEndMarker(uint64_t frame_number) override; + + virtual void DispatchFrameEndMarker(uint64_t frame_number) override; + + virtual void DispatchDisplayMessageCommand(format::ThreadId thread_id, const std::string& message) override; + + virtual void DispatchFillMemoryCommand( + format::ThreadId thread_id, uint64_t memory_id, uint64_t offset, uint64_t size, const uint8_t* data) override; + + virtual void DispatchFixDeviceAddresCommand(const format::FixDeviceAddressCommandHeader& header, + const format::AddressLocationInfo* infos) override; + + virtual void + DispatchFillMemoryResourceValueCommand(const format::FillMemoryResourceValueCommandHeader& command_header, + const uint8_t* data) override; + + virtual void DispatchResizeWindowCommand(format::ThreadId thread_id, + format::HandleId surface_id, + uint32_t width, + uint32_t height) override; + + virtual void DispatchResizeWindowCommand2(format::ThreadId thread_id, + format::HandleId surface_id, + uint32_t width, + uint32_t height, + uint32_t pre_transform) override; + + virtual void + DispatchCreateHardwareBufferCommand(format::ThreadId thread_id, + format::HandleId memory_id, + uint64_t buffer_id, + uint32_t format, + uint32_t width, + uint32_t height, + uint32_t stride, + uint64_t usage, + uint32_t layers, + const std::vector& plane_info) override; + + virtual void DispatchDestroyHardwareBufferCommand(format::ThreadId thread_id, uint64_t buffer_id) override; + + virtual void DispatchCreateHeapAllocationCommand(format::ThreadId thread_id, + uint64_t allocation_id, + uint64_t allocation_size) override; + + virtual void DispatchSetDevicePropertiesCommand(format::ThreadId thread_id, + format::HandleId physical_device_id, + uint32_t api_version, + uint32_t driver_version, + uint32_t vendor_id, + uint32_t device_id, + uint32_t device_type, + const uint8_t pipeline_cache_uuid[format::kUuidSize], + const std::string& device_name) override; + + virtual void + DispatchSetDeviceMemoryPropertiesCommand(format::ThreadId thread_id, + format::HandleId physical_device_id, + const std::vector& memory_types, + const std::vector& memory_heaps) override; + + virtual void DispatchSetOpaqueAddressCommand(format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId object_id, + uint64_t address) override; + + virtual void DispatchSetRayTracingShaderGroupHandlesCommand(format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId pipeline_id, + size_t data_size, + const uint8_t* data) override; + + virtual void + DispatchSetSwapchainImageStateCommand(format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId swapchain_id, + uint32_t last_presented_image, + const std::vector& image_state) override; + + virtual void DispatchBeginResourceInitCommand(format::ThreadId thread_id, + format::HandleId device_id, + uint64_t max_resource_size, + uint64_t max_copy_size) override; + + virtual void DispatchEndResourceInitCommand(format::ThreadId thread_id, format::HandleId device_id) override; + + virtual void DispatchInitBufferCommand(format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId buffer_id, + uint64_t data_size, + const uint8_t* data) override; + + virtual void DispatchInitImageCommand(format::ThreadId thread_id, + format::HandleId device_id, + format::HandleId image_id, + uint64_t data_size, + uint32_t aspect, + uint32_t layout, + const std::vector& level_sizes, + const uint8_t* data) override; + + virtual void DispatchInitSubresourceCommand(const format::InitSubresourceCommandHeader& command_header, + const uint8_t* data) override; + + virtual void DispatchSetTlasToBlasDependencyCommand(format::HandleId tlas, + const std::vector& blases) override; + + virtual void DispatchInitDx12AccelerationStructureCommand( + const format::InitDx12AccelerationStructureCommandHeader& command_header, + std::vector& geometry_descs, + const uint8_t* build_inputs_data) override + {} + + virtual void DispatchDriverInfo(format::ThreadId thread_id, format::DriverInfoBlock& info) override {} + + virtual void DispatchExeFileInfo(format::ThreadId thread_id, format::ExeFileInfoBlock& info) override; + + virtual void DispatchVulkanAccelerationStructuresBuildMetaCommand(const uint8_t* parameter_buffer, + size_t buffer_size) override; + virtual void DispatchVulkanAccelerationStructuresCopyMetaCommand(const uint8_t* parameter_buffer, + size_t buffer_size) override; + + virtual void DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand(const uint8_t* parameter_buffer, + size_t buffer_size) override; + virtual void SetCurrentBlockIndex(uint64_t block_index) override; + + protected: + const std::vector& GetConsumers() const { return consumers_; } + void AddPacket(void* packet) { container_.push_back(packet); } + + private: + size_t PreloadDecode_vkUpdateDescriptorSetWithTemplate(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size); + + size_t PreloadDecode_vkCmdPushDescriptorSetWithTemplateKHR(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size); + + size_t PreloadDecode_vkCmdPushDescriptorSetWithTemplate2KHR(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size); + + size_t PreloadDecode_vkUpdateDescriptorSetWithTemplateKHR(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size); + + size_t PreloadDecode_vkCreateRayTracingPipelinesKHR(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size); + + size_t PreloadDecode_vkDeferredOperationJoinKHR(const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size); + + template + T* SavePointer(void* buffer, size_t size); + + private: + std::vector consumers_; + + struct DeferredOperationFunctionCallData + { + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; + }; + std::unordered_map record_deferred_operation_function_call; + + std::vector container_; +}; + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) + +#endif // GFXRECON_DECODE_VULKAN_DECODER_BASE_H diff --git a/framework/decode/vulkan_preload_file_processor.cpp b/framework/decode/vulkan_preload_file_processor.cpp new file mode 100644 index 0000000000..47aedc04aa --- /dev/null +++ b/framework/decode/vulkan_preload_file_processor.cpp @@ -0,0 +1,1406 @@ +/* +** Copyright (c) 2023 LunarG, Inc. +** Copyright (c) 2023 Arm Limited and/or its affiliates +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#include "decode/vulkan_preload_file_processor.h" +#include "util/logging.h" + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +VulkanPreloadFileProcessor::VulkanPreloadFileProcessor() : + status_(PreloadStatus::kInactive), vulkan_preload_decoder_(nullptr) +{} + +void VulkanPreloadFileProcessor::ReplayPreloadedPackets() +{ + vulkan_preload_replayer_.ReplayPackets(vulkan_preload_decoder_); +} +void VulkanPreloadFileProcessor::PreloadNextFrames(size_t count) +{ + preload_frames_ = count; + status_ = PreloadStatus::kRecord; + while (count-- != 0U) + { + if (!ProcessNextFrame()) + { + break; + } + } + status_ = PreloadStatus::kReplay; +} + +bool VulkanPreloadFileProcessor::ProcessNextFrame() +{ + bool success = true; + switch (status_) + { + case PreloadStatus::kInactive: + case PreloadStatus::kRecord: + success = IsFileValid(); + break; + case PreloadStatus::kReplay: + success = (GetErrorState() == Error::kErrorNone); + default: + break; + } + + if (success) + { + success = ProcessBlocks(); + } + else + { + // If not EOF, determine reason for invalid state. + if (file_descriptor_ == nullptr) + { + error_state_ = kErrorInvalidFileDescriptor; + } + else if (ferror(file_descriptor_)) + { + error_state_ = kErrorReadingFile; + } + } + + return success; +} + +bool VulkanPreloadFileProcessor::ProcessBlocks() +{ + format::BlockHeader block_header; + bool success = true; + + while (success) + { + if (enable_print_block_info_ && ((block_index_from_ < 0 || block_index_to_ < 0) || + (block_index_from_ <= block_index_ && block_index_to_ >= block_index_))) + { + GFXRECON_LOG_INFO( + "block info: index: %" PRIu64 ", current frame: %" PRIu64 "", block_index_, current_frame_number_); + } + success = ContinueDecoding(); + + if (success) + { + success = ReadBlockHeader(&block_header); + + for (auto decoder : decoders_) + { + decoder->SetCurrentBlockIndex(block_index_); + } + + if (success) + { + if (format::RemoveCompressedBlockBit(block_header.type) == format::BlockType::kFunctionCallBlock) + { + format::ApiCallId api_call_id = format::ApiCallId::ApiCall_Unknown; + + success = ReadBytes(&api_call_id, sizeof(api_call_id)); + + if (success) + { + bool should_break = false; + if (status_ == PreloadStatus::kRecord) + { + success = ProcessFunctionCall(block_header, api_call_id, should_break); + } + else + { + success = FileProcessor::ProcessFunctionCall(block_header, api_call_id, should_break); + } + + if (should_break) + { + break; + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read function call block header"); + } + } + else if (format::RemoveCompressedBlockBit(block_header.type) == format::BlockType::kMetaDataBlock) + { + format::MetaDataId meta_data_id = format::MakeMetaDataId( + format::ApiFamilyId::ApiFamily_None, format::MetaDataType::kUnknownMetaDataType); + + success = ReadBytes(&meta_data_id, sizeof(meta_data_id)); + + if (success) + { + if (status_ == PreloadStatus::kRecord) + { + success = ProcessMetaData(block_header, meta_data_id); + } + else + { + success = FileProcessor::ProcessMetaData(block_header, meta_data_id); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read meta-data block header"); + } + } + else if (block_header.type == format::BlockType::kFrameMarkerBlock) + { + format::MarkerType marker_type = format::MarkerType::kUnknownMarker; + uint64_t frame_number = 0; + + success = ReadBytes(&marker_type, sizeof(marker_type)); + + if (success) + { + bool should_break = false; + success = FileProcessor::ProcessFrameMarker(block_header, marker_type, should_break); + + if (should_break) + { + break; + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read frame marker header"); + } + } + else if (block_header.type == format::BlockType::kStateMarkerBlock) + { + format::MarkerType marker_type = format::MarkerType::kUnknownMarker; + uint64_t frame_number = 0; + + success = ReadBytes(&marker_type, sizeof(marker_type)); + + if (success) + { + success = FileProcessor::ProcessStateMarker(block_header, marker_type); + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read state marker header"); + } + } + else if (block_header.type == format::BlockType::kAnnotation) + { + if (annotation_handler_ != nullptr) + { + format::AnnotationType annotation_type = format::AnnotationType::kUnknown; + + success = ReadBytes(&annotation_type, sizeof(annotation_type)); + + if (success) + { + success = FileProcessor::ProcessAnnotation(block_header, annotation_type); + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read annotation block header"); + } + } + else + { + // If there is no annotation handler to process the annotation, we can skip the annotation + // block. + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, block_header.size); + success = SkipBytes(static_cast(block_header.size)); + } + } + else + { + // Unrecognized block type. + GFXRECON_LOG_WARNING("Skipping unrecognized file block with type %u", block_header.type); + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, block_header.size); + success = SkipBytes(static_cast(block_header.size)); + } + } + else + { + if (!feof(file_descriptor_)) + { + // No data has been read for the current block, so we don't use 'HandleBlockReadError' here, as it + // assumes that the block header has been successfully read and will print an incomplete block at + // end of file warning when the file is at EOF without an error. For this case (the normal EOF case) + // we print nothing at EOF, or print an error message and set the error code directly when not at + // EOF. + GFXRECON_LOG_ERROR("Failed to read block header (frame %u block %" PRIu64 ")", + current_frame_number_, + block_index_); + error_state_ = kErrorReadingBlockHeader; + } + } + } + + { + ++block_index_; + } + } + + return success; +} + +bool VulkanPreloadFileProcessor::ProcessFunctionCall(const format::BlockHeader& block_header, + format::ApiCallId call_id, + bool& should_break) +{ + size_t parameter_buffer_size = static_cast(block_header.size) - sizeof(call_id); + uint64_t uncompressed_size = 0; + ApiCallInfo call_info{ block_index_ }; + bool success = ReadBytes(&call_info.thread_id, sizeof(call_info.thread_id)); + + if (success) + { + parameter_buffer_size -= sizeof(call_info.thread_id); + + if (format::IsBlockCompressed(block_header.type)) + { + parameter_buffer_size -= sizeof(uncompressed_size); + success = ReadBytes(&uncompressed_size, sizeof(uncompressed_size)); + + if (success) + { + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, uncompressed_size); + + size_t actual_size = 0; + success = ReadCompressedParameterBuffer( + parameter_buffer_size, static_cast(uncompressed_size), &actual_size); + + if (success) + { + assert(actual_size == uncompressed_size); + parameter_buffer_size = static_cast(uncompressed_size); + } + else + { + HandleBlockReadError(kErrorReadingCompressedBlockData, + "Failed to read compressed function call block data"); + } + } + else + { + HandleBlockReadError(kErrorReadingCompressedBlockHeader, + "Failed to read compressed function call block header"); + } + } + else + { + success = ReadParameterBuffer(parameter_buffer_size); + + if (!success) + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read function call block data"); + } + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsApiCall(call_id)) + { + DecodeAllocator::Begin(); + vulkan_preload_decoder_->DecodeFunctionCall( + call_id, call_info, parameter_buffer_.data(), parameter_buffer_size); + DecodeAllocator::End(); + } + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read function call block header"); + } + + // Break from loop on frame delimiter. + if (IsFrameDelimiter(call_id)) + { + // Make sure to increment the frame number on the way out. + ++current_frame_number_; + ++block_index_; + should_break = true; + } + return success; +} + +bool VulkanPreloadFileProcessor::ProcessMetaData(const format::BlockHeader& block_header, + format::MetaDataId meta_data_id) +{ + bool success = false; + + format::MetaDataType meta_data_type = format::GetMetaDataType(meta_data_id); + + if (meta_data_type == format::MetaDataType::kFillMemoryCommand) + { + format::FillMemoryCommandHeader header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.memory_id, sizeof(header.memory_id)); + success = success && ReadBytes(&header.memory_offset, sizeof(header.memory_offset)); + success = success && ReadBytes(&header.memory_size, sizeof(header.memory_size)); + + if (success) + { + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, header.memory_size); + + if (format::IsBlockCompressed(block_header.type)) + { + size_t uncompressed_size = 0; + size_t compressed_size = static_cast(block_header.size) - sizeof(meta_data_id) - + sizeof(header.thread_id) - sizeof(header.memory_id) - + sizeof(header.memory_offset) - sizeof(header.memory_size); + + success = ReadCompressedParameterBuffer( + compressed_size, static_cast(header.memory_size), &uncompressed_size); + } + else + { + success = ReadParameterBuffer(static_cast(header.memory_size)); + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchFillMemoryCommand(header.thread_id, + header.memory_id, + header.memory_offset, + header.memory_size, + parameter_buffer_.data()); + } + } + else + { + if (format::IsBlockCompressed(block_header.type)) + { + HandleBlockReadError(kErrorReadingCompressedBlockData, + "Failed to read fill memory meta-data block"); + } + else + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read fill memory meta-data block"); + } + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read fill memory meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kFixDeviceAddressCommand) + { + format::FixDeviceAddressCommandHeader header; + success = ReadBytes(&header.relation_id, sizeof(header.relation_id)); + success = ReadBytes(&header.num_of_locations, sizeof(header.num_of_locations)); + auto locations = new format::AddressLocationInfo[header.num_of_locations]; + success = ReadBytes(locations, header.num_of_locations * sizeof(format::AddressLocationInfo)); + + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchFixDeviceAddresCommand(header, locations); + } + delete[] locations; + } + else if (meta_data_type == format::MetaDataType::kFillMemoryResourceValueCommand) + { + format::FillMemoryResourceValueCommandHeader header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = ReadBytes(&header.resource_value_count, sizeof(header.resource_value_count)); + + if (success) + { + uint64_t data_size = header.resource_value_count * (sizeof(format::ResourceValueType) + sizeof(uint64_t)); + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, data_size); + + if (format::IsBlockCompressed(block_header.type)) + { + size_t uncompressed_size = 0; + size_t compressed_size = static_cast(block_header.size) - sizeof(meta_data_id) - + sizeof(header.thread_id) - sizeof(header.resource_value_count); + size_t uncompressed_data = static_cast(data_size); + success = ReadCompressedParameterBuffer(compressed_size, uncompressed_data, &uncompressed_size); + } + else + { + success = ReadParameterBuffer(static_cast(data_size)); + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchFillMemoryResourceValueCommand(header, parameter_buffer_.data()); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockData, + "Failed to read fill memory resource value meta-data block"); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read fill memory resource value meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kResizeWindowCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::ResizeWindowCommand command; + + success = ReadBytes(&command.thread_id, sizeof(command.thread_id)); + success = success && ReadBytes(&command.surface_id, sizeof(command.surface_id)); + success = success && ReadBytes(&command.width, sizeof(command.width)); + success = success && ReadBytes(&command.height, sizeof(command.height)); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchResizeWindowCommand( + command.thread_id, command.surface_id, command.width, command.height); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read resize window meta-data block"); + } + } + else if (meta_data_type == format::MetaDataType::kResizeWindowCommand2) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::ResizeWindowCommand2 command; + + success = ReadBytes(&command.thread_id, sizeof(command.thread_id)); + success = success && ReadBytes(&command.surface_id, sizeof(command.surface_id)); + success = success && ReadBytes(&command.width, sizeof(command.width)); + success = success && ReadBytes(&command.height, sizeof(command.height)); + success = success && ReadBytes(&command.pre_transform, sizeof(command.pre_transform)); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchResizeWindowCommand2( + command.thread_id, command.surface_id, command.width, command.height, command.pre_transform); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read resize window 2 meta-data block"); + } + } + else if (meta_data_type == format::MetaDataType::kExeFileInfoCommand) + { + format::ExeFileInfoBlock header; + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + + success = + success && ReadBytes(&header.info_record.ProductVersion, gfxrecon::util::filepath::kMaxFilePropertySize); + success = success && ReadBytes(&header.info_record.FileVersion, gfxrecon::util::filepath::kMaxFilePropertySize); + success = success && ReadBytes(&header.info_record.AppVersion, + sizeof(uint32_t) * gfxrecon::util::filepath::kFileVersionSize); + success = success && ReadBytes(&header.info_record.AppName, gfxrecon::util::filepath::kMaxFilePropertySize); + success = success && ReadBytes(&header.info_record.CompanyName, gfxrecon::util::filepath::kMaxFilePropertySize); + success = + success && ReadBytes(&header.info_record.FileDescription, gfxrecon::util::filepath::kMaxFilePropertySize); + success = + success && ReadBytes(&header.info_record.InternalName, gfxrecon::util::filepath::kMaxFilePropertySize); + success = + success && ReadBytes(&header.info_record.OriginalFilename, gfxrecon::util::filepath::kMaxFilePropertySize); + success = success && ReadBytes(&header.info_record.ProductName, gfxrecon::util::filepath::kMaxFilePropertySize); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchExeFileInfo(header.thread_id, header); + } + } + } + else if (meta_data_type == format::MetaDataType::kDriverInfoCommand) + { + format::DriverInfoBlock header; + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + + success = success && ReadBytes(&header.driver_record, gfxrecon::util::filepath::kMaxDriverInfoSize); + + if (success) + { + for (auto decoder : decoders_) + { + decoder->DispatchDriverInfo(header.thread_id, header); + } + } + } + else if (meta_data_type == format::MetaDataType::kDisplayMessageCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::DisplayMessageCommandHeader header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + + if (success) + { + uint64_t message_size = block_header.size - sizeof(meta_data_id) - sizeof(header.thread_id); + + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, message_size); + + success = ReadParameterBuffer(static_cast(message_size)); + + if (success) + { + auto message_start = parameter_buffer_.begin(); + std::string message(message_start, std::next(message_start, static_cast(message_size))); + + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchDisplayMessageCommand(header.thread_id, message); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read display message meta-data block"); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read display message meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kCreateHardwareBufferCommand_deprecated) + { + format::CreateHardwareBufferCommandHeader_deprecated header; + + GFXRECON_LOG_WARNING_ONCE( + "This capture contains a deprecated metacommand to create an AHardwareBuffer. While still supported, this " + "metacommand may not correctly represent some state of the captured AHardwareBuffer."); + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.memory_id, sizeof(header.memory_id)); + success = success && ReadBytes(&header.buffer_id, sizeof(header.buffer_id)); + success = success && ReadBytes(&header.format, sizeof(header.format)); + success = success && ReadBytes(&header.width, sizeof(header.width)); + success = success && ReadBytes(&header.height, sizeof(header.height)); + success = success && ReadBytes(&header.stride, sizeof(header.stride)); + success = success && ReadBytes(&header.usage, sizeof(header.usage)); + success = success && ReadBytes(&header.layers, sizeof(header.layers)); + success = success && ReadBytes(&header.planes, sizeof(header.planes)); + + if (success) + { + std::vector entries; + + for (uint64_t i = 0; i < header.planes; ++i) + { + format::HardwareBufferPlaneInfo entry; + + if (!ReadBytes(&entry, sizeof(entry))) + { + success = false; + break; + } + + entries.emplace_back(std::move(entry)); + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchCreateHardwareBufferCommand(header.thread_id, + header.memory_id, + header.buffer_id, + header.format, + header.width, + header.height, + header.stride, + header.usage, + header.layers, + entries); + } + } + else + { + if (format::IsBlockCompressed(block_header.type)) + { + HandleBlockReadError(kErrorReadingCompressedBlockData, + "Failed to read create hardware buffer meta-data block"); + } + else + { + HandleBlockReadError(kErrorReadingBlockData, + "Failed to read create hardware buffer meta-data block"); + } + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read create hardware buffer meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kCreateHardwareBufferCommand) + { + format::CreateHardwareBufferCommandHeader header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.memory_id, sizeof(header.memory_id)); + success = success && ReadBytes(&header.buffer_id, sizeof(header.buffer_id)); + success = success && ReadBytes(&header.format, sizeof(header.format)); + success = success && ReadBytes(&header.width, sizeof(header.width)); + success = success && ReadBytes(&header.height, sizeof(header.height)); + success = success && ReadBytes(&header.stride, sizeof(header.stride)); + success = success && ReadBytes(&header.usage, sizeof(header.usage)); + success = success && ReadBytes(&header.layers, sizeof(header.layers)); + success = success && ReadBytes(&header.planes, sizeof(header.planes)); + + if (success) + { + std::vector entries; + + for (uint64_t i = 0; i < header.planes; ++i) + { + format::HardwareBufferPlaneInfo entry; + + if (!ReadBytes(&entry, sizeof(entry))) + { + success = false; + break; + } + + entries.emplace_back(std::move(entry)); + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchCreateHardwareBufferCommand(header.thread_id, + header.memory_id, + header.buffer_id, + header.format, + header.width, + header.height, + header.stride, + header.usage, + header.layers, + entries); + } + } + else + { + if (format::IsBlockCompressed(block_header.type)) + { + HandleBlockReadError(kErrorReadingCompressedBlockData, + "Failed to read create hardware buffer meta-data block"); + } + else + { + HandleBlockReadError(kErrorReadingBlockData, + "Failed to read create hardware buffer meta-data block"); + } + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read create hardware buffer meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kDestroyHardwareBufferCommand) + { + format::DestroyHardwareBufferCommand command; + + success = ReadBytes(&command.thread_id, sizeof(command.thread_id)); + success = success && ReadBytes(&command.buffer_id, sizeof(command.buffer_id)); + + if (success) + { + for (auto decoder : decoders_) + { + if (decoder->SupportsMetaDataId(meta_data_id)) + { + decoder->DispatchDestroyHardwareBufferCommand(command.thread_id, command.buffer_id); + } + } + } + else + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read destroy hardware buffer meta-data block"); + } + } + else if (meta_data_type == format::MetaDataType::kCreateHeapAllocationCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::CreateHeapAllocationCommand header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.allocation_id, sizeof(header.allocation_id)); + success = success && ReadBytes(&header.allocation_size, sizeof(header.allocation_size)); + + if (success) + { + + vulkan_preload_decoder_->DispatchCreateHeapAllocationCommand( + header.thread_id, header.allocation_id, header.allocation_size); + } + else + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read create heap allocation meta-data block"); + } + } + else if (meta_data_type == format::MetaDataType::kSetDevicePropertiesCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::SetDevicePropertiesCommand header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.physical_device_id, sizeof(header.physical_device_id)); + success = success && ReadBytes(&header.api_version, sizeof(header.api_version)); + success = success && ReadBytes(&header.driver_version, sizeof(header.driver_version)); + success = success && ReadBytes(&header.vendor_id, sizeof(header.vendor_id)); + success = success && ReadBytes(&header.device_id, sizeof(header.device_id)); + success = success && ReadBytes(&header.device_type, sizeof(header.device_type)); + success = success && ReadBytes(&header.pipeline_cache_uuid, format::kUuidSize); + success = success && ReadBytes(&header.device_name_len, sizeof(header.device_name_len)); + + if (success) + { + char device_name[format::kMaxPhysicalDeviceNameSize]; + + if (header.device_name_len < format::kMaxPhysicalDeviceNameSize) + { + success = success && ReadBytes(&device_name, header.device_name_len); + device_name[header.device_name_len] = '\0'; + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchSetDevicePropertiesCommand(header.thread_id, + header.physical_device_id, + header.api_version, + header.driver_version, + header.vendor_id, + header.device_id, + header.device_type, + header.pipeline_cache_uuid, + device_name); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockData, + "Failed to read set device memory properties meta-data block"); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read set device memory properties meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kSetDeviceMemoryPropertiesCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::SetDeviceMemoryPropertiesCommand header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.physical_device_id, sizeof(header.physical_device_id)); + success = success && ReadBytes(&header.memory_type_count, sizeof(header.memory_type_count)); + success = success && ReadBytes(&header.memory_heap_count, sizeof(header.memory_heap_count)); + + if (success) + { + std::vector types; + std::vector heaps; + + for (uint32_t i = 0; i < header.memory_type_count; ++i) + { + format::DeviceMemoryType type; + + if (!ReadBytes(&type, sizeof(type))) + { + success = false; + break; + } + + types.emplace_back(std::move(type)); + } + + for (uint32_t i = 0; i < header.memory_heap_count; ++i) + { + format::DeviceMemoryHeap heap; + + if (!ReadBytes(&heap, sizeof(heap))) + { + success = false; + break; + } + + heaps.emplace_back(std::move(heap)); + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchSetDeviceMemoryPropertiesCommand( + header.thread_id, header.physical_device_id, types, heaps); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockData, + "Failed to read set device memory properties meta-data block"); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read set device memory properties meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kSetOpaqueAddressCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::SetOpaqueAddressCommand header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.device_id, sizeof(header.device_id)); + success = success && ReadBytes(&header.object_id, sizeof(header.object_id)); + success = success && ReadBytes(&header.address, sizeof(header.address)); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchSetOpaqueAddressCommand( + header.thread_id, header.device_id, header.object_id, header.address); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read set opaque address meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kSetRayTracingShaderGroupHandlesCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::SetRayTracingShaderGroupHandlesCommandHeader header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.device_id, sizeof(header.device_id)); + success = success && ReadBytes(&header.pipeline_id, sizeof(header.pipeline_id)); + success = success && ReadBytes(&header.data_size, sizeof(header.data_size)); + + // Read variable size shader group handle data into parameter_buffer_. + success = success && ReadParameterBuffer(static_cast(header.data_size)); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchSetRayTracingShaderGroupHandlesCommand( + header.thread_id, + header.device_id, + header.pipeline_id, + static_cast(header.data_size), + parameter_buffer_.data()); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read set ray tracing shader group handles meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kSetSwapchainImageStateCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::SetSwapchainImageStateCommandHeader header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.device_id, sizeof(header.device_id)); + success = success && ReadBytes(&header.swapchain_id, sizeof(header.swapchain_id)); + success = success && ReadBytes(&header.last_presented_image, sizeof(header.last_presented_image)); + success = success && ReadBytes(&header.image_info_count, sizeof(header.image_info_count)); + + if (success) + { + std::vector entries; + + for (uint32_t i = 0; i < header.image_info_count; ++i) + { + format::SwapchainImageStateInfo entry; + + if (!ReadBytes(&entry, sizeof(entry))) + { + success = false; + break; + } + + entries.emplace_back(std::move(entry)); + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchSetSwapchainImageStateCommand( + header.thread_id, header.device_id, header.swapchain_id, header.last_presented_image, entries); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockData, + "Failed to read set swapchain image state meta-data block"); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read set swapchain image state meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kBeginResourceInitCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::BeginResourceInitCommand header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.device_id, sizeof(header.device_id)); + success = success && ReadBytes(&header.max_resource_size, sizeof(header.max_resource_size)); + success = success && ReadBytes(&header.max_copy_size, sizeof(header.max_copy_size)); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchBeginResourceInitCommand( + header.thread_id, header.device_id, header.max_resource_size, header.max_copy_size); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read begin resource init meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kEndResourceInitCommand) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::EndResourceInitCommand header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.device_id, sizeof(header.device_id)); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchEndResourceInitCommand(header.thread_id, header.device_id); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read end resource init meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kInitBufferCommand) + { + format::InitBufferCommandHeader header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.device_id, sizeof(header.device_id)); + success = success && ReadBytes(&header.buffer_id, sizeof(header.buffer_id)); + success = success && ReadBytes(&header.data_size, sizeof(header.data_size)); + + if (success) + { + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, header.data_size); + + if (format::IsBlockCompressed(block_header.type)) + { + size_t uncompressed_size = 0; + size_t compressed_size = + static_cast(block_header.size) - (sizeof(header) - sizeof(header.meta_header.block_header)); + + success = ReadCompressedParameterBuffer( + compressed_size, static_cast(header.data_size), &uncompressed_size); + } + else + { + success = ReadParameterBuffer(static_cast(header.data_size)); + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchInitBufferCommand(header.thread_id, + header.device_id, + header.buffer_id, + header.data_size, + parameter_buffer_.data()); + } + } + else + { + if (format::IsBlockCompressed(block_header.type)) + { + HandleBlockReadError(kErrorReadingCompressedBlockData, + "Failed to read init buffer data meta-data block"); + } + else + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read init buffer data meta-data block"); + } + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, "Failed to read init buffer data meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kInitImageCommand) + { + format::InitImageCommandHeader header; + std::vector level_sizes; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.device_id, sizeof(header.device_id)); + success = success && ReadBytes(&header.image_id, sizeof(header.image_id)); + success = success && ReadBytes(&header.data_size, sizeof(header.data_size)); + success = success && ReadBytes(&header.aspect, sizeof(header.aspect)); + success = success && ReadBytes(&header.layout, sizeof(header.layout)); + success = success && ReadBytes(&header.level_count, sizeof(header.level_count)); + + if (success && (header.level_count > 0)) + { + level_sizes.resize(header.level_count); + success = success && ReadBytes(level_sizes.data(), header.level_count * sizeof(level_sizes[0])); + } + + if (success && (header.data_size > 0)) + { + assert(header.data_size == std::accumulate(level_sizes.begin(), level_sizes.end(), 0ull)); + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, header.data_size); + + if (format::IsBlockCompressed(block_header.type)) + { + size_t uncompressed_size = 0; + size_t compressed_size = static_cast(block_header.size) - + (sizeof(header) - sizeof(header.meta_header.block_header)) - + (level_sizes.size() * sizeof(level_sizes[0])); + + success = ReadCompressedParameterBuffer( + compressed_size, static_cast(header.data_size), &uncompressed_size); + } + else + { + success = ReadParameterBuffer(static_cast(header.data_size)); + } + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchInitImageCommand(header.thread_id, + header.device_id, + header.image_id, + header.data_size, + header.aspect, + header.layout, + level_sizes, + parameter_buffer_.data()); + } + } + else + { + if (format::IsBlockCompressed(block_header.type)) + { + HandleBlockReadError(kErrorReadingCompressedBlockData, + "Failed to read init image data meta-data block"); + } + else + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read init image data meta-data block"); + } + } + } + else if (meta_data_type == format::MetaDataType::kInitSubresourceCommand) + { + format::InitSubresourceCommandHeader header; + + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.device_id, sizeof(header.device_id)); + success = success && ReadBytes(&header.resource_id, sizeof(header.resource_id)); + success = success && ReadBytes(&header.subresource, sizeof(header.subresource)); + success = success && ReadBytes(&header.initial_state, sizeof(header.initial_state)); + success = success && ReadBytes(&header.resource_state, sizeof(header.resource_state)); + success = success && ReadBytes(&header.barrier_flags, sizeof(header.barrier_flags)); + success = success && ReadBytes(&header.data_size, sizeof(header.data_size)); + + if (success) + { + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, header.data_size); + + if (format::IsBlockCompressed(block_header.type)) + { + size_t uncompressed_size = 0; + size_t compressed_size = + static_cast(block_header.size) - (sizeof(header) - sizeof(header.meta_header.block_header)); + + success = ReadCompressedParameterBuffer( + compressed_size, static_cast(header.data_size), &uncompressed_size); + } + else + { + success = ReadParameterBuffer(static_cast(header.data_size)); + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchInitSubresourceCommand(header, parameter_buffer_.data()); + } + } + else + { + if (format::IsBlockCompressed(block_header.type)) + { + HandleBlockReadError(kErrorReadingCompressedBlockData, + "Failed to read init subresource data meta-data block"); + } + else + { + HandleBlockReadError(kErrorReadingBlockData, + "Failed to read init subresource data meta-data block"); + } + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read init subresource data meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kParentToChildDependency) + { + // This command does not support compression. + assert(block_header.type != format::BlockType::kCompressedMetaDataBlock); + + format::ParentToChildDependencyHeader header; + success = ReadBytes(&header.thread_id, sizeof(header.thread_id)); + success = success && ReadBytes(&header.dependency_type, sizeof(header.dependency_type)); + success = success && ReadBytes(&header.parent_id, sizeof(header.parent_id)); + success = success && ReadBytes(&header.child_count, sizeof(header.child_count)); + + if (success) + { + switch (header.dependency_type) + { + case format::kAccelerationStructuresDependency: + { + std::vector blases; + blases.resize(header.child_count); + + for (uint32_t i = 0; i < header.child_count; ++i) + { + success = success && ReadBytes(&blases[i], sizeof(blases[i])); + } + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + vulkan_preload_decoder_->DispatchSetTlasToBlasDependencyCommand(header.parent_id, blases); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read TLAS to BLAS dependency meta-data block header"); + } + } + break; + + default: + success = false; + HandleBlockReadError(kErrorReadingBlockHeader, + "Corrupted parent to child dependency meta-data block header"); + break; + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read parent to child dependency meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kVulkanBuildAccelerationStructuresCommand) + { + format::VulkanMetaBuildAccelerationStructuresHeader header; + size_t parameter_buffer_size = static_cast(block_header.size) - sizeof(meta_data_id); + success = ReadParameterBuffer(parameter_buffer_size); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + DecodeAllocator::Begin(); + + vulkan_preload_decoder_->DispatchVulkanAccelerationStructuresBuildMetaCommand(parameter_buffer_.data(), + parameter_buffer_size); + + DecodeAllocator::End(); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockHeader, + "Failed to read acceleration structure init meta-data block header"); + } + } + else if (meta_data_type == format::MetaDataType::kVulkanCopyAccelerationStructuresCommand) + { + format::VulkanCopyAccelerationStructuresCommandHeader header; + size_t parameter_buffer_size = static_cast(block_header.size) - sizeof(meta_data_id); + success = ReadParameterBuffer(parameter_buffer_size); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + DecodeAllocator::Begin(); + + vulkan_preload_decoder_->DispatchVulkanAccelerationStructuresCopyMetaCommand(parameter_buffer_.data(), + parameter_buffer_size); + + DecodeAllocator::End(); + } + } + } + else if (meta_data_type == format::MetaDataType::kVulkanWriteAccelerationStructuresPropertiesCommand) + { + format::VulkanCopyAccelerationStructuresCommandHeader header; + size_t parameter_buffer_size = static_cast(block_header.size) - sizeof(meta_data_id); + success = ReadParameterBuffer(parameter_buffer_size); + + if (success) + { + if (vulkan_preload_decoder_->SupportsMetaDataId(meta_data_id)) + { + DecodeAllocator::Begin(); + + vulkan_preload_decoder_->DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand( + parameter_buffer_.data(), parameter_buffer_size); + + DecodeAllocator::End(); + } + } + } + else + { + if ((meta_data_type == format::MetaDataType::kReserved23) || + (meta_data_type == format::MetaDataType::kReserved25)) + { + // Only log a warning once if the capture file contains blocks that are a "reserved" meta data type. + GFXRECON_LOG_WARNING_ONCE("This capture file contains meta-data block(s) with reserved type(s) that are " + "not supported. Unsupported meta-data block types will be skipped."); + } + else + { + // Unrecognized metadata type. + GFXRECON_LOG_WARNING("Skipping unrecognized meta-data block with type %" PRIu16, meta_data_type); + } + GFXRECON_CHECK_CONVERSION_DATA_LOSS(size_t, block_header.size); + success = SkipBytes(static_cast(block_header.size) - sizeof(meta_data_id)); + } + + return success; +} + +bool VulkanPreloadFileProcessor::ProcessStateMarker(const format::BlockHeader& block_header, + format::MarkerType marker_type) +{ + uint64_t frame_number = 0; + bool success = ReadBytes(&frame_number, sizeof(frame_number)); + + if (success) + { + if (marker_type == format::kBeginMarker) + { + GFXRECON_LOG_INFO("Loading state for captured frame %" PRId64, frame_number); + } + else if (marker_type == format::kEndMarker) + { + GFXRECON_LOG_INFO("Finished loading state for captured frame %" PRId64, frame_number); + first_frame_ = frame_number; + } + + if (marker_type == format::kBeginMarker) + { + vulkan_preload_decoder_->DispatchStateBeginMarker(frame_number); + } + else if (marker_type == format::kEndMarker) + { + vulkan_preload_decoder_->DispatchStateEndMarker(frame_number); + } + else + { + GFXRECON_LOG_WARNING("Skipping unrecognized state marker with type %u", marker_type); + } + } + else + { + HandleBlockReadError(kErrorReadingBlockData, "Failed to read state marker data"); + } + + return success; +} + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/vulkan_preload_file_processor.h b/framework/decode/vulkan_preload_file_processor.h new file mode 100644 index 0000000000..21dff78a4f --- /dev/null +++ b/framework/decode/vulkan_preload_file_processor.h @@ -0,0 +1,74 @@ +/* +** Copyright (c) 2023 LunarG, Inc. +** Copyright (c) 2023 Arm Limited and/or its affiliates +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#ifndef GFXRECON_DECODE_VULKAN_PRELOAD_FILE_PROCESSOR_H +#define GFXRECON_DECODE_VULKAN_PRELOAD_FILE_PROCESSOR_H + +#include "decode/file_processor.h" +#include "format/format_util.h" + +#include "generated/generated_vulkan_preload_decoder.h" +#include "generated/generated_vulkan_preload_replayer.h" + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +class VulkanPreloadFileProcessor : public FileProcessor +{ + public: + VulkanPreloadFileProcessor(); + + void SetPreloadDecoder(VulkanPreloadDecoder* decoder) { vulkan_preload_decoder_ = decoder; } + void SetConsumer(VulkanReplayConsumer* consumer) { vulkan_preload_replayer_.AddConsumer(consumer); } + + // Preloads *count* frames to continuous, expandable memory buffer + void PreloadNextFrames(size_t count); + + bool ProcessNextFrame() override; + + void ReplayPreloadedPackets(); + + protected: + bool ProcessFunctionCall(const format::BlockHeader& block_header, format::ApiCallId call_id, bool& should_break); + bool ProcessMetaData(const format::BlockHeader& block_header, format::MetaDataId meta_data_id); + bool ProcessStateMarker(const format::BlockHeader& block_header, format::MarkerType marker_type); + + private: + enum class PreloadStatus + { + kInactive, + kRecord, + kReplay + } status_; + + bool ProcessBlocks() override; + + size_t preload_frames_; + VulkanPreloadDecoder* vulkan_preload_decoder_; + VulkanPreloadReplayer vulkan_preload_replayer_; +}; + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) + +#endif // GFXRECON_DECODE_PRELOAD_FILE_PROCESSOR_H diff --git a/framework/decode/vulkan_preload_replayer_base.cpp b/framework/decode/vulkan_preload_replayer_base.cpp new file mode 100644 index 0000000000..ba0b2c1d5c --- /dev/null +++ b/framework/decode/vulkan_preload_replayer_base.cpp @@ -0,0 +1,363 @@ +/* +** Copyright (c) 2023 LunarG, Inc. +** Copyright (c) 2023 Arm Limited and/or its affiliates +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#include "decode/vulkan_preload_replayer_base.h" +#include "util/logging.h" + +#include "format/packet_call_id.h" +#include "vulkan_preload_replayer_base.h" + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +const uint32_t kFirstFrame = 0; + +VulkanPreloadReplayerBase::VulkanPreloadReplayerBase() : current_frame_number_(kFirstFrame) {} + +VulkanPreloadReplayerBase::~VulkanPreloadReplayerBase() {} + +void VulkanPreloadReplayerBase::Replay_DispatchFillMemoryCommand(Packet_DispatchFillMemoryCommand* packet) +{ + vulkan_replay_consumer_->ProcessFillMemoryCommand(packet->memory_id, packet->offset, packet->size, packet->data); +} + +void VulkanPreloadReplayerBase::Replay_DispatchFixDeviceAddresCommand(Packet_DispatchFixDeviceAddresCommand* packet) +{ + vulkan_replay_consumer_->ProcessFixDeviceAddressCommand(packet->header, packet->infos); +} + +void VulkanPreloadReplayerBase::Replay_DispatchResizeWindowCommand(Packet_DispatchResizeWindowCommand* packet) +{ + vulkan_replay_consumer_->ProcessResizeWindowCommand(packet->surface_id, packet->width, packet->height); +} + +void VulkanPreloadReplayerBase::Replay_DispatchResizeWindowCommand2(Packet_DispatchResizeWindowCommand2* packet) +{ + vulkan_replay_consumer_->ProcessResizeWindowCommand2( + packet->surface_id, packet->width, packet->height, packet->pre_transform); +} + +void VulkanPreloadReplayerBase::Replay_DispatchDisplayMessageCommand(Packet_DispatchDisplayMessageCommand* packet) +{ + vulkan_replay_consumer_->ProcessDisplayMessageCommand(packet->message); +} + +void VulkanPreloadReplayerBase::Replay_DispatchCreateHardwareBufferCommand( + Packet_DispatchCreateHardwareBufferCommand* packet) +{ + vulkan_replay_consumer_->ProcessCreateHardwareBufferCommand(packet->memory_id, + packet->buffer_id, + packet->format, + packet->width, + packet->height, + packet->stride, + packet->usage, + packet->layers, + packet->plane_info); +} + +void VulkanPreloadReplayerBase::Replay_DispatchDestroyHardwareBufferCommand( + Packet_DispatchDestroyHardwareBufferCommand* packet) +{ + vulkan_replay_consumer_->ProcessDestroyHardwareBufferCommand(packet->buffer_id); +} + +void VulkanPreloadReplayerBase::Replay_DispatchSetDevicePropertiesCommand( + Packet_DispatchSetDevicePropertiesCommand* packet) +{ + vulkan_replay_consumer_->ProcessSetDevicePropertiesCommand(packet->physical_device_id, + packet->api_version, + packet->driver_version, + packet->vendor_id, + packet->device_id, + packet->device_type, + packet->pipeline_cache_uuid, + packet->device_name); +} + +void VulkanPreloadReplayerBase::Replay_DispatchSetDeviceMemoryPropertiesCommand( + Packet_DispatchSetDeviceMemoryPropertiesCommand* packet) +{ + vulkan_replay_consumer_->ProcessSetDeviceMemoryPropertiesCommand( + packet->physical_device_id, packet->memory_types, packet->memory_heaps); +} + +void VulkanPreloadReplayerBase::Replay_DispatchSetOpaqueAddressCommand(Packet_DispatchSetOpaqueAddressCommand* packet) +{ + vulkan_replay_consumer_->ProcessSetOpaqueAddressCommand(packet->device_id, packet->object_id, packet->address); +} + +void VulkanPreloadReplayerBase::Replay_DispatchSetRayTracingShaderGroupHandlesCommand( + Packet_DispatchSetRayTracingShaderGroupHandlesCommand* packet) +{ + vulkan_replay_consumer_->ProcessSetRayTracingShaderGroupHandlesCommand( + packet->device_id, packet->pipeline_id, packet->data_size, packet->data); +} + +void VulkanPreloadReplayerBase::Replay_DispatchSetSwapchainImageStateCommand( + Packet_DispatchSetSwapchainImageStateCommand* packet) +{ + vulkan_replay_consumer_->ProcessSetSwapchainImageStateCommand( + packet->device_id, packet->swapchain_id, packet->last_presented_image, packet->image_state); +} + +void VulkanPreloadReplayerBase::Replay_DispatchBeginResourceInitCommand(Packet_DispatchBeginResourceInitCommand* packet) +{ + vulkan_replay_consumer_->ProcessBeginResourceInitCommand( + packet->device_id, packet->max_resource_size, packet->max_copy_size); +} + +void VulkanPreloadReplayerBase::Replay_DispatchEndResourceInitCommand(Packet_DispatchEndResourceInitCommand* packet) +{ + vulkan_replay_consumer_->ProcessEndResourceInitCommand(packet->device_id); +} + +void VulkanPreloadReplayerBase::Replay_DispatchInitBufferCommand(Packet_DispatchInitBufferCommand* packet) +{ + vulkan_replay_consumer_->ProcessInitBufferCommand( + packet->device_id, packet->buffer_id, packet->data_size, packet->data); +} + +void VulkanPreloadReplayerBase::Replay_DispatchInitImageCommand(Packet_DispatchInitImageCommand* packet) +{ + vulkan_replay_consumer_->ProcessInitImageCommand(packet->device_id, + packet->image_id, + packet->data_size, + packet->aspect, + packet->layout, + packet->level_sizes, + packet->data); +} + +void VulkanPreloadReplayerBase::Replay_DispatchSetTlasToBlasDependencyCommand( + Packet_DispatchSetTlasToBlasDependencyCommand* packet) +{ + vulkan_replay_consumer_->ProcessSetTlasToBlasRelationCommand(packet->tlas, packet->blases); +} + +void VulkanPreloadReplayerBase::Replay_DispatchVulkanAccelerationStructuresBuildMetaCommand( + Packet_DispatchVulkanAccelerationStructuresBuildMetaCommand* packet) +{ + vulkan_replay_consumer_->ProcessBuildVulkanAccelerationStructuresMetaCommand( + packet->device, packet->info_count, &(packet->pInfos), &(packet->ppRangeInfos), packet->instance_buffers_data); +} + +void VulkanPreloadReplayerBase::Replay_DispatchVulkanAccelerationStructuresCopyMetaCommand( + Packet_DispatchVulkanAccelerationStructuresCopyMetaCommand* packet) +{ + vulkan_replay_consumer_->ProcessCopyVulkanAccelerationStructuresMetaCommand(packet->device, &(packet->copy_infos)); +} + +void VulkanPreloadReplayerBase::Replay_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand( + Packet_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand* packet) +{ + vulkan_replay_consumer_->ProcessVulkanAccelerationStructuresWritePropertiesMetaCommand( + packet->device_id, packet->copy_query_typeinfos, packet->acceleration_structure_id); +} + +void VulkanPreloadReplayerBase::Replay_vkUpdateDescriptorSetWithTemplate( + Packet_vkUpdateDescriptorSetWithTemplate* packet) +{ + vulkan_replay_consumer_->Process_vkUpdateDescriptorSetWithTemplate( + packet->call_info, packet->device, packet->descriptorSet, packet->descriptorUpdateTemplate, &(packet->pData)); +} + +void VulkanPreloadReplayerBase::Replay_vkCmdPushDescriptorSetWithTemplateKHR( + Packet_vkCmdPushDescriptorSetWithTemplateKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPushDescriptorSetWithTemplateKHR(packet->call_info, + packet->commandBuffer, + packet->descriptorUpdateTemplate, + packet->layout, + packet->set, + &(packet->pData)); +} + +void VulkanPreloadReplayerBase::Replay_vkUpdateDescriptorSetWithTemplateKHR( + Packet_vkUpdateDescriptorSetWithTemplateKHR* packet) +{ + vulkan_replay_consumer_->Process_vkUpdateDescriptorSetWithTemplate( + packet->call_info, packet->device, packet->descriptorSet, packet->descriptorUpdateTemplate, &(packet->pData)); +} + +void VulkanPreloadReplayerBase::Replay_vkCreateRayTracingPipelinesKHR(Packet_vkCreateRayTracingPipelinesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateRayTracingPipelinesKHR(packet->call_info, + packet->returnValue, + packet->device, + packet->deferredOperation, + packet->pipelineCache, + packet->createInfoCount, + &(packet->pCreateInfos), + &(packet->pAllocator), + &(packet->pPipelines)); + + if (packet->deferredOperation) + { + DecodeAllocator::TurnOffEndCanClear(); + DeferredOperationFunctionCallData record; + record.pCreateInfos = std::move(packet->pCreateInfos); + record.pAllocator = std::move(packet->pAllocator); + record.pPipelines = std::move(packet->pPipelines); + record_deferred_operation_function_call[packet->deferredOperation] = std::move(record); + } +} + +void VulkanPreloadReplayerBase::Replay_vkCmdPushDescriptorSetWithTemplate2KHR( + Packet_vkCmdPushDescriptorSetWithTemplate2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPushDescriptorSetWithTemplate2KHR( + packet->call_info, packet->commandBuffer, &(packet->pPushDescriptorSetWithTemplateInfo)); +} + +void VulkanPreloadReplayerBase::Replay_vkDeferredOperationJoinKHR(Packet_vkDeferredOperationJoinKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDeferredOperationJoinKHR( + packet->call_info, packet->return_value, packet->device, packet->operation); + + DecodeAllocator::TurnOnEndCanClear(); + auto it = record_deferred_operation_function_call.find(packet->operation); + if (it != record_deferred_operation_function_call.end()) + { + record_deferred_operation_function_call.erase(it); + } +} + +bool VulkanPreloadReplayerBase::ReplayPackets(VulkanPreloadDecoder* vulkan_preload_decoder) +{ + std::vector container = vulkan_preload_decoder->GetPackets(); + size_t packet_number = container.size(); + size_t packet_index = 0; + while (packet_index < packet_number) + { + void* packet = container[packet_index]; + auto packet_call_id = *reinterpret_cast(packet); + auto packet_family_id = GetPacketCallFamily(packet_call_id); + if (packet_family_id == format::PacketFamilyId::PacketFamily_Vulkan_Functional_Call) + { + DecodeAllocator::Begin(); + ReplayFunctionCall(packet_call_id, packet); + DecodeAllocator::End(); + } + else + { + switch (packet_call_id) + { + case gfxrecon::format::PacketCall_DispatchFillMemoryCommand: + Replay_DispatchFillMemoryCommand(reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchFixDeviceAddresCommand: + Replay_DispatchFixDeviceAddresCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchResizeWindowCommand: + Replay_DispatchResizeWindowCommand(reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchResizeWindowCommand2: + Replay_DispatchResizeWindowCommand2(reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchDisplayMessageCommand: + Replay_DispatchDisplayMessageCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchCreateHardwareBufferCommand: + Replay_DispatchCreateHardwareBufferCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchDestroyHardwareBufferCommand: + Replay_DispatchDestroyHardwareBufferCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchSetDevicePropertiesCommand: + Replay_DispatchSetDevicePropertiesCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchSetDeviceMemoryPropertiesCommand: + Replay_DispatchSetDeviceMemoryPropertiesCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchSetOpaqueAddressCommand: + Replay_DispatchSetOpaqueAddressCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchSetRayTracingShaderGroupHandlesCommand: + Replay_DispatchSetRayTracingShaderGroupHandlesCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchSetSwapchainImageStateCommand: + Replay_DispatchSetSwapchainImageStateCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchBeginResourceInitCommand: + Replay_DispatchBeginResourceInitCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchEndResourceInitCommand: + Replay_DispatchEndResourceInitCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchInitBufferCommand: + Replay_DispatchInitBufferCommand(reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchInitImageCommand: + Replay_DispatchInitImageCommand(reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchSetTlasToBlasDependencyCommand: + Replay_DispatchSetTlasToBlasDependencyCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchVulkanAccelerationStructuresBuildMetaCommand: + Replay_DispatchVulkanAccelerationStructuresBuildMetaCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchVulkanAccelerationStructuresCopyMetaCommand: + Replay_DispatchVulkanAccelerationStructuresCopyMetaCommand( + reinterpret_cast(packet)); + break; + case gfxrecon::format::PacketCall_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand: + Replay_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand( + reinterpret_cast( + packet)); + break; + + default: + break; + } + } + packet_index++; + } + return false; +} + +void VulkanPreloadReplayerBase::ReplayFunctionCall(format::PacketCallId& packet_call_id, void* packet) +{ + switch (packet_call_id) + { + case gfxrecon::format::PacketCall_vkCreateRayTracingPipelinesKHR: + break; + default: + break; + } +} +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) \ No newline at end of file diff --git a/framework/decode/vulkan_preload_replayer_base.h b/framework/decode/vulkan_preload_replayer_base.h new file mode 100644 index 0000000000..0e168b3a81 --- /dev/null +++ b/framework/decode/vulkan_preload_replayer_base.h @@ -0,0 +1,100 @@ +/* +** Copyright (c) 2023 LunarG, Inc. +** Copyright (c) 2023 Arm Limited and/or its affiliates +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +#ifndef GFXRECON_DECODE_VULKAN_PRELOAD_REPLAYER_BASE_H +#define GFXRECON_DECODE_VULKAN_PRELOAD_REPLAYER_BASE_H + +#include "vulkan_struct_packet.h" +#include "generated/generated_vulkan_consumer.h" +#include "generated/generated_vulkan_struct_packet.h" +#include "generated/generated_vulkan_replay_consumer.h" +#include "generated/generated_vulkan_preload_decoder.h" + +#include "format/format_util.h" + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +class VulkanPreloadReplayerBase +{ + public: + VulkanPreloadReplayerBase(); + virtual ~VulkanPreloadReplayerBase(); + bool ReplayPackets(VulkanPreloadDecoder* vulkan_preload_decoder); + + virtual void ReplayFunctionCall(format::PacketCallId& packet_call_id, void* packet); + + void AddConsumer(VulkanReplayConsumer* consumer) { vulkan_replay_consumer_ = consumer; } + + virtual void Replay_DispatchFillMemoryCommand(Packet_DispatchFillMemoryCommand* packet); + virtual void Replay_DispatchFixDeviceAddresCommand(Packet_DispatchFixDeviceAddresCommand* packet); + virtual void Replay_DispatchResizeWindowCommand(Packet_DispatchResizeWindowCommand* packet); + virtual void Replay_DispatchResizeWindowCommand2(Packet_DispatchResizeWindowCommand2* packet); + virtual void Replay_DispatchDisplayMessageCommand(Packet_DispatchDisplayMessageCommand* packet); + virtual void Replay_DispatchCreateHardwareBufferCommand(Packet_DispatchCreateHardwareBufferCommand* packet); + virtual void Replay_DispatchDestroyHardwareBufferCommand(Packet_DispatchDestroyHardwareBufferCommand* packet); + virtual void Replay_DispatchSetDevicePropertiesCommand(Packet_DispatchSetDevicePropertiesCommand* packet); + virtual void + Replay_DispatchSetDeviceMemoryPropertiesCommand(Packet_DispatchSetDeviceMemoryPropertiesCommand* packet); + virtual void Replay_DispatchSetOpaqueAddressCommand(Packet_DispatchSetOpaqueAddressCommand* packet); + virtual void Replay_DispatchSetRayTracingShaderGroupHandlesCommand( + Packet_DispatchSetRayTracingShaderGroupHandlesCommand* packet); + virtual void Replay_DispatchSetSwapchainImageStateCommand(Packet_DispatchSetSwapchainImageStateCommand* packet); + virtual void Replay_DispatchBeginResourceInitCommand(Packet_DispatchBeginResourceInitCommand* packet); + virtual void Replay_DispatchEndResourceInitCommand(Packet_DispatchEndResourceInitCommand* packet); + virtual void Replay_DispatchInitBufferCommand(Packet_DispatchInitBufferCommand* packet); + virtual void Replay_DispatchInitImageCommand(Packet_DispatchInitImageCommand* packet); + virtual void Replay_DispatchSetTlasToBlasDependencyCommand(Packet_DispatchSetTlasToBlasDependencyCommand* packet); + virtual void Replay_DispatchVulkanAccelerationStructuresBuildMetaCommand( + Packet_DispatchVulkanAccelerationStructuresBuildMetaCommand* packet); + virtual void Replay_DispatchVulkanAccelerationStructuresCopyMetaCommand( + Packet_DispatchVulkanAccelerationStructuresCopyMetaCommand* packet); + virtual void Replay_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand( + Packet_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand* packet); + + virtual void Replay_vkUpdateDescriptorSetWithTemplate(Packet_vkUpdateDescriptorSetWithTemplate* packet); + virtual void Replay_vkCmdPushDescriptorSetWithTemplateKHR(Packet_vkCmdPushDescriptorSetWithTemplateKHR* packet); + virtual void Replay_vkUpdateDescriptorSetWithTemplateKHR(Packet_vkUpdateDescriptorSetWithTemplateKHR* packet); + virtual void Replay_vkCreateRayTracingPipelinesKHR(Packet_vkCreateRayTracingPipelinesKHR* packet); + virtual void Replay_vkCmdPushDescriptorSetWithTemplate2KHR(Packet_vkCmdPushDescriptorSetWithTemplate2KHR* packet); + virtual void Replay_vkDeferredOperationJoinKHR(Packet_vkDeferredOperationJoinKHR* packet); + + protected: + VulkanReplayConsumer* vulkan_replay_consumer_; + + private: + uint64_t current_frame_number_; + + struct DeferredOperationFunctionCallData + { + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; + }; + std::unordered_map record_deferred_operation_function_call; +}; + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) + +#endif // GFXRECON_DECODE_VULKAN_REPLAY_PRELOADER_BASE_H \ No newline at end of file diff --git a/framework/decode/vulkan_struct_packet.h b/framework/decode/vulkan_struct_packet.h new file mode 100644 index 0000000000..a7227050de --- /dev/null +++ b/framework/decode/vulkan_struct_packet.h @@ -0,0 +1,321 @@ +#include "generated/generated_vulkan_cpp_consumer.h" + +#include "decode/vulkan_cpp_consumer_base.h" +#include "decode/vulkan_cpp_structs.h" +#include "generated/generated_vulkan_cpp_structs.h" +#include "generated/generated_vulkan_enum_to_string.h" +#include "generated/generated_vulkan_cpp_consumer_extension.h" +#include "decode/handle_pointer_decoder.h" +#include "decode/pointer_decoder.h" +#include "decode/string_decoder.h" +#include "decode/struct_pointer_decoder.h" +#include "decode/custom_vulkan_struct_handle_mappers.h" +#include "generated/generated_vulkan_struct_decoders.h" +#include "util/defines.h" +#include "format/packet_call_id.h" +#include "vulkan/vulkan.h" +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#include "vk_video/vulkan_video_codecs_common.h" + +#include +#include + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +struct Packet_DispatchStateBeginMarker +{ + format::PacketCallId packet_id; + uint64_t frame_number; +}; + +struct Packet_DispatchStateEndMarker +{ + format::PacketCallId packet_id; + uint64_t frame_number; +}; + +struct Packet_DispatchFrameEndMarker +{ + format::PacketCallId packet_id; + uint64_t frame_number; +}; + +struct Packet_DispatchDisplayMessageCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + std::string message; +}; + +struct Packet_DispatchFillMemoryCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + uint64_t memory_id; + uint64_t offset; + uint64_t size; + uint8_t* data; +}; + +struct Packet_DispatchFixDeviceAddresCommand +{ + format::PacketCallId packet_id; + format::FixDeviceAddressCommandHeader header; + format::AddressLocationInfo* infos; +}; + +struct Packet_DispatchExeFileInfo +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::ExeFileInfoBlock info; +}; + +struct Packet_DispatchFillMemoryResourceValueCommand +{ + format::PacketCallId packet_id; + format::FillMemoryResourceValueCommandHeader command_header; + uint8_t* data; +}; + +struct Packet_DispatchResizeWindowCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId surface_id; + uint32_t width; + uint32_t height; +}; + +struct Packet_DispatchResizeWindowCommand2 +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId surface_id; + uint32_t width; + uint32_t height; + uint32_t pre_transform; +}; + +struct Packet_DispatchCreateHardwareBufferCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId memory_id; + uint64_t buffer_id; + uint32_t format; + uint32_t width; + uint32_t height; + uint32_t stride; + uint64_t usage; + uint32_t layers; + std::vector plane_info; +}; + +struct Packet_DispatchDestroyHardwareBufferCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + uint64_t buffer_id; +}; + +struct Packet_DispatchCreateHeapAllocationCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + uint64_t allocation_id; + uint64_t allocation_size; +}; + +struct Packet_DispatchSetDevicePropertiesCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId physical_device_id; + uint32_t api_version; + uint32_t driver_version; + uint32_t vendor_id; + uint32_t device_id; + uint32_t device_type; + uint8_t pipeline_cache_uuid[format::kUuidSize]; + std::string device_name; +}; + +struct Packet_DispatchSetDeviceMemoryPropertiesCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId physical_device_id; + std::vector memory_types; + std::vector memory_heaps; +}; + +struct Packet_DispatchSetOpaqueAddressCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId device_id; + format::HandleId object_id; + uint64_t address; +}; + +struct Packet_DispatchSetRayTracingShaderGroupHandlesCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId device_id; + format::HandleId pipeline_id; + size_t data_size; + uint8_t* data; +}; + +struct Packet_DispatchSetSwapchainImageStateCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId device_id; + format::HandleId swapchain_id; + uint32_t last_presented_image; + std::vector image_state; +}; + +struct Packet_DispatchBeginResourceInitCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId device_id; + uint64_t max_resource_size; + uint64_t max_copy_size; +}; + +struct Packet_DispatchEndResourceInitCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId device_id; +}; + +struct Packet_DispatchInitBufferCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId device_id; + format::HandleId buffer_id; + size_t data_size; + uint8_t* data; +}; + +struct Packet_DispatchInitImageCommand +{ + format::PacketCallId packet_id; + format::ThreadId thread_id; + format::HandleId device_id; + format::HandleId image_id; + size_t data_size; + uint32_t aspect; + uint32_t layout; + std::vector level_sizes; + uint8_t* data; +}; + +struct Packet_DispatchInitSubresourceCommand +{ + format::PacketCallId packet_id; + format::InitSubresourceCommandHeader command_header; + uint8_t* data; +}; + +// Function Call +struct Packet_vkUpdateDescriptorSetWithTemplate +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId descriptorSet; + format::HandleId descriptorUpdateTemplate; + DescriptorUpdateTemplateDecoder pData; +}; + +struct Packet_vkCmdPushDescriptorSetWithTemplateKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId descriptorUpdateTemplate; + format::HandleId layout; + uint32_t set; + DescriptorUpdateTemplateDecoder pData; +}; + +struct Packet_vkCmdPushDescriptorSetWithTemplate2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pPushDescriptorSetWithTemplateInfo; +}; + +struct Packet_vkUpdateDescriptorSetWithTemplateKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId descriptorSet; + format::HandleId descriptorUpdateTemplate; + DescriptorUpdateTemplateDecoder pData; +}; + +struct Packet_vkCreateRayTracingPipelinesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult returnValue; + format::HandleId device; + format::HandleId deferredOperation; + format::HandleId pipelineCache; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; +}; + +struct Packet_DispatchSetTlasToBlasDependencyCommand +{ + format::PacketCallId packet_id; + format::HandleId tlas; + std::vector blases; +}; + +struct Packet_DispatchVulkanAccelerationStructuresBuildMetaCommand +{ + format::PacketCallId packet_id; + format::HandleId device; + uint32_t info_count; + StructPointerDecoder pInfos; + StructPointerDecoder ppRangeInfos; + std::vector> instance_buffers_data; +}; + +struct Packet_DispatchVulkanAccelerationStructuresCopyMetaCommand +{ + format::PacketCallId packet_id; + format::HandleId device; + StructPointerDecoder copy_infos; +}; + +struct Packet_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand +{ + format::PacketCallId packet_id; + format::HandleId device_id; + VkQueryType copy_query_typeinfos; + format::HandleId acceleration_structure_id; +}; + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/format/CMakeLists.txt b/framework/format/CMakeLists.txt index 995513386f..99d3756b65 100644 --- a/framework/format/CMakeLists.txt +++ b/framework/format/CMakeLists.txt @@ -37,6 +37,7 @@ target_sources(gfxrecon_format ${CMAKE_CURRENT_LIST_DIR}/format_util.h ${CMAKE_CURRENT_LIST_DIR}/format_util.cpp ${CMAKE_CURRENT_LIST_DIR}/platform_types.h + ${CMAKE_CURRENT_LIST_DIR}/packet_call_id.h ) target_include_directories(gfxrecon_format diff --git a/framework/format/packet_call_id.h b/framework/format/packet_call_id.h new file mode 100644 index 0000000000..3adbd1a876 --- /dev/null +++ b/framework/format/packet_call_id.h @@ -0,0 +1,747 @@ +/* +** Copyright (c) 2018-2023 Valve Corporation +** Copyright (c) 2018-2023 LunarG, Inc. +** Copyright (c) 2022-2023 Advanced Micro Devices, Inc. All rights reserved. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +/* +** The IDs defined by this header should not be modified. New API call +** IDs should always be appended to the existing API call ID list. +** +*/ + +#ifndef GFXRECON_FORMAT_PACKET_CALL_ID_H +#define GFXRECON_FORMAT_PACKET_CALL_ID_H + +#include "util/defines.h" + +#include + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(format) + +constexpr uint32_t MakePacketCallId(uint16_t family, uint16_t api_call) +{ + return ((static_cast(family) << 16) & 0xffff0000) | (static_cast(api_call) & 0x0000ffff); +} + +constexpr uint16_t GetPacketCallFamily(uint32_t call_id) +{ + return static_cast((call_id >> 16) & 0x0000ffff); +} + +enum PacketFamilyId : uint16_t +{ + PacketFamily_None = 0, + PacketFamily_Vulkan_Functional_Call = 1, + PacketFamily_META_DATA_Call = 2, +}; + +enum PacketCallId : uint32_t +{ + // clang-format off + PacketCall_Unknown = 0x0000, + + // Vulkan API + PacketCall_vkCreateInstance = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1000), + PacketCall_vkDestroyInstance = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1001), + PacketCall_vkEnumeratePhysicalDevices = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1002), + PacketCall_vkGetPhysicalDeviceFeatures = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1003), + PacketCall_vkGetPhysicalDeviceFormatProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1004), + PacketCall_vkGetPhysicalDeviceImageFormatProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1005), + PacketCall_vkGetPhysicalDeviceProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1006), + PacketCall_vkGetPhysicalDeviceQueueFamilyProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1007), + PacketCall_vkGetPhysicalDeviceMemoryProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1008), + PacketCall_vkGetInstanceProcAddr = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1009), + PacketCall_vkGetDeviceProcAddr = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x100a), + PacketCall_vkCreateDevice = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x100b), + PacketCall_vkDestroyDevice = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x100c), + PacketCall_vkEnumerateInstanceExtensionProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x100d), + PacketCall_vkEnumerateDeviceExtensionProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x100e), + PacketCall_vkEnumerateInstanceLayerProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x100f), + PacketCall_vkEnumerateDeviceLayerProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1010), + PacketCall_vkGetDeviceQueue = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1011), + PacketCall_vkQueueSubmit = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1012), + PacketCall_vkQueueWaitIdle = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1013), + PacketCall_vkDeviceWaitIdle = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1014), + PacketCall_vkAllocateMemory = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1015), + PacketCall_vkFreeMemory = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1016), + PacketCall_vkMapMemory = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1017), + PacketCall_vkUnmapMemory = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1018), + PacketCall_vkFlushMappedMemoryRanges = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1019), + PacketCall_vkInvalidateMappedMemoryRanges = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x101a), + PacketCall_vkGetDeviceMemoryCommitment = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x101b), + PacketCall_vkBindBufferMemory = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x101c), + PacketCall_vkBindImageMemory = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x101d), + PacketCall_vkGetBufferMemoryRequirements = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x101e), + PacketCall_vkGetImageMemoryRequirements = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x101f), + PacketCall_vkGetImageSparseMemoryRequirements = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1020), + PacketCall_vkGetPhysicalDeviceSparseImageFormatProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1021), + PacketCall_vkQueueBindSparse = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1022), + PacketCall_vkCreateFence = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1023), + PacketCall_vkDestroyFence = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1024), + PacketCall_vkResetFences = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1025), + PacketCall_vkGetFenceStatus = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1026), + PacketCall_vkWaitForFences = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1027), + PacketCall_vkCreateSemaphore = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1028), + PacketCall_vkDestroySemaphore = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1029), + PacketCall_vkCreateEvent = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x102a), + PacketCall_vkDestroyEvent = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x102b), + PacketCall_vkGetEventStatus = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x102c), + PacketCall_vkSetEvent = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x102d), + PacketCall_vkResetEvent = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x102e), + PacketCall_vkCreateQueryPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x102f), + PacketCall_vkDestroyQueryPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1030), + PacketCall_vkGetQueryPoolResults = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1031), + PacketCall_vkCreateBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1032), + PacketCall_vkDestroyBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1033), + PacketCall_vkCreateBufferView = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1034), + PacketCall_vkDestroyBufferView = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1035), + PacketCall_vkCreateImage = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1036), + PacketCall_vkDestroyImage = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1037), + PacketCall_vkGetImageSubresourceLayout = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1038), + PacketCall_vkCreateImageView = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1039), + PacketCall_vkDestroyImageView = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x103a), + PacketCall_vkCreateShaderModule = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x103b), + PacketCall_vkDestroyShaderModule = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x103c), + PacketCall_vkCreatePipelineCache = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x103d), + PacketCall_vkDestroyPipelineCache = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x103e), + PacketCall_vkGetPipelineCacheData = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x103f), + PacketCall_vkMergePipelineCaches = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1040), + PacketCall_vkCreateGraphicsPipelines = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1041), + PacketCall_vkCreateComputePipelines = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1042), + PacketCall_vkDestroyPipeline = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1043), + PacketCall_vkCreatePipelineLayout = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1044), + PacketCall_vkDestroyPipelineLayout = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1045), + PacketCall_vkCreateSampler = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1046), + PacketCall_vkDestroySampler = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1047), + PacketCall_vkCreateDescriptorSetLayout = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1048), + PacketCall_vkDestroyDescriptorSetLayout = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1049), + PacketCall_vkCreateDescriptorPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x104a), + PacketCall_vkDestroyDescriptorPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x104b), + PacketCall_vkResetDescriptorPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x104c), + PacketCall_vkAllocateDescriptorSets = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x104d), + PacketCall_vkFreeDescriptorSets = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x104e), + PacketCall_vkUpdateDescriptorSets = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x104f), + PacketCall_vkCreateFramebuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1050), + PacketCall_vkDestroyFramebuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1051), + PacketCall_vkCreateRenderPass = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1052), + PacketCall_vkDestroyRenderPass = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1053), + PacketCall_vkGetRenderAreaGranularity = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1054), + PacketCall_vkCreateCommandPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1055), + PacketCall_vkDestroyCommandPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1056), + PacketCall_vkResetCommandPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1057), + PacketCall_vkAllocateCommandBuffers = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1058), + PacketCall_vkFreeCommandBuffers = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1059), + PacketCall_vkBeginCommandBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x105a), + PacketCall_vkEndCommandBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x105b), + PacketCall_vkResetCommandBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x105c), + PacketCall_vkCmdBindPipeline = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x105d), + PacketCall_vkCmdSetViewport = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x105e), + PacketCall_vkCmdSetScissor = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x105f), + PacketCall_vkCmdSetLineWidth = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1060), + PacketCall_vkCmdSetDepthBias = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1061), + PacketCall_vkCmdSetBlendConstants = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1062), + PacketCall_vkCmdSetDepthBounds = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1063), + PacketCall_vkCmdSetStencilCompareMask = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1064), + PacketCall_vkCmdSetStencilWriteMask = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1065), + PacketCall_vkCmdSetStencilReference = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1066), + PacketCall_vkCmdBindDescriptorSets = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1067), + PacketCall_vkCmdBindIndexBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1068), + PacketCall_vkCmdBindVertexBuffers = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1069), + PacketCall_vkCmdDraw = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x106a), + PacketCall_vkCmdDrawIndexed = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x106b), + PacketCall_vkCmdDrawIndirect = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x106c), + PacketCall_vkCmdDrawIndexedIndirect = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x106d), + PacketCall_vkCmdDispatch = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x106e), + PacketCall_vkCmdDispatchIndirect = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x106f), + PacketCall_vkCmdCopyBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1070), + PacketCall_vkCmdCopyImage = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1071), + PacketCall_vkCmdBlitImage = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1072), + PacketCall_vkCmdCopyBufferToImage = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1073), + PacketCall_vkCmdCopyImageToBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1074), + PacketCall_vkCmdUpdateBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1075), + PacketCall_vkCmdFillBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1076), + PacketCall_vkCmdClearColorImage = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1077), + PacketCall_vkCmdClearDepthStencilImage = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1078), + PacketCall_vkCmdClearAttachments = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1079), + PacketCall_vkCmdResolveImage = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x107a), + PacketCall_vkCmdSetEvent = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x107b), + PacketCall_vkCmdResetEvent = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x107c), + PacketCall_vkCmdWaitEvents = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x107d), + PacketCall_vkCmdPipelineBarrier = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x107e), + PacketCall_vkCmdBeginQuery = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x107f), + PacketCall_vkCmdEndQuery = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1080), + PacketCall_vkCmdResetQueryPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1081), + PacketCall_vkCmdWriteTimestamp = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1082), + PacketCall_vkCmdCopyQueryPoolResults = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1083), + PacketCall_vkCmdPushConstants = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1084), + PacketCall_vkCmdBeginRenderPass = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1085), + PacketCall_vkCmdNextSubpass = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1086), + PacketCall_vkCmdEndRenderPass = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1087), + PacketCall_vkCmdExecuteCommands = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1088), + PacketCall_vkEnumerateInstanceVersion = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1089), + PacketCall_vkBindBufferMemory2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x108a), + PacketCall_vkBindImageMemory2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x108b), + PacketCall_vkGetDeviceGroupPeerMemoryFeatures = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x108c), + PacketCall_vkCmdSetDeviceMask = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x108d), + PacketCall_vkCmdDispatchBase = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x108e), + PacketCall_vkEnumeratePhysicalDeviceGroups = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x108f), + PacketCall_vkGetImageMemoryRequirements2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1090), + PacketCall_vkGetBufferMemoryRequirements2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1091), + PacketCall_vkGetImageSparseMemoryRequirements2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1092), + PacketCall_vkGetPhysicalDeviceFeatures2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1093), + PacketCall_vkGetPhysicalDeviceProperties2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1094), + PacketCall_vkGetPhysicalDeviceFormatProperties2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1095), + PacketCall_vkGetPhysicalDeviceImageFormatProperties2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1096), + PacketCall_vkGetPhysicalDeviceQueueFamilyProperties2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1097), + PacketCall_vkGetPhysicalDeviceMemoryProperties2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1098), + PacketCall_vkGetPhysicalDeviceSparseImageFormatProperties2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1099), + PacketCall_vkTrimCommandPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x109a), + PacketCall_vkGetDeviceQueue2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x109b), + PacketCall_vkCreateSamplerYcbcrConversion = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x109c), + PacketCall_vkDestroySamplerYcbcrConversion = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x109d), + PacketCall_vkCreateDescriptorUpdateTemplate = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x109e), + PacketCall_vkDestroyDescriptorUpdateTemplate = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x109f), + PacketCall_vkUpdateDescriptorSetWithTemplate = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a0), + PacketCall_vkGetPhysicalDeviceExternalBufferProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a1), + PacketCall_vkGetPhysicalDeviceExternalFenceProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a2), + PacketCall_vkGetPhysicalDeviceExternalSemaphoreProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a3), + PacketCall_vkGetDescriptorSetLayoutSupport = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a4), + PacketCall_vkDestroySurfaceKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a5), + PacketCall_vkGetPhysicalDeviceSurfaceSupportKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a6), + PacketCall_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a7), + PacketCall_vkGetPhysicalDeviceSurfaceFormatsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a8), + PacketCall_vkGetPhysicalDeviceSurfacePresentModesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10a9), + PacketCall_vkCreateSwapchainKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10aa), + PacketCall_vkDestroySwapchainKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ab), + PacketCall_vkGetSwapchainImagesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ac), + PacketCall_vkAcquireNextImageKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ad), + PacketCall_vkQueuePresentKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ae), + PacketCall_vkGetDeviceGroupPresentCapabilitiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10af), + PacketCall_vkGetDeviceGroupSurfacePresentModesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b0), + PacketCall_vkGetPhysicalDevicePresentRectanglesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b1), + PacketCall_vkAcquireNextImage2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b2), + PacketCall_vkGetPhysicalDeviceDisplayPropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b3), + PacketCall_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b4), + PacketCall_vkGetDisplayPlaneSupportedDisplaysKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b5), + PacketCall_vkGetDisplayModePropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b6), + PacketCall_vkCreateDisplayModeKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b7), + PacketCall_vkGetDisplayPlaneCapabilitiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b8), + PacketCall_vkCreateDisplayPlaneSurfaceKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10b9), + PacketCall_vkCreateSharedSwapchainsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ba), + PacketCall_vkCreateXlibSurfaceKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10bb), + PacketCall_vkGetPhysicalDeviceXlibPresentationSupportKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10bc), + PacketCall_vkCreateXcbSurfaceKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10bd), + PacketCall_vkGetPhysicalDeviceXcbPresentationSupportKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10be), + PacketCall_vkCreateWaylandSurfaceKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10bf), + PacketCall_vkGetPhysicalDeviceWaylandPresentationSupportKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c0), + PacketCall_vkCreateMirSurfaceKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c1), + PacketCall_vkGetPhysicalDeviceMirPresentationSupportKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c2), + PacketCall_vkCreateAndroidSurfaceKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c3), + PacketCall_vkCreateWin32SurfaceKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c4), + PacketCall_vkGetPhysicalDeviceWin32PresentationSupportKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c5), + PacketCall_vkGetPhysicalDeviceFeatures2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c6), + PacketCall_vkGetPhysicalDeviceProperties2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c7), + PacketCall_vkGetPhysicalDeviceFormatProperties2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c8), + PacketCall_vkGetPhysicalDeviceImageFormatProperties2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10c9), + PacketCall_vkGetPhysicalDeviceQueueFamilyProperties2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ca), + PacketCall_vkGetPhysicalDeviceMemoryProperties2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10cb), + PacketCall_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10cc), + PacketCall_vkGetDeviceGroupPeerMemoryFeaturesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10cd), + PacketCall_vkCmdSetDeviceMaskKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ce), + PacketCall_vkCmdDispatchBaseKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10cf), + PacketCall_vkTrimCommandPoolKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d0), + PacketCall_vkEnumeratePhysicalDeviceGroupsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d1), + PacketCall_vkGetPhysicalDeviceExternalBufferPropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d2), + PacketCall_vkGetMemoryWin32HandleKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d3), + PacketCall_vkGetMemoryWin32HandlePropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d4), + PacketCall_vkGetMemoryFdKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d5), + PacketCall_vkGetMemoryFdPropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d6), + PacketCall_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d7), + PacketCall_vkImportSemaphoreWin32HandleKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d8), + PacketCall_vkGetSemaphoreWin32HandleKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10d9), + PacketCall_vkImportSemaphoreFdKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10da), + PacketCall_vkGetSemaphoreFdKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10db), + PacketCall_vkCmdPushDescriptorSetKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10dc), + PacketCall_vkCmdPushDescriptorSetWithTemplateKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10dd), + PacketCall_vkCreateDescriptorUpdateTemplateKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10de), + PacketCall_vkDestroyDescriptorUpdateTemplateKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10df), + PacketCall_vkUpdateDescriptorSetWithTemplateKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e0), + PacketCall_vkCreateRenderPass2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e1), + PacketCall_vkCmdBeginRenderPass2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e2), + PacketCall_vkCmdNextSubpass2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e3), + PacketCall_vkCmdEndRenderPass2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e4), + PacketCall_vkGetSwapchainStatusKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e5), + PacketCall_vkGetPhysicalDeviceExternalFencePropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e6), + PacketCall_vkImportFenceWin32HandleKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e7), + PacketCall_vkGetFenceWin32HandleKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e8), + PacketCall_vkImportFenceFdKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10e9), + PacketCall_vkGetFenceFdKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ea), + PacketCall_vkGetPhysicalDeviceSurfaceCapabilities2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10eb), + PacketCall_vkGetPhysicalDeviceSurfaceFormats2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ec), + PacketCall_vkGetPhysicalDeviceDisplayProperties2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ed), + PacketCall_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ee), + PacketCall_vkGetDisplayModeProperties2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ef), + PacketCall_vkGetDisplayPlaneCapabilities2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f0), + PacketCall_vkGetImageMemoryRequirements2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f1), + PacketCall_vkGetBufferMemoryRequirements2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f2), + PacketCall_vkGetImageSparseMemoryRequirements2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f3), + PacketCall_vkCreateSamplerYcbcrConversionKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f4), + PacketCall_vkDestroySamplerYcbcrConversionKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f5), + PacketCall_vkBindBufferMemory2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f6), + PacketCall_vkBindImageMemory2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f7), + PacketCall_vkGetDescriptorSetLayoutSupportKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f8), + PacketCall_vkCmdDrawIndirectCountKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10f9), + PacketCall_vkCmdDrawIndexedIndirectCountKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10fa), + PacketCall_vkCreateDebugReportCallbackEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10fb), + PacketCall_vkDestroyDebugReportCallbackEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10fc), + PacketCall_vkDebugReportMessageEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10fd), + PacketCall_vkDebugMarkerSetObjectTagEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10fe), + PacketCall_vkDebugMarkerSetObjectNameEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x10ff), + PacketCall_vkCmdDebugMarkerBeginEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1100), + PacketCall_vkCmdDebugMarkerEndEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1101), + PacketCall_vkCmdDebugMarkerInsertEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1102), + PacketCall_vkCmdDrawIndirectCountAMD = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1103), + PacketCall_vkCmdDrawIndexedIndirectCountAMD = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1104), + PacketCall_vkGetShaderInfoAMD = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1105), + PacketCall_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1106), + PacketCall_vkGetMemoryWin32HandleNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1107), + PacketCall_vkCreateViSurfaceNN = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1108), + PacketCall_vkCmdBeginConditionalRenderingEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1109), + PacketCall_vkCmdEndConditionalRenderingEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x110a), + PacketCall_vkCmdProcessCommandsNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x110b), + PacketCall_vkCmdReserveSpaceForCommandsNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x110c), + PacketCall_vkCreateIndirectCommandsLayoutNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x110d), + PacketCall_vkDestroyIndirectCommandsLayoutNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x110e), + PacketCall_vkCreateObjectTableNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x110f), + PacketCall_vkDestroyObjectTableNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1110), + PacketCall_vkRegisterObjectsNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1111), + PacketCall_vkUnregisterObjectsNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1112), + PacketCall_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1113), + PacketCall_vkCmdSetViewportWScalingNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1114), + PacketCall_vkReleaseDisplayEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1115), + PacketCall_vkAcquireXlibDisplayEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1116), + PacketCall_vkGetRandROutputDisplayEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1117), + PacketCall_vkGetPhysicalDeviceSurfaceCapabilities2EXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1118), + PacketCall_vkDisplayPowerControlEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1119), + PacketCall_vkRegisterDeviceEventEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x111a), + PacketCall_vkRegisterDisplayEventEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x111b), + PacketCall_vkGetSwapchainCounterEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x111c), + PacketCall_vkGetRefreshCycleDurationGOOGLE = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x111d), + PacketCall_vkGetPastPresentationTimingGOOGLE = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x111e), + PacketCall_vkCmdSetDiscardRectangleEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x111f), + PacketCall_vkSetHdrMetadataEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1120), + PacketCall_vkCreateIOSSurfaceMVK = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1121), + PacketCall_vkCreateMacOSSurfaceMVK = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1122), + PacketCall_vkSetDebugUtilsObjectNameEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1123), + PacketCall_vkSetDebugUtilsObjectTagEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1124), + PacketCall_vkQueueBeginDebugUtilsLabelEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1125), + PacketCall_vkQueueEndDebugUtilsLabelEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1126), + PacketCall_vkQueueInsertDebugUtilsLabelEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1127), + PacketCall_vkCmdBeginDebugUtilsLabelEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1128), + PacketCall_vkCmdEndDebugUtilsLabelEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1129), + PacketCall_vkCmdInsertDebugUtilsLabelEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x112a), + PacketCall_vkCreateDebugUtilsMessengerEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x112b), + PacketCall_vkDestroyDebugUtilsMessengerEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x112c), + PacketCall_vkSubmitDebugUtilsMessageEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x112d), + PacketCall_vkGetAndroidHardwareBufferPropertiesANDROID = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x112e), + PacketCall_vkGetMemoryAndroidHardwareBufferANDROID = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x112f), + PacketCall_vkCmdSetSampleLocationsEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1130), + PacketCall_vkGetPhysicalDeviceMultisamplePropertiesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1131), + PacketCall_vkCreateValidationCacheEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1132), + PacketCall_vkDestroyValidationCacheEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1133), + PacketCall_vkMergeValidationCachesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1134), + PacketCall_vkGetValidationCacheDataEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1135), + PacketCall_vkGetMemoryHostPointerPropertiesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1136), + PacketCall_vkCmdWriteBufferMarkerAMD = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1137), + PacketCall_vkCmdBindShadingRateImageNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1138), + PacketCall_vkCmdSetViewportShadingRatePaletteNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1139), + PacketCall_vkCmdSetCoarseSampleOrderNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x113a), + PacketCall_vkGetImageDrmFormatModifierPropertiesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x113b), + PacketCall_vkCreateAccelerationStructureNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x113c), + PacketCall_vkDestroyAccelerationStructureNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x113d), + PacketCall_vkGetAccelerationStructureMemoryRequirementsNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x113e), + PacketCall_vkBindAccelerationStructureMemoryNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x113f), + PacketCall_vkCmdBuildAccelerationStructureNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1140), + PacketCall_vkCmdCopyAccelerationStructureNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1141), + PacketCall_vkCmdTraceRaysNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1142), + PacketCall_vkCreateRayTracingPipelinesNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1143), + PacketCall_vkGetRayTracingShaderGroupHandlesNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1144), + PacketCall_vkGetAccelerationStructureHandleNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1145), + PacketCall_vkCmdWriteAccelerationStructuresPropertiesNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1146), + PacketCall_vkCompileDeferredNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1147), + PacketCall_vkCmdDrawMeshTasksNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1148), + PacketCall_vkCmdDrawMeshTasksIndirectNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1149), + PacketCall_vkCmdDrawMeshTasksIndirectCountNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x114a), + PacketCall_vkCmdSetExclusiveScissorNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x114b), + PacketCall_vkCmdSetCheckpointNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x114c), + PacketCall_vkGetQueueCheckpointDataNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x114d), + PacketCall_vkCreateImagePipeSurfaceFUCHSIA = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x114e), + PacketCall_vkCmdBindTransformFeedbackBuffersEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x114f), + PacketCall_vkCmdBeginTransformFeedbackEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1150), + PacketCall_vkCmdEndTransformFeedbackEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1151), + PacketCall_vkCmdBeginQueryIndexedEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1152), + PacketCall_vkCmdEndQueryIndexedEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1153), + PacketCall_vkCmdDrawIndirectByteCountEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1154), + PacketCall_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1155), + PacketCall_vkGetCalibratedTimestampsEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1156), + PacketCall_vkGetBufferDeviceAddressEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1157), + PacketCall_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1158), + PacketCall_vkGetImageViewHandleNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1159), + PacketCall_vkCreateMetalSurfaceEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x115a), + PacketCall_vkCreateStreamDescriptorSurfaceGGP = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x115b), + PacketCall_vkSetLocalDimmingAMD = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x115c), + PacketCall_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x115d), + PacketCall_vkGetPhysicalDeviceSurfacePresentModes2EXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x115e), + PacketCall_vkAcquireFullScreenExclusiveModeEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x115f), + PacketCall_vkReleaseFullScreenExclusiveModeEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1160), + PacketCall_vkGetDeviceGroupSurfacePresentModes2EXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1161), + PacketCall_vkCreateHeadlessSurfaceEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1162), + PacketCall_vkResetQueryPoolEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1163), + PacketCall_vkGetPipelineExecutablePropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1164), + PacketCall_vkGetPipelineExecutableStatisticsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1165), + PacketCall_vkGetPipelineExecutableInternalRepresentationsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1166), + PacketCall_vkInitializePerformanceApiINTEL = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1167), + PacketCall_vkUninitializePerformanceApiINTEL = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1168), + PacketCall_vkCmdSetPerformanceMarkerINTEL = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1169), + PacketCall_vkCmdSetPerformanceStreamMarkerINTEL = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x116a), + PacketCall_vkCmdSetPerformanceOverrideINTEL = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x116b), + PacketCall_vkAcquirePerformanceConfigurationINTEL = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x116c), + PacketCall_vkReleasePerformanceConfigurationINTEL = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x116d), + PacketCall_vkQueueSetPerformanceConfigurationINTEL = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x116e), + PacketCall_vkGetPerformanceParameterINTEL = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x116f), + PacketCall_vkCmdSetLineStippleEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1170), + PacketCall_vkGetSemaphoreCounterValueKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1171), + PacketCall_vkWaitSemaphoresKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1172), + PacketCall_vkSignalSemaphoreKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1173), + PacketCall_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1174), + PacketCall_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1175), + PacketCall_vkAcquireProfilingLockKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1176), + PacketCall_vkReleaseProfilingLockKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1177), + PacketCall_vkGetBufferDeviceAddressKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1178), + PacketCall_vkGetBufferOpaqueCaptureAddressKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1179), + PacketCall_vkGetDeviceMemoryOpaqueCaptureAddressKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x117a), + PacketCall_vkGetPhysicalDeviceToolPropertiesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x117b), + PacketCall_vkCmdDrawIndirectCount = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x117c), + PacketCall_vkCmdDrawIndexedIndirectCount = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x117d), + PacketCall_vkCreateRenderPass2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x117e), + PacketCall_vkCmdBeginRenderPass2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x117f), + PacketCall_vkCmdNextSubpass2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1180), + PacketCall_vkCmdEndRenderPass2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1181), + PacketCall_vkResetQueryPool = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1182), + PacketCall_vkGetSemaphoreCounterValue = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1183), + PacketCall_vkWaitSemaphores = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1184), + PacketCall_vkSignalSemaphore = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1185), + PacketCall_vkGetBufferDeviceAddress = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1186), + PacketCall_vkGetBufferOpaqueCaptureAddress = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1187), + PacketCall_vkGetDeviceMemoryOpaqueCaptureAddress = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1188), + PacketCall_vkCreateDeferredOperationKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1189), + PacketCall_vkDestroyDeferredOperationKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x118a), + PacketCall_vkGetDeferredOperationMaxConcurrencyKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x118b), + PacketCall_vkGetDeferredOperationResultKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x118c), + PacketCall_vkDeferredOperationJoinKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x118d), + PacketCall_vkCreateAccelerationStructureKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x118e), + PacketCall_vkDestroyAccelerationStructureKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x118f), + PacketCall_vkGetAccelerationStructureMemoryRequirementsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1190), + PacketCall_vkBindAccelerationStructureMemoryKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1191), + PacketCall_vkCmdBuildAccelerationStructuresKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1192), + PacketCall_vkCmdBuildAccelerationStructuresIndirectKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1193), + PacketCall_vkBuildAccelerationStructuresKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1194), + PacketCall_vkCopyAccelerationStructureKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1195), + PacketCall_vkCopyAccelerationStructureToMemoryKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1196), + PacketCall_vkCopyMemoryToAccelerationStructureKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1197), + PacketCall_vkWriteAccelerationStructuresPropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1198), + PacketCall_vkCmdCopyAccelerationStructureKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1199), + PacketCall_vkCmdCopyAccelerationStructureToMemoryKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x119a), + PacketCall_vkCmdCopyMemoryToAccelerationStructureKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x119b), + PacketCall_vkCmdTraceRaysKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x119c), + PacketCall_vkCreateRayTracingPipelinesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x119d), + PacketCall_vkGetRayTracingShaderGroupHandlesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x119e), + PacketCall_vkCmdWriteAccelerationStructuresPropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x119f), + PacketCall_vkGetAccelerationStructureDeviceAddressKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1200), + PacketCall_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1201), + PacketCall_vkCmdTraceRaysIndirectKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1202), + PacketCall_vkGetDeviceAccelerationStructureCompatibilityKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1203), + PacketCall_vkGetGeneratedCommandsMemoryRequirementsNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1204), + PacketCall_vkCmdPreprocessGeneratedCommandsNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1205), + PacketCall_vkCmdExecuteGeneratedCommandsNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1206), + PacketCall_vkCmdBindPipelineShaderGroupNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1207), + PacketCall_vkCreateIndirectCommandsLayoutNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1208), + PacketCall_vkDestroyIndirectCommandsLayoutNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1209), + PacketCall_vkGetImageViewAddressNVX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x120a), + PacketCall_vkCreatePrivateDataSlotEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x120b), + PacketCall_vkDestroyPrivateDataSlotEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x120c), + PacketCall_vkSetPrivateDataEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x120d), + PacketCall_vkGetPrivateDataEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x120e), + PacketCall_vkCmdSetCullModeEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x120f), + PacketCall_vkCmdSetFrontFaceEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1210), + PacketCall_vkCmdSetPrimitiveTopologyEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1211), + PacketCall_vkCmdSetViewportWithCountEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1212), + PacketCall_vkCmdSetScissorWithCountEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1213), + PacketCall_vkCmdBindVertexBuffers2EXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1214), + PacketCall_vkCmdSetDepthTestEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1215), + PacketCall_vkCmdSetDepthWriteEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1216), + PacketCall_vkCmdSetDepthCompareOpEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1217), + PacketCall_vkCmdSetDepthBoundsTestEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1218), + PacketCall_vkCmdSetStencilTestEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1219), + PacketCall_vkCmdSetStencilOpEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x121a), + PacketCall_vkCreateDirectFBSurfaceEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x121b), + PacketCall_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x121c), + PacketCall_vkCmdCopyBuffer2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x121d), + PacketCall_vkCmdCopyImage2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x121e), + PacketCall_vkCmdCopyBufferToImage2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x121f), + PacketCall_vkCmdCopyImageToBuffer2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1220), + PacketCall_vkCmdBlitImage2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1221), + PacketCall_vkCmdResolveImage2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1222), + PacketCall_vkGetAccelerationStructureBuildSizesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1223), + PacketCall_vkGetRayTracingShaderGroupStackSizeKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1224), + PacketCall_vkCmdSetRayTracingPipelineStackSizeKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1225), + PacketCall_vkGetPhysicalDeviceFragmentShadingRatesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1226), + PacketCall_vkCmdSetFragmentShadingRateKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1227), + PacketCall_vkCmdSetFragmentShadingRateEnumNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1228), + PacketCall_vkAcquireWinrtDisplayNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1229), + PacketCall_vkGetWinrtDisplayNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x122a), + PacketCall_vkCmdSetEvent2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x122b), + PacketCall_vkCmdResetEvent2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x122c), + PacketCall_vkCmdWaitEvents2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x122d), + PacketCall_vkCmdPipelineBarrier2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x122e), + PacketCall_vkCmdWriteTimestamp2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x122f), + PacketCall_vkQueueSubmit2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1230), + PacketCall_vkCmdWriteBufferMarker2AMD = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1231), + PacketCall_vkGetQueueCheckpointData2NV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1232), + PacketCall_vkCmdSetVertexInputEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1233), + PacketCall_vkGetMemoryZirconHandleFUCHSIA = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1234), + PacketCall_vkGetMemoryZirconHandlePropertiesFUCHSIA = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1235), + PacketCall_vkImportSemaphoreZirconHandleFUCHSIA = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1236), + PacketCall_vkGetSemaphoreZirconHandleFUCHSIA = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1237), + PacketCall_vkCmdSetPatchControlPointsEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1238), + PacketCall_vkCmdSetRasterizerDiscardEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1239), + PacketCall_vkCmdSetDepthBiasEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x123a), + PacketCall_vkCmdSetLogicOpEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x123b), + PacketCall_vkCmdSetPrimitiveRestartEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x123c), + PacketCall_vkCreateScreenSurfaceQNX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x123d), + PacketCall_vkGetPhysicalDeviceScreenPresentationSupportQNX = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x123e), + PacketCall_vkCmdSetColorWriteEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x123f), + PacketCall_vkAcquireDrmDisplayEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1240), + PacketCall_vkGetDrmDisplayEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1241), + PacketCall_vkCmdDrawMultiEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1242), + PacketCall_vkCmdDrawMultiIndexedEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1243), + PacketCall_vkWaitForPresentKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1244), + PacketCall_vkCmdBindInvocationMaskHUAWEI = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1245), + PacketCall_vkGetMemoryRemoteAddressNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1246), + PacketCall_vkGetDeviceBufferMemoryRequirementsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1247), + PacketCall_vkGetDeviceImageMemoryRequirementsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1248), + PacketCall_vkGetDeviceImageSparseMemoryRequirementsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1249), + PacketCall_vkSetDeviceMemoryPriorityEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x124a), + PacketCall_vkCmdBeginRenderingKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x124b), + PacketCall_vkCmdEndRenderingKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x124c), + PacketCall_vkGetPhysicalDeviceToolProperties = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x124d), + PacketCall_vkCreatePrivateDataSlot = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x124e), + PacketCall_vkDestroyPrivateDataSlot = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x124f), + PacketCall_vkSetPrivateData = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1250), + PacketCall_vkGetPrivateData = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1251), + PacketCall_vkCmdSetEvent2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1252), + PacketCall_vkCmdResetEvent2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1253), + PacketCall_vkCmdWaitEvents2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1254), + PacketCall_vkCmdPipelineBarrier2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1255), + PacketCall_vkCmdWriteTimestamp2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1256), + PacketCall_vkQueueSubmit2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1257), + PacketCall_vkCmdCopyBuffer2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1258), + PacketCall_vkCmdCopyImage2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1259), + PacketCall_vkCmdCopyBufferToImage2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x125a), + PacketCall_vkCmdCopyImageToBuffer2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x125b), + PacketCall_vkCmdBlitImage2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x125c), + PacketCall_vkCmdResolveImage2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x125d), + PacketCall_vkCmdBeginRendering = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x125e), + PacketCall_vkCmdEndRendering = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x125f), + PacketCall_vkCmdSetCullMode = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1260), + PacketCall_vkCmdSetFrontFace = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1261), + PacketCall_vkCmdSetPrimitiveTopology = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1262), + PacketCall_vkCmdSetViewportWithCount = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1263), + PacketCall_vkCmdSetScissorWithCount = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1264), + PacketCall_vkCmdBindVertexBuffers2 = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1265), + PacketCall_vkCmdSetDepthTestEnable = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1266), + PacketCall_vkCmdSetDepthWriteEnable = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1267), + PacketCall_vkCmdSetDepthCompareOp = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1268), + PacketCall_vkCmdSetDepthBoundsTestEnable = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1269), + PacketCall_vkCmdSetStencilTestEnable = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x126a), + PacketCall_vkCmdSetStencilOp = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x126b), + PacketCall_vkCmdSetRasterizerDiscardEnable = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x126c), + PacketCall_vkCmdSetDepthBiasEnable = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x126d), + PacketCall_vkCmdSetPrimitiveRestartEnable = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x126e), + PacketCall_vkGetDeviceBufferMemoryRequirements = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x126f), + PacketCall_vkGetDeviceImageMemoryRequirements = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1270), + PacketCall_vkGetDeviceImageSparseMemoryRequirements = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1271), + PacketCall_vkGetDescriptorSetLayoutHostMappingInfoVALVE = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1272), + PacketCall_vkGetDescriptorSetHostMappingVALVE = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1273), + PacketCall_vkCmdTraceRaysIndirect2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1274), + PacketCall_vkGetImageSubresourceLayout2EXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1275), + PacketCall_vkGetPipelinePropertiesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1276), + PacketCall_vkGetShaderModuleIdentifierEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1277), + PacketCall_vkGetShaderModuleCreateInfoIdentifierEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1278), + PacketCall_vkGetFramebufferTilePropertiesQCOM = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1279), + PacketCall_vkGetDynamicRenderingTilePropertiesQCOM = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x127a), + PacketCall_vkGetDeviceFaultInfoEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x127b), + PacketCall_vkCreateMicromapEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x127c), + PacketCall_vkDestroyMicromapEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x127d), + PacketCall_vkCmdBuildMicromapsEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x127e), + PacketCall_vkBuildMicromapsEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x127f), + PacketCall_vkCopyMicromapEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1280), + PacketCall_vkCopyMicromapToMemoryEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1281), + PacketCall_vkCopyMemoryToMicromapEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1282), + PacketCall_vkWriteMicromapsPropertiesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1283), + PacketCall_vkCmdCopyMicromapEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1284), + PacketCall_vkCmdCopyMicromapToMemoryEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1285), + PacketCall_vkCmdCopyMemoryToMicromapEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1286), + PacketCall_vkCmdWriteMicromapsPropertiesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1287), + PacketCall_vkGetDeviceMicromapCompatibilityEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1288), + PacketCall_vkGetMicromapBuildSizesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1289), + PacketCall_vkCmdSetTessellationDomainOriginEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x128a), + PacketCall_vkCmdSetDepthClampEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x128b), + PacketCall_vkCmdSetPolygonModeEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x128c), + PacketCall_vkCmdSetRasterizationSamplesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x128d), + PacketCall_vkCmdSetSampleMaskEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x128e), + PacketCall_vkCmdSetAlphaToCoverageEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x128f), + PacketCall_vkCmdSetAlphaToOneEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1290), + PacketCall_vkCmdSetLogicOpEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1291), + PacketCall_vkCmdSetColorBlendEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1292), + PacketCall_vkCmdSetColorBlendEquationEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1293), + PacketCall_vkCmdSetColorWriteMaskEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1294), + PacketCall_vkCmdSetRasterizationStreamEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1295), + PacketCall_vkCmdSetConservativeRasterizationModeEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1296), + PacketCall_vkCmdSetExtraPrimitiveOverestimationSizeEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1297), + PacketCall_vkCmdSetDepthClipEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1298), + PacketCall_vkCmdSetSampleLocationsEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x1299), + PacketCall_vkCmdSetColorBlendAdvancedEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x129a), + PacketCall_vkCmdSetProvokingVertexModeEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x129b), + PacketCall_vkCmdSetLineRasterizationModeEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x129c), + PacketCall_vkCmdSetLineStippleEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x129d), + PacketCall_vkCmdSetDepthClipNegativeOneToOneEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x129e), + PacketCall_vkCmdSetViewportWScalingEnableNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x129f), + PacketCall_vkCmdSetViewportSwizzleNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a0), + PacketCall_vkCmdSetCoverageToColorEnableNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a1), + PacketCall_vkCmdSetCoverageToColorLocationNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a2), + PacketCall_vkCmdSetCoverageModulationModeNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a3), + PacketCall_vkCmdSetCoverageModulationTableEnableNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a4), + PacketCall_vkCmdSetCoverageModulationTableNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a5), + PacketCall_vkCmdSetShadingRateImageEnableNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a6), + PacketCall_vkCmdSetRepresentativeFragmentTestEnableNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a7), + PacketCall_vkCmdSetCoverageReductionModeNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a8), + PacketCall_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12a9), + PacketCall_vkCreateOpticalFlowSessionNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12aa), + PacketCall_vkDestroyOpticalFlowSessionNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12ab), + PacketCall_vkBindOpticalFlowSessionImageNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12ac), + PacketCall_vkCmdOpticalFlowExecuteNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12ad), + PacketCall_vkCmdDrawMeshTasksEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12ae), + PacketCall_vkCmdDrawMeshTasksIndirectEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12af), + PacketCall_vkCmdDrawMeshTasksIndirectCountEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b0), + PacketCall_vkReleaseSwapchainImagesEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b1), + PacketCall_vkCmdDrawClusterHUAWEI = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b2), + PacketCall_vkCmdDrawClusterIndirectHUAWEI = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b3), + PacketCall_vkGetPhysicalDeviceVideoCapabilitiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b4), + PacketCall_vkGetPhysicalDeviceVideoFormatPropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b5), + PacketCall_vkCreateVideoSessionKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b6), + PacketCall_vkDestroyVideoSessionKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b7), + PacketCall_vkGetVideoSessionMemoryRequirementsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b8), + PacketCall_vkBindVideoSessionMemoryKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12b9), + PacketCall_vkCreateVideoSessionParametersKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12ba), + PacketCall_vkUpdateVideoSessionParametersKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12bb), + PacketCall_vkDestroyVideoSessionParametersKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12bc), + PacketCall_vkCmdBeginVideoCodingKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12bd), + PacketCall_vkCmdEndVideoCodingKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12be), + PacketCall_vkCmdControlVideoCodingKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12bf), + PacketCall_vkCmdDecodeVideoKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c0), + PacketCall_vkCmdEncodeVideoKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c1), + PacketCall_vkCmdSetDiscardRectangleEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c2), + PacketCall_vkCmdSetDiscardRectangleModeEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c3), + PacketCall_vkCmdSetExclusiveScissorEnableNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c4), + PacketCall_vkMapMemory2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c5), + PacketCall_vkUnmapMemory2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c6), + PacketCall_vkCreateShadersEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c7), + PacketCall_vkDestroyShaderEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c8), + PacketCall_vkGetShaderBinaryDataEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12c9), + PacketCall_vkCmdBindShadersEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12ca), + PacketCall_vkCmdSetAttachmentFeedbackLoopEnableEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12cb), + PacketCall_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12cc), + PacketCall_vkGetEncodedVideoSessionParametersKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12cd), + PacketCall_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12ce), + PacketCall_vkCmdSetDepthBias2EXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12cf), + PacketCall_vkCopyMemoryToImageEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d0), + PacketCall_vkCopyImageToMemoryEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d1), + PacketCall_vkCopyImageToImageEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d2), + PacketCall_vkTransitionImageLayoutEXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d3), + PacketCall_vkGetPipelineIndirectMemoryRequirementsNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d4), + PacketCall_vkCmdUpdatePipelineIndirectBuffer = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d5), + PacketCall_vkGetPipelineIndirectDeviceAddressNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d6), + PacketCall_vkCmdUpdatePipelineIndirectBufferNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d7), + PacketCall_vkCmdBindIndexBuffer2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d8), + PacketCall_vkGetRenderingAreaGranularityKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12d9), + PacketCall_vkGetDeviceImageSubresourceLayoutKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12da), + PacketCall_vkGetImageSubresourceLayout2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12db), + PacketCall_vkFrameBoundaryANDROID = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12dc), + PacketCall_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12dd), + PacketCall_vkGetCalibratedTimestampsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12de), + PacketCall_vkCmdBindDescriptorSets2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12df), + PacketCall_vkCmdPushConstants2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e0), + PacketCall_vkCmdPushDescriptorSet2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e1), + PacketCall_vkCmdPushDescriptorSetWithTemplate2KHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e2), + PacketCall_vkCmdSetDescriptorBufferOffsets2EXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e3), + PacketCall_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e4), + PacketCall_vkCmdSetRenderingAttachmentLocationsKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e5), + PacketCall_vkCmdSetRenderingInputAttachmentIndicesKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e6), + PacketCall_vkCmdSetLineStippleKHR = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e7), + PacketCall_vkSetLatencySleepModeNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e8), + PacketCall_vkLatencySleepNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12e9), + PacketCall_vkSetLatencyMarkerNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12ea), + PacketCall_vkGetLatencyTimingsNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12eb), + PacketCall_vkQueueNotifyOutOfBandNV = MakePacketCallId(PacketFamily_Vulkan_Functional_Call, 0x12ec), + + PacketCall_DispatchFillMemoryCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12ed), + PacketCall_DispatchFixDeviceAddresCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12ee), + PacketCall_DispatchResizeWindowCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12ef), + PacketCall_DispatchResizeWindowCommand2 = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f0), + PacketCall_DispatchDisplayMessageCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f1), + PacketCall_DispatchCreateHardwareBufferCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f2), + PacketCall_DispatchDestroyHardwareBufferCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f3), + PacketCall_DispatchSetDevicePropertiesCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f4), + PacketCall_DispatchSetDeviceMemoryPropertiesCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f5), + PacketCall_DispatchSetOpaqueAddressCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f6), + PacketCall_DispatchSetRayTracingShaderGroupHandlesCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f7), + PacketCall_DispatchSetSwapchainImageStateCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f8), + PacketCall_DispatchBeginResourceInitCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12f9), + PacketCall_DispatchEndResourceInitCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12fa), + PacketCall_DispatchInitBufferCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12fb), + PacketCall_DispatchInitImageCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12fc), + PacketCall_DispatchSetTlasToBlasDependencyCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12fd), + PacketCall_DispatchVulkanAccelerationStructuresBuildMetaCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12fe), + PacketCall_DispatchVulkanAccelerationStructuresCopyMetaCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x12ff), + PacketCall_DispatchVulkanAccelerationStructuresWritePropertiesMetaCommand = MakePacketCallId(PacketFamily_META_DATA_Call, 0x1300), + + PacketCall_VulkanLast, + + // clang-format on +}; + +GFXRECON_END_NAMESPACE(gfxrecon) +GFXRECON_END_NAMESPACE(format) + +#endif // GFXRECON_FORMAT_PACKET_CALL_ID_H diff --git a/framework/generated/generate_vulkan.py b/framework/generated/generate_vulkan.py index 3275799a95..87f6f727b6 100644 --- a/framework/generated/generate_vulkan.py +++ b/framework/generated/generate_vulkan.py @@ -90,6 +90,12 @@ 'generated_vulkan_cpp_consumer_extension.h', 'generated_vulkan_cpp_consumer_extension.cpp', 'generated_vulkan_stype_util.h', + 'generated_vulkan_struct_packet.h', + 'generated_vulkan_preload_decoder.h', + 'generated_vulkan_preload_decoder.cpp', + 'generated_vulkan_preload_replayer.h', + 'generated_vulkan_preload_replayer.cpp', + 'generated_vulkan_preload_decode_pnext_struct.cpp', ] if __name__ == '__main__': diff --git a/framework/generated/generated_vulkan_preload_decode_pnext_struct.cpp b/framework/generated/generated_vulkan_preload_decode_pnext_struct.cpp new file mode 100644 index 0000000000..95e988ca77 --- /dev/null +++ b/framework/generated/generated_vulkan_preload_decode_pnext_struct.cpp @@ -0,0 +1,2293 @@ +/* +** Copyright (c) 2018-2023 Valve Corporation +** Copyright (c) 2018-2023 LunarG, Inc. +** Copyright (c) 2023 Advanced Micro Devices, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +/* +** This file is generated from the Khronos Vulkan XML API Registry. +** +*/ + +#include "decode/custom_vulkan_struct_decoders.h" +#include "decode/decode_allocator.h" +#include "decode/vulkan_pnext_node.h" +#include "decode/vulkan_pnext_typed_node.h" +#include "generated/generated_vulkan_struct_decoders.h" +#include "generated/generated_vulkan_enum_to_string.h" +#include "util/logging.h" + +#include + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +size_t PreloadDecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, PNextNode** pNext) +{ + assert(pNext != nullptr); + + size_t bytes_read = 0; + uint32_t attrib = 0; + + if ((parameter_buffer != nullptr) && (buffer_size >= sizeof(attrib))) + { + size_t stype_offset = 0; + + // Peek at the pointer attribute mask to make sure we have a non-NULL value that can be decoded. + attrib = *(reinterpret_cast(parameter_buffer)); + + if ((attrib & format::PointerAttributes::kIsNull) != format::PointerAttributes::kIsNull) + { + // Offset to VkStructureType, after the pointer encoding preamble. + stype_offset = sizeof(attrib); + + if ((attrib & format::PointerAttributes::kHasAddress) == format::PointerAttributes::kHasAddress) + { + stype_offset += sizeof(format::AddressEncodeType); + } + } + + if ((stype_offset != 0) && ((buffer_size - stype_offset) >= sizeof(VkStructureType))) + { + const VkStructureType* sType = reinterpret_cast(parameter_buffer + stype_offset); + + switch (*sType) + { + default: + // TODO: This may need to be a fatal error + GFXRECON_LOG_ERROR("Failed to decode pNext value with unrecognized VkStructureType = %s", (util::ToString(*sType).c_str())); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: + (*pNext) = PreloadDecodeAllocator::Allocate>(); + bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size); + break; + } + } + } + + if ((bytes_read == 0) && (attrib != 0)) + { + // The encoded pointer attribute mask included kIsNull, or the sType was unrecognized. + // We will report that we read the attribute mask, but nothing else was decoded. + bytes_read = sizeof(attrib); + } + + return bytes_read; +} + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/generated/generated_vulkan_preload_decoder.cpp b/framework/generated/generated_vulkan_preload_decoder.cpp new file mode 100644 index 0000000000..c0fec95692 --- /dev/null +++ b/framework/generated/generated_vulkan_preload_decoder.cpp @@ -0,0 +1,18418 @@ +/* +** Copyright (c) 2018-2023 Valve Corporation +** Copyright (c) 2018-2023 LunarG, Inc. +** Copyright (c) 2023 Advanced Micro Devices, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +/* +** This file is generated from the Khronos Vulkan XML API Registry. +** +*/ + +#include "decode/handle_pointer_decoder.h" +#include "decode/pointer_decoder.h" +#include "decode/string_array_decoder.h" +#include "decode/string_decoder.h" +#include "decode/struct_pointer_decoder.h" +#include "decode/value_decoder.h" +#include "decode/vulkan_pnext_node.h" +#include "generated/generated_vulkan_decoder.h" +#include "generated/generated_vulkan_struct_decoders_forward.h" +#include "generated/generated_vulkan_struct_packet.h" +#include "generated/generated_vulkan_preload_decoder.h" +#include "util/defines.h" + +#include "vulkan/vulkan.h" +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#include "vk_video/vulkan_video_codecs_common.h" + +#include + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +size_t VulkanPreloadDecoder::Decode_vkCreateInstance(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pInstance; + VkResult return_value; + + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pInstance.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateInstance* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateInstance; + packet->call_info = call_info; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pInstance = pInstance; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyInstance(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyInstance* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyInstance; + packet->call_info = call_info; + packet->instance = instance; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkEnumeratePhysicalDevices(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + PointerDecoder pPhysicalDeviceCount; + HandlePointerDecoder pPhysicalDevices; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pPhysicalDeviceCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPhysicalDevices.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkEnumeratePhysicalDevices* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkEnumeratePhysicalDevices; + packet->call_info = call_info; + packet->instance = instance; + packet->pPhysicalDeviceCount = pPhysicalDeviceCount; + packet->pPhysicalDevices = pPhysicalDevices; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceFeatures(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pFeatures; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pFeatures.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceFeatures* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceFeatures; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pFeatures = pFeatures; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceFormatProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + VkFormat format; + StructPointerDecoder pFormatProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &format); + bytes_read += pFormatProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceFormatProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceFormatProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->format = format; + packet->pFormatProperties = pFormatProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceImageFormatProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; + StructPointerDecoder pImageFormatProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &format); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &type); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &tiling); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &usage); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + bytes_read += pImageFormatProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceImageFormatProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceImageFormatProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->format = format; + packet->type = type; + packet->tiling = tiling; + packet->usage = usage; + packet->flags = flags; + packet->pImageFormatProperties = pImageFormatProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pProperties = pProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceQueueFamilyProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pQueueFamilyPropertyCount; + StructPointerDecoder pQueueFamilyProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pQueueFamilyPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pQueueFamilyProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceQueueFamilyProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceQueueFamilyProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pQueueFamilyPropertyCount = pQueueFamilyPropertyCount; + packet->pQueueFamilyProperties = pQueueFamilyProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceMemoryProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pMemoryProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pMemoryProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceMemoryProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceMemoryProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pMemoryProperties = pMemoryProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDevice(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDevice; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDevice.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDevice* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDevice; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pDevice = pDevice; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyDevice(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyDevice* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyDevice; + packet->call_info = call_info; + packet->device = device; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceQueue(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t queueFamilyIndex; + uint32_t queueIndex; + HandlePointerDecoder pQueue; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueFamilyIndex); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueIndex); + bytes_read += pQueue.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceQueue* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceQueue; + packet->call_info = call_info; + packet->device = device; + packet->queueFamilyIndex = queueFamilyIndex; + packet->queueIndex = queueIndex; + packet->pQueue = pQueue; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueSubmit(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + uint32_t submitCount; + StructPointerDecoder pSubmits; + format::HandleId fence; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &submitCount); + bytes_read += pSubmits.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fence); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkQueueSubmit* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueSubmit; + packet->call_info = call_info; + packet->queue = queue; + packet->submitCount = submitCount; + packet->pSubmits = pSubmits; + packet->fence = fence; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueWaitIdle(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkQueueWaitIdle* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueWaitIdle; + packet->call_info = call_info; + packet->queue = queue; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDeviceWaitIdle(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkDeviceWaitIdle* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDeviceWaitIdle; + packet->call_info = call_info; + packet->device = device; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAllocateMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pAllocateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pMemory; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pAllocateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemory.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAllocateMemory* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAllocateMemory; + packet->call_info = call_info; + packet->device = device; + packet->pAllocateInfo = pAllocateInfo; + packet->pAllocator = pAllocator; + packet->pMemory = pMemory; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkFreeMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId memory; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memory); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkFreeMemory* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkFreeMemory; + packet->call_info = call_info; + packet->device = device; + packet->memory = memory; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkMapMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId memory; + VkDeviceSize offset; + VkDeviceSize size; + VkMemoryMapFlags flags; + PointerDecoder ppData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memory); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &size); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + bytes_read += ppData.DecodeVoidPtr((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkMapMemory* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkMapMemory; + packet->call_info = call_info; + packet->device = device; + packet->memory = memory; + packet->offset = offset; + packet->size = size; + packet->flags = flags; + packet->ppData = ppData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkUnmapMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId memory; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memory); + + Packet_vkUnmapMemory* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkUnmapMemory; + packet->call_info = call_info; + packet->device = device; + packet->memory = memory; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkFlushMappedMemoryRanges(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t memoryRangeCount; + StructPointerDecoder pMemoryRanges; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memoryRangeCount); + bytes_read += pMemoryRanges.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkFlushMappedMemoryRanges* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkFlushMappedMemoryRanges; + packet->call_info = call_info; + packet->device = device; + packet->memoryRangeCount = memoryRangeCount; + packet->pMemoryRanges = pMemoryRanges; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkInvalidateMappedMemoryRanges(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t memoryRangeCount; + StructPointerDecoder pMemoryRanges; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memoryRangeCount); + bytes_read += pMemoryRanges.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkInvalidateMappedMemoryRanges* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkInvalidateMappedMemoryRanges; + packet->call_info = call_info; + packet->device = device; + packet->memoryRangeCount = memoryRangeCount; + packet->pMemoryRanges = pMemoryRanges; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceMemoryCommitment(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId memory; + PointerDecoder pCommittedMemoryInBytes; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memory); + bytes_read += pCommittedMemoryInBytes.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceMemoryCommitment* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceMemoryCommitment; + packet->call_info = call_info; + packet->device = device; + packet->memory = memory; + packet->pCommittedMemoryInBytes = pCommittedMemoryInBytes; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBindBufferMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId buffer; + format::HandleId memory; + VkDeviceSize memoryOffset; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memory); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memoryOffset); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBindBufferMemory* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBindBufferMemory; + packet->call_info = call_info; + packet->device = device; + packet->buffer = buffer; + packet->memory = memory; + packet->memoryOffset = memoryOffset; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBindImageMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId image; + format::HandleId memory; + VkDeviceSize memoryOffset; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memory); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memoryOffset); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBindImageMemory* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBindImageMemory; + packet->call_info = call_info; + packet->device = device; + packet->image = image; + packet->memory = memory; + packet->memoryOffset = memoryOffset; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetBufferMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId buffer; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetBufferMemoryRequirements* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetBufferMemoryRequirements; + packet->call_info = call_info; + packet->device = device; + packet->buffer = buffer; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId image; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetImageMemoryRequirements* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageMemoryRequirements; + packet->call_info = call_info; + packet->device = device; + packet->image = image; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageSparseMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId image; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += pSparseMemoryRequirementCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSparseMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetImageSparseMemoryRequirements* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageSparseMemoryRequirements; + packet->call_info = call_info; + packet->device = device; + packet->image = image; + packet->pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + packet->pSparseMemoryRequirements = pSparseMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSparseImageFormatProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &format); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &type); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &samples); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &usage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &tiling); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceSparseImageFormatProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSparseImageFormatProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->format = format; + packet->type = type; + packet->samples = samples; + packet->usage = usage; + packet->tiling = tiling; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueBindSparse(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfo; + format::HandleId fence; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindInfoCount); + bytes_read += pBindInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fence); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkQueueBindSparse* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueBindSparse; + packet->call_info = call_info; + packet->queue = queue; + packet->bindInfoCount = bindInfoCount; + packet->pBindInfo = pBindInfo; + packet->fence = fence; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateFence(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pFence; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFence.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateFence* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateFence; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pFence = pFence; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyFence(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId fence; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fence); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyFence* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyFence; + packet->call_info = call_info; + packet->device = device; + packet->fence = fence; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkResetFences(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t fenceCount; + HandlePointerDecoder pFences; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fenceCount); + bytes_read += pFences.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkResetFences* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkResetFences; + packet->call_info = call_info; + packet->device = device; + packet->fenceCount = fenceCount; + packet->pFences = pFences; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetFenceStatus(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId fence; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fence); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetFenceStatus* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetFenceStatus; + packet->call_info = call_info; + packet->device = device; + packet->fence = fence; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkWaitForFences(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t fenceCount; + HandlePointerDecoder pFences; + VkBool32 waitAll; + uint64_t timeout; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fenceCount); + bytes_read += pFences.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &waitAll); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &timeout); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkWaitForFences* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkWaitForFences; + packet->call_info = call_info; + packet->device = device; + packet->fenceCount = fenceCount; + packet->pFences = pFences; + packet->waitAll = waitAll; + packet->timeout = timeout; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateSemaphore(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSemaphore; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSemaphore.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateSemaphore* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateSemaphore; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSemaphore = pSemaphore; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroySemaphore(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId semaphore; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &semaphore); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroySemaphore* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroySemaphore; + packet->call_info = call_info; + packet->device = device; + packet->semaphore = semaphore; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pEvent; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pEvent.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateEvent* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateEvent; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pEvent = pEvent; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId event; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyEvent* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyEvent; + packet->call_info = call_info; + packet->device = device; + packet->event = event; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetEventStatus(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId event; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetEventStatus* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetEventStatus; + packet->call_info = call_info; + packet->device = device; + packet->event = event; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId event; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkSetEvent* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetEvent; + packet->call_info = call_info; + packet->device = device; + packet->event = event; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkResetEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId event; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkResetEvent* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkResetEvent; + packet->call_info = call_info; + packet->device = device; + packet->event = event; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateQueryPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pQueryPool; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pQueryPool.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateQueryPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateQueryPool; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pQueryPool = pQueryPool; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyQueryPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId queryPool; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyQueryPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyQueryPool; + packet->call_info = call_info; + packet->device = device; + packet->queryPool = queryPool; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetQueryPoolResults(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; + size_t dataSize; + PointerDecoder pData; + VkDeviceSize stride; + VkQueryResultFlags flags; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstQuery); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryCount); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dataSize); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetQueryPoolResults* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetQueryPoolResults; + packet->call_info = call_info; + packet->device = device; + packet->queryPool = queryPool; + packet->firstQuery = firstQuery; + packet->queryCount = queryCount; + packet->dataSize = dataSize; + packet->pData = pData; + packet->stride = stride; + packet->flags = flags; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pBuffer; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pBuffer.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateBuffer; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pBuffer = pBuffer; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId buffer; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyBuffer; + packet->call_info = call_info; + packet->device = device; + packet->buffer = buffer; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateBufferView(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pView; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pView.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateBufferView* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateBufferView; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pView = pView; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyBufferView(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId bufferView; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bufferView); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyBufferView* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyBufferView; + packet->call_info = call_info; + packet->device = device; + packet->bufferView = bufferView; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pImage; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pImage.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateImage* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateImage; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pImage = pImage; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId image; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyImage* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyImage; + packet->call_info = call_info; + packet->device = device; + packet->image = image; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageSubresourceLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId image; + StructPointerDecoder pSubresource; + StructPointerDecoder pLayout; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += pSubresource.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pLayout.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetImageSubresourceLayout* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageSubresourceLayout; + packet->call_info = call_info; + packet->device = device; + packet->image = image; + packet->pSubresource = pSubresource; + packet->pLayout = pLayout; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateImageView(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pView; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pView.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateImageView* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateImageView; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pView = pView; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyImageView(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId imageView; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageView); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyImageView* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyImageView; + packet->call_info = call_info; + packet->device = device; + packet->imageView = imageView; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateShaderModule(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pShaderModule; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pShaderModule.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateShaderModule* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateShaderModule; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pShaderModule = pShaderModule; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyShaderModule(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId shaderModule; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &shaderModule); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyShaderModule* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyShaderModule; + packet->call_info = call_info; + packet->device = device; + packet->shaderModule = shaderModule; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreatePipelineCache(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelineCache; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPipelineCache.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreatePipelineCache* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreatePipelineCache; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pPipelineCache = pPipelineCache; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyPipelineCache(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipelineCache; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineCache); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyPipelineCache* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyPipelineCache; + packet->call_info = call_info; + packet->device = device; + packet->pipelineCache = pipelineCache; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPipelineCacheData(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipelineCache; + PointerDecoder pDataSize; + PointerDecoder pData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineCache); + bytes_read += pDataSize.PreloadDecodeSizeT((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPipelineCacheData* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPipelineCacheData; + packet->call_info = call_info; + packet->device = device; + packet->pipelineCache = pipelineCache; + packet->pDataSize = pDataSize; + packet->pData = pData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkMergePipelineCaches(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId dstCache; + uint32_t srcCacheCount; + HandlePointerDecoder pSrcCaches; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstCache); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcCacheCount); + bytes_read += pSrcCaches.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkMergePipelineCaches* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkMergePipelineCaches; + packet->call_info = call_info; + packet->device = device; + packet->dstCache = dstCache; + packet->srcCacheCount = srcCacheCount; + packet->pSrcCaches = pSrcCaches; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateGraphicsPipelines(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipelineCache; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineCache); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &createInfoCount); + bytes_read += pCreateInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPipelines.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateGraphicsPipelines* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateGraphicsPipelines; + packet->call_info = call_info; + packet->device = device; + packet->pipelineCache = pipelineCache; + packet->createInfoCount = createInfoCount; + packet->pCreateInfos = pCreateInfos; + packet->pAllocator = pAllocator; + packet->pPipelines = pPipelines; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateComputePipelines(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipelineCache; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineCache); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &createInfoCount); + bytes_read += pCreateInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPipelines.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateComputePipelines* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateComputePipelines; + packet->call_info = call_info; + packet->device = device; + packet->pipelineCache = pipelineCache; + packet->createInfoCount = createInfoCount; + packet->pCreateInfos = pCreateInfos; + packet->pAllocator = pAllocator; + packet->pPipelines = pPipelines; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyPipeline(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipeline; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyPipeline* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyPipeline; + packet->call_info = call_info; + packet->device = device; + packet->pipeline = pipeline; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreatePipelineLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelineLayout; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPipelineLayout.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreatePipelineLayout* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreatePipelineLayout; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pPipelineLayout = pPipelineLayout; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyPipelineLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipelineLayout; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineLayout); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyPipelineLayout* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyPipelineLayout; + packet->call_info = call_info; + packet->device = device; + packet->pipelineLayout = pipelineLayout; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateSampler(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSampler; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSampler.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateSampler* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateSampler; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSampler = pSampler; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroySampler(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId sampler; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &sampler); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroySampler* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroySampler; + packet->call_info = call_info; + packet->device = device; + packet->sampler = sampler; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDescriptorSetLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSetLayout; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSetLayout.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDescriptorSetLayout* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDescriptorSetLayout; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSetLayout = pSetLayout; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyDescriptorSetLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId descriptorSetLayout; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorSetLayout); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyDescriptorSetLayout* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyDescriptorSetLayout; + packet->call_info = call_info; + packet->device = device; + packet->descriptorSetLayout = descriptorSetLayout; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDescriptorPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDescriptorPool; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDescriptorPool.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDescriptorPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDescriptorPool; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pDescriptorPool = pDescriptorPool; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyDescriptorPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId descriptorPool; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorPool); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyDescriptorPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyDescriptorPool; + packet->call_info = call_info; + packet->device = device; + packet->descriptorPool = descriptorPool; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkResetDescriptorPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId descriptorPool; + VkDescriptorPoolResetFlags flags; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorPool); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkResetDescriptorPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkResetDescriptorPool; + packet->call_info = call_info; + packet->device = device; + packet->descriptorPool = descriptorPool; + packet->flags = flags; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAllocateDescriptorSets(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pAllocateInfo; + HandlePointerDecoder pDescriptorSets; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pAllocateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDescriptorSets.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAllocateDescriptorSets* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAllocateDescriptorSets; + packet->call_info = call_info; + packet->device = device; + packet->pAllocateInfo = pAllocateInfo; + packet->pDescriptorSets = pDescriptorSets; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkFreeDescriptorSets(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId descriptorPool; + uint32_t descriptorSetCount; + HandlePointerDecoder pDescriptorSets; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorSetCount); + bytes_read += pDescriptorSets.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkFreeDescriptorSets* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkFreeDescriptorSets; + packet->call_info = call_info; + packet->device = device; + packet->descriptorPool = descriptorPool; + packet->descriptorSetCount = descriptorSetCount; + packet->pDescriptorSets = pDescriptorSets; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkUpdateDescriptorSets(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t descriptorWriteCount; + StructPointerDecoder pDescriptorWrites; + uint32_t descriptorCopyCount; + StructPointerDecoder pDescriptorCopies; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorWriteCount); + bytes_read += pDescriptorWrites.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorCopyCount); + bytes_read += pDescriptorCopies.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkUpdateDescriptorSets* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkUpdateDescriptorSets; + packet->call_info = call_info; + packet->device = device; + packet->descriptorWriteCount = descriptorWriteCount; + packet->pDescriptorWrites = pDescriptorWrites; + packet->descriptorCopyCount = descriptorCopyCount; + packet->pDescriptorCopies = pDescriptorCopies; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateFramebuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pFramebuffer; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFramebuffer.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateFramebuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateFramebuffer; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pFramebuffer = pFramebuffer; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyFramebuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId framebuffer; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &framebuffer); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyFramebuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyFramebuffer; + packet->call_info = call_info; + packet->device = device; + packet->framebuffer = framebuffer; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateRenderPass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pRenderPass; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pRenderPass.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateRenderPass* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateRenderPass; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pRenderPass = pRenderPass; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyRenderPass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId renderPass; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &renderPass); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyRenderPass* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyRenderPass; + packet->call_info = call_info; + packet->device = device; + packet->renderPass = renderPass; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetRenderAreaGranularity(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId renderPass; + StructPointerDecoder pGranularity; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &renderPass); + bytes_read += pGranularity.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetRenderAreaGranularity* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetRenderAreaGranularity; + packet->call_info = call_info; + packet->device = device; + packet->renderPass = renderPass; + packet->pGranularity = pGranularity; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateCommandPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pCommandPool; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCommandPool.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateCommandPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateCommandPool; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pCommandPool = pCommandPool; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyCommandPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId commandPool; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandPool); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyCommandPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyCommandPool; + packet->call_info = call_info; + packet->device = device; + packet->commandPool = commandPool; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkResetCommandPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId commandPool; + VkCommandPoolResetFlags flags; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandPool); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkResetCommandPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkResetCommandPool; + packet->call_info = call_info; + packet->device = device; + packet->commandPool = commandPool; + packet->flags = flags; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAllocateCommandBuffers(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pAllocateInfo; + HandlePointerDecoder pCommandBuffers; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pAllocateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCommandBuffers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAllocateCommandBuffers* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAllocateCommandBuffers; + packet->call_info = call_info; + packet->device = device; + packet->pAllocateInfo = pAllocateInfo; + packet->pCommandBuffers = pCommandBuffers; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkFreeCommandBuffers(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId commandPool; + uint32_t commandBufferCount; + HandlePointerDecoder pCommandBuffers; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBufferCount); + bytes_read += pCommandBuffers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkFreeCommandBuffers* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkFreeCommandBuffers; + packet->call_info = call_info; + packet->device = device; + packet->commandPool = commandPool; + packet->commandBufferCount = commandBufferCount; + packet->pCommandBuffers = pCommandBuffers; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBeginCommandBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pBeginInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pBeginInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBeginCommandBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBeginCommandBuffer; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pBeginInfo = pBeginInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkEndCommandBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkEndCommandBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkEndCommandBuffer; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkResetCommandBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkCommandBufferResetFlags flags; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkResetCommandBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkResetCommandBuffer; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->flags = flags; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindPipeline(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId pipeline; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineBindPoint); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + + Packet_vkCmdBindPipeline* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindPipeline; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pipelineBindPoint = pipelineBindPoint; + packet->pipeline = pipeline; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetViewport(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstViewport; + uint32_t viewportCount; + StructPointerDecoder pViewports; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstViewport); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &viewportCount); + bytes_read += pViewports.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetViewport* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetViewport; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstViewport = firstViewport; + packet->viewportCount = viewportCount; + packet->pViewports = pViewports; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetScissor(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstScissor; + uint32_t scissorCount; + StructPointerDecoder pScissors; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstScissor); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &scissorCount); + bytes_read += pScissors.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetScissor* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetScissor; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstScissor = firstScissor; + packet->scissorCount = scissorCount; + packet->pScissors = pScissors; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetLineWidth(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + float lineWidth; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFloatValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &lineWidth); + + Packet_vkCmdSetLineWidth* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetLineWidth; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->lineWidth = lineWidth; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthBias(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFloatValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthBiasConstantFactor); + bytes_read += ValueDecoder::DecodeFloatValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthBiasClamp); + bytes_read += ValueDecoder::DecodeFloatValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthBiasSlopeFactor); + + Packet_vkCmdSetDepthBias* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthBias; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthBiasConstantFactor = depthBiasConstantFactor; + packet->depthBiasClamp = depthBiasClamp; + packet->depthBiasSlopeFactor = depthBiasSlopeFactor; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetBlendConstants(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + PointerDecoder blendConstants; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += blendConstants.PreloadDecodeFloat((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetBlendConstants* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetBlendConstants; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->blendConstants = blendConstants; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthBounds(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + float minDepthBounds; + float maxDepthBounds; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFloatValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &minDepthBounds); + bytes_read += ValueDecoder::DecodeFloatValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &maxDepthBounds); + + Packet_vkCmdSetDepthBounds* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthBounds; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->minDepthBounds = minDepthBounds; + packet->maxDepthBounds = maxDepthBounds; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetStencilCompareMask(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + uint32_t compareMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &faceMask); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &compareMask); + + Packet_vkCmdSetStencilCompareMask* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetStencilCompareMask; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->faceMask = faceMask; + packet->compareMask = compareMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetStencilWriteMask(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + uint32_t writeMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &faceMask); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &writeMask); + + Packet_vkCmdSetStencilWriteMask* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetStencilWriteMask; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->faceMask = faceMask; + packet->writeMask = writeMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetStencilReference(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + uint32_t reference; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &faceMask); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &reference); + + Packet_vkCmdSetStencilReference* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetStencilReference; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->faceMask = faceMask; + packet->reference = reference; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindDescriptorSets(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + HandlePointerDecoder pDescriptorSets; + uint32_t dynamicOffsetCount; + PointerDecoder pDynamicOffsets; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineBindPoint); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &layout); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstSet); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorSetCount); + bytes_read += pDescriptorSets.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dynamicOffsetCount); + bytes_read += pDynamicOffsets.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBindDescriptorSets* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindDescriptorSets; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pipelineBindPoint = pipelineBindPoint; + packet->layout = layout; + packet->firstSet = firstSet; + packet->descriptorSetCount = descriptorSetCount; + packet->pDescriptorSets = pDescriptorSets; + packet->dynamicOffsetCount = dynamicOffsetCount; + packet->pDynamicOffsets = pDynamicOffsets; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindIndexBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + VkIndexType indexType; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indexType); + + Packet_vkCmdBindIndexBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindIndexBuffer; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->indexType = indexType; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindVertexBuffers(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstBinding; + uint32_t bindingCount; + HandlePointerDecoder pBuffers; + PointerDecoder pOffsets; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstBinding); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindingCount); + bytes_read += pBuffers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pOffsets.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBindVertexBuffers* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindVertexBuffers; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstBinding = firstBinding; + packet->bindingCount = bindingCount; + packet->pBuffers = pBuffers; + packet->pOffsets = pOffsets; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDraw(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &vertexCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instanceCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstVertex); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstInstance); + + Packet_vkCmdDraw* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDraw; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->vertexCount = vertexCount; + packet->instanceCount = instanceCount; + packet->firstVertex = firstVertex; + packet->firstInstance = firstInstance; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndexed(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indexCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instanceCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstIndex); + bytes_read += ValueDecoder::DecodeInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &vertexOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstInstance); + + Packet_vkCmdDrawIndexed* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndexed; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->indexCount = indexCount; + packet->instanceCount = instanceCount; + packet->firstIndex = firstIndex; + packet->vertexOffset = vertexOffset; + packet->firstInstance = firstInstance; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndirect(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + uint32_t drawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &drawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawIndirect* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndirect; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->drawCount = drawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndexedIndirect(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + uint32_t drawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &drawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawIndexedIndirect* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndexedIndirect; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->drawCount = drawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDispatch(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountX); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountY); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountZ); + + Packet_vkCmdDispatch* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDispatch; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->groupCountX = groupCountX; + packet->groupCountY = groupCountY; + packet->groupCountZ = groupCountZ; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDispatchIndirect(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + + Packet_vkCmdDispatchIndirect* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDispatchIndirect; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId srcBuffer; + format::HandleId dstBuffer; + uint32_t regionCount; + StructPointerDecoder pRegions; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), ®ionCount); + bytes_read += pRegions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyBuffer; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->srcBuffer = srcBuffer; + packet->dstBuffer = dstBuffer; + packet->regionCount = regionCount; + packet->pRegions = pRegions; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId srcImage; + VkImageLayout srcImageLayout; + format::HandleId dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + StructPointerDecoder pRegions; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcImage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcImageLayout); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstImage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstImageLayout); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), ®ionCount); + bytes_read += pRegions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyImage* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyImage; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->srcImage = srcImage; + packet->srcImageLayout = srcImageLayout; + packet->dstImage = dstImage; + packet->dstImageLayout = dstImageLayout; + packet->regionCount = regionCount; + packet->pRegions = pRegions; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBlitImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId srcImage; + VkImageLayout srcImageLayout; + format::HandleId dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + StructPointerDecoder pRegions; + VkFilter filter; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcImage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcImageLayout); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstImage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstImageLayout); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), ®ionCount); + bytes_read += pRegions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &filter); + + Packet_vkCmdBlitImage* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBlitImage; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->srcImage = srcImage; + packet->srcImageLayout = srcImageLayout; + packet->dstImage = dstImage; + packet->dstImageLayout = dstImageLayout; + packet->regionCount = regionCount; + packet->pRegions = pRegions; + packet->filter = filter; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyBufferToImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId srcBuffer; + format::HandleId dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + StructPointerDecoder pRegions; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstImage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstImageLayout); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), ®ionCount); + bytes_read += pRegions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyBufferToImage* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyBufferToImage; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->srcBuffer = srcBuffer; + packet->dstImage = dstImage; + packet->dstImageLayout = dstImageLayout; + packet->regionCount = regionCount; + packet->pRegions = pRegions; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyImageToBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId srcImage; + VkImageLayout srcImageLayout; + format::HandleId dstBuffer; + uint32_t regionCount; + StructPointerDecoder pRegions; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcImage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcImageLayout); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), ®ionCount); + bytes_read += pRegions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyImageToBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyImageToBuffer; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->srcImage = srcImage; + packet->srcImageLayout = srcImageLayout; + packet->dstBuffer = dstBuffer; + packet->regionCount = regionCount; + packet->pRegions = pRegions; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdUpdateBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + VkDeviceSize dataSize; + PointerDecoder pData; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstOffset); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dataSize); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdUpdateBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdUpdateBuffer; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->dstBuffer = dstBuffer; + packet->dstOffset = dstOffset; + packet->dataSize = dataSize; + packet->pData = pData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdFillBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + VkDeviceSize size; + uint32_t data; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstOffset); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &size); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &data); + + Packet_vkCmdFillBuffer* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdFillBuffer; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->dstBuffer = dstBuffer; + packet->dstOffset = dstOffset; + packet->size = size; + packet->data = data; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdClearColorImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId image; + VkImageLayout imageLayout; + StructPointerDecoder pColor; + uint32_t rangeCount; + StructPointerDecoder pRanges; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageLayout); + bytes_read += pColor.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &rangeCount); + bytes_read += pRanges.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdClearColorImage* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdClearColorImage; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->image = image; + packet->imageLayout = imageLayout; + packet->pColor = pColor; + packet->rangeCount = rangeCount; + packet->pRanges = pRanges; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdClearDepthStencilImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId image; + VkImageLayout imageLayout; + StructPointerDecoder pDepthStencil; + uint32_t rangeCount; + StructPointerDecoder pRanges; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageLayout); + bytes_read += pDepthStencil.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &rangeCount); + bytes_read += pRanges.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdClearDepthStencilImage* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdClearDepthStencilImage; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->image = image; + packet->imageLayout = imageLayout; + packet->pDepthStencil = pDepthStencil; + packet->rangeCount = rangeCount; + packet->pRanges = pRanges; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdClearAttachments(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t attachmentCount; + StructPointerDecoder pAttachments; + uint32_t rectCount; + StructPointerDecoder pRects; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &attachmentCount); + bytes_read += pAttachments.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &rectCount); + bytes_read += pRects.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdClearAttachments* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdClearAttachments; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->attachmentCount = attachmentCount; + packet->pAttachments = pAttachments; + packet->rectCount = rectCount; + packet->pRects = pRects; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdResolveImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId srcImage; + VkImageLayout srcImageLayout; + format::HandleId dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + StructPointerDecoder pRegions; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcImage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcImageLayout); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstImage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstImageLayout); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), ®ionCount); + bytes_read += pRegions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdResolveImage* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdResolveImage; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->srcImage = srcImage; + packet->srcImageLayout = srcImageLayout; + packet->dstImage = dstImage; + packet->dstImageLayout = dstImageLayout; + packet->regionCount = regionCount; + packet->pRegions = pRegions; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId event; + VkPipelineStageFlags stageMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stageMask); + + Packet_vkCmdSetEvent* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetEvent; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->event = event; + packet->stageMask = stageMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdResetEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId event; + VkPipelineStageFlags stageMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stageMask); + + Packet_vkCmdResetEvent* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdResetEvent; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->event = event; + packet->stageMask = stageMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWaitEvents(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t eventCount; + HandlePointerDecoder pEvents; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + uint32_t memoryBarrierCount; + StructPointerDecoder pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + StructPointerDecoder pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + StructPointerDecoder pImageMemoryBarriers; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &eventCount); + bytes_read += pEvents.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcStageMask); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstStageMask); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memoryBarrierCount); + bytes_read += pMemoryBarriers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bufferMemoryBarrierCount); + bytes_read += pBufferMemoryBarriers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageMemoryBarrierCount); + bytes_read += pImageMemoryBarriers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdWaitEvents* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWaitEvents; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->eventCount = eventCount; + packet->pEvents = pEvents; + packet->srcStageMask = srcStageMask; + packet->dstStageMask = dstStageMask; + packet->memoryBarrierCount = memoryBarrierCount; + packet->pMemoryBarriers = pMemoryBarriers; + packet->bufferMemoryBarrierCount = bufferMemoryBarrierCount; + packet->pBufferMemoryBarriers = pBufferMemoryBarriers; + packet->imageMemoryBarrierCount = imageMemoryBarrierCount; + packet->pImageMemoryBarriers = pImageMemoryBarriers; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdPipelineBarrier(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkDependencyFlags dependencyFlags; + uint32_t memoryBarrierCount; + StructPointerDecoder pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + StructPointerDecoder pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + StructPointerDecoder pImageMemoryBarriers; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcStageMask); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstStageMask); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dependencyFlags); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memoryBarrierCount); + bytes_read += pMemoryBarriers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bufferMemoryBarrierCount); + bytes_read += pBufferMemoryBarriers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageMemoryBarrierCount); + bytes_read += pImageMemoryBarriers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPipelineBarrier* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPipelineBarrier; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->srcStageMask = srcStageMask; + packet->dstStageMask = dstStageMask; + packet->dependencyFlags = dependencyFlags; + packet->memoryBarrierCount = memoryBarrierCount; + packet->pMemoryBarriers = pMemoryBarriers; + packet->bufferMemoryBarrierCount = bufferMemoryBarrierCount; + packet->pBufferMemoryBarriers = pBufferMemoryBarriers; + packet->imageMemoryBarrierCount = imageMemoryBarrierCount; + packet->pImageMemoryBarriers = pImageMemoryBarriers; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginQuery(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t query; + VkQueryControlFlags flags; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &query); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + + Packet_vkCmdBeginQuery* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginQuery; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->queryPool = queryPool; + packet->query = query; + packet->flags = flags; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndQuery(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t query; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &query); + + Packet_vkCmdEndQuery* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndQuery; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->queryPool = queryPool; + packet->query = query; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdResetQueryPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstQuery); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryCount); + + Packet_vkCmdResetQueryPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdResetQueryPool; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->queryPool = queryPool; + packet->firstQuery = firstQuery; + packet->queryCount = queryCount; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWriteTimestamp(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineStageFlagBits pipelineStage; + format::HandleId queryPool; + uint32_t query; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineStage); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &query); + + Packet_vkCmdWriteTimestamp* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWriteTimestamp; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pipelineStage = pipelineStage; + packet->queryPool = queryPool; + packet->query = query; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyQueryPoolResults(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + VkDeviceSize stride; + VkQueryResultFlags flags; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstQuery); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryCount); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstOffset); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + + Packet_vkCmdCopyQueryPoolResults* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyQueryPoolResults; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->queryPool = queryPool; + packet->firstQuery = firstQuery; + packet->queryCount = queryCount; + packet->dstBuffer = dstBuffer; + packet->dstOffset = dstOffset; + packet->stride = stride; + packet->flags = flags; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdPushConstants(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + PointerDecoder pValues; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &layout); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stageFlags); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &size); + bytes_read += pValues.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPushConstants* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPushConstants; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->layout = layout; + packet->stageFlags = stageFlags; + packet->offset = offset; + packet->size = size; + packet->pValues = pValues; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginRenderPass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pRenderPassBegin; + VkSubpassContents contents; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pRenderPassBegin.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &contents); + + Packet_vkCmdBeginRenderPass* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginRenderPass; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pRenderPassBegin = pRenderPassBegin; + packet->contents = contents; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdNextSubpass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkSubpassContents contents; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &contents); + + Packet_vkCmdNextSubpass* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdNextSubpass; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->contents = contents; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndRenderPass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + + Packet_vkCmdEndRenderPass* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndRenderPass; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdExecuteCommands(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t commandBufferCount; + HandlePointerDecoder pCommandBuffers; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBufferCount); + bytes_read += pCommandBuffers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdExecuteCommands* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdExecuteCommands; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->commandBufferCount = commandBufferCount; + packet->pCommandBuffers = pCommandBuffers; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBindBufferMemory2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindInfoCount); + bytes_read += pBindInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBindBufferMemory2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBindBufferMemory2; + packet->call_info = call_info; + packet->device = device; + packet->bindInfoCount = bindInfoCount; + packet->pBindInfos = pBindInfos; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBindImageMemory2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindInfoCount); + bytes_read += pBindInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBindImageMemory2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBindImageMemory2; + packet->call_info = call_info; + packet->device = device; + packet->bindInfoCount = bindInfoCount; + packet->pBindInfos = pBindInfos; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceGroupPeerMemoryFeatures(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t heapIndex; + uint32_t localDeviceIndex; + uint32_t remoteDeviceIndex; + PointerDecoder pPeerMemoryFeatures; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &heapIndex); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &localDeviceIndex); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &remoteDeviceIndex); + bytes_read += pPeerMemoryFeatures.PreloadDecodeFlags((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceGroupPeerMemoryFeatures* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceGroupPeerMemoryFeatures; + packet->call_info = call_info; + packet->device = device; + packet->heapIndex = heapIndex; + packet->localDeviceIndex = localDeviceIndex; + packet->remoteDeviceIndex = remoteDeviceIndex; + packet->pPeerMemoryFeatures = pPeerMemoryFeatures; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDeviceMask(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t deviceMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &deviceMask); + + Packet_vkCmdSetDeviceMask* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDeviceMask; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->deviceMask = deviceMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDispatchBase(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t baseGroupX; + uint32_t baseGroupY; + uint32_t baseGroupZ; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &baseGroupX); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &baseGroupY); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &baseGroupZ); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountX); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountY); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountZ); + + Packet_vkCmdDispatchBase* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDispatchBase; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->baseGroupX = baseGroupX; + packet->baseGroupY = baseGroupY; + packet->baseGroupZ = baseGroupZ; + packet->groupCountX = groupCountX; + packet->groupCountY = groupCountY; + packet->groupCountZ = groupCountZ; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkEnumeratePhysicalDeviceGroups(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + PointerDecoder pPhysicalDeviceGroupCount; + StructPointerDecoder pPhysicalDeviceGroupProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pPhysicalDeviceGroupCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPhysicalDeviceGroupProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkEnumeratePhysicalDeviceGroups* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkEnumeratePhysicalDeviceGroups; + packet->call_info = call_info; + packet->instance = instance; + packet->pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount; + packet->pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageMemoryRequirements2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetImageMemoryRequirements2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageMemoryRequirements2; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetBufferMemoryRequirements2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetBufferMemoryRequirements2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetBufferMemoryRequirements2; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageSparseMemoryRequirements2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSparseMemoryRequirementCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSparseMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetImageSparseMemoryRequirements2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageSparseMemoryRequirements2; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + packet->pSparseMemoryRequirements = pSparseMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceFeatures2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pFeatures; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pFeatures.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceFeatures2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceFeatures2; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pFeatures = pFeatures; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceProperties2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceProperties2; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pProperties = pProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceFormatProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + VkFormat format; + StructPointerDecoder pFormatProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &format); + bytes_read += pFormatProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceFormatProperties2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceFormatProperties2; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->format = format; + packet->pFormatProperties = pFormatProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceImageFormatProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pImageFormatInfo; + StructPointerDecoder pImageFormatProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pImageFormatInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pImageFormatProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceImageFormatProperties2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceImageFormatProperties2; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pImageFormatInfo = pImageFormatInfo; + packet->pImageFormatProperties = pImageFormatProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceQueueFamilyProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pQueueFamilyPropertyCount; + StructPointerDecoder pQueueFamilyProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pQueueFamilyPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pQueueFamilyProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceQueueFamilyProperties2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceQueueFamilyProperties2; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pQueueFamilyPropertyCount = pQueueFamilyPropertyCount; + packet->pQueueFamilyProperties = pQueueFamilyProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceMemoryProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pMemoryProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pMemoryProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceMemoryProperties2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceMemoryProperties2; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pMemoryProperties = pMemoryProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSparseImageFormatProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pFormatInfo; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pFormatInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceSparseImageFormatProperties2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSparseImageFormatProperties2; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pFormatInfo = pFormatInfo; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkTrimCommandPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId commandPool; + VkCommandPoolTrimFlags flags; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandPool); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + + Packet_vkTrimCommandPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkTrimCommandPool; + packet->call_info = call_info; + packet->device = device; + packet->commandPool = commandPool; + packet->flags = flags; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceQueue2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pQueueInfo; + HandlePointerDecoder pQueue; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pQueueInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pQueue.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceQueue2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceQueue2; + packet->call_info = call_info; + packet->device = device; + packet->pQueueInfo = pQueueInfo; + packet->pQueue = pQueue; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateSamplerYcbcrConversion(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pYcbcrConversion; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pYcbcrConversion.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateSamplerYcbcrConversion* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateSamplerYcbcrConversion; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pYcbcrConversion = pYcbcrConversion; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroySamplerYcbcrConversion(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId ycbcrConversion; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &ycbcrConversion); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroySamplerYcbcrConversion* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroySamplerYcbcrConversion; + packet->call_info = call_info; + packet->device = device; + packet->ycbcrConversion = ycbcrConversion; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDescriptorUpdateTemplate(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDescriptorUpdateTemplate; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDescriptorUpdateTemplate.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDescriptorUpdateTemplate* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDescriptorUpdateTemplate; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pDescriptorUpdateTemplate = pDescriptorUpdateTemplate; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyDescriptorUpdateTemplate(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId descriptorUpdateTemplate; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorUpdateTemplate); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyDescriptorUpdateTemplate* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyDescriptorUpdateTemplate; + packet->call_info = call_info; + packet->device = device; + packet->descriptorUpdateTemplate = descriptorUpdateTemplate; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceExternalBufferProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pExternalBufferInfo; + StructPointerDecoder pExternalBufferProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pExternalBufferInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pExternalBufferProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceExternalBufferProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceExternalBufferProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pExternalBufferInfo = pExternalBufferInfo; + packet->pExternalBufferProperties = pExternalBufferProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceExternalFenceProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pExternalFenceInfo; + StructPointerDecoder pExternalFenceProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pExternalFenceInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pExternalFenceProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceExternalFenceProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceExternalFenceProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pExternalFenceInfo = pExternalFenceInfo; + packet->pExternalFenceProperties = pExternalFenceProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceExternalSemaphoreProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pExternalSemaphoreInfo; + StructPointerDecoder pExternalSemaphoreProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pExternalSemaphoreInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pExternalSemaphoreProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceExternalSemaphoreProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceExternalSemaphoreProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pExternalSemaphoreInfo = pExternalSemaphoreInfo; + packet->pExternalSemaphoreProperties = pExternalSemaphoreProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDescriptorSetLayoutSupport(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pSupport; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSupport.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDescriptorSetLayoutSupport* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDescriptorSetLayoutSupport; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pSupport = pSupport; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndirectCount(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBufferOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &maxDrawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawIndirectCount* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndirectCount; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->countBuffer = countBuffer; + packet->countBufferOffset = countBufferOffset; + packet->maxDrawCount = maxDrawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndexedIndirectCount(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBufferOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &maxDrawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawIndexedIndirectCount* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndexedIndirectCount; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->countBuffer = countBuffer; + packet->countBufferOffset = countBufferOffset; + packet->maxDrawCount = maxDrawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateRenderPass2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pRenderPass; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pRenderPass.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateRenderPass2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateRenderPass2; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pRenderPass = pRenderPass; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginRenderPass2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pRenderPassBegin; + StructPointerDecoder pSubpassBeginInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pRenderPassBegin.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSubpassBeginInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBeginRenderPass2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginRenderPass2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pRenderPassBegin = pRenderPassBegin; + packet->pSubpassBeginInfo = pSubpassBeginInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdNextSubpass2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pSubpassBeginInfo; + StructPointerDecoder pSubpassEndInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pSubpassBeginInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSubpassEndInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdNextSubpass2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdNextSubpass2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pSubpassBeginInfo = pSubpassBeginInfo; + packet->pSubpassEndInfo = pSubpassEndInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndRenderPass2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pSubpassEndInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pSubpassEndInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdEndRenderPass2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndRenderPass2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pSubpassEndInfo = pSubpassEndInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkResetQueryPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstQuery); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryCount); + + Packet_vkResetQueryPool* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkResetQueryPool; + packet->call_info = call_info; + packet->device = device; + packet->queryPool = queryPool; + packet->firstQuery = firstQuery; + packet->queryCount = queryCount; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetSemaphoreCounterValue(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId semaphore; + PointerDecoder pValue; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &semaphore); + bytes_read += pValue.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetSemaphoreCounterValue* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetSemaphoreCounterValue; + packet->call_info = call_info; + packet->device = device; + packet->semaphore = semaphore; + packet->pValue = pValue; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkWaitSemaphores(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pWaitInfo; + uint64_t timeout; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pWaitInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &timeout); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkWaitSemaphores* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkWaitSemaphores; + packet->call_info = call_info; + packet->device = device; + packet->pWaitInfo = pWaitInfo; + packet->timeout = timeout; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSignalSemaphore(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pSignalInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pSignalInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkSignalSemaphore* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSignalSemaphore; + packet->call_info = call_info; + packet->device = device; + packet->pSignalInfo = pSignalInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetBufferDeviceAddress(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + VkDeviceAddress return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetBufferDeviceAddress* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetBufferDeviceAddress; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetBufferOpaqueCaptureAddress(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + uint64_t return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetBufferOpaqueCaptureAddress* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetBufferOpaqueCaptureAddress; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceMemoryOpaqueCaptureAddress(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + uint64_t return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDeviceMemoryOpaqueCaptureAddress* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceMemoryOpaqueCaptureAddress; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceToolProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pToolCount; + StructPointerDecoder pToolProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pToolCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pToolProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceToolProperties* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceToolProperties; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pToolCount = pToolCount; + packet->pToolProperties = pToolProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreatePrivateDataSlot(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPrivateDataSlot; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPrivateDataSlot.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreatePrivateDataSlot* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreatePrivateDataSlot; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pPrivateDataSlot = pPrivateDataSlot; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyPrivateDataSlot(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId privateDataSlot; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &privateDataSlot); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyPrivateDataSlot* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyPrivateDataSlot; + packet->call_info = call_info; + packet->device = device; + packet->privateDataSlot = privateDataSlot; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetPrivateData(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkObjectType objectType; + uint64_t objectHandle; + format::HandleId privateDataSlot; + uint64_t data; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &objectType); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &objectHandle); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &privateDataSlot); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &data); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkSetPrivateData* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetPrivateData; + packet->call_info = call_info; + packet->device = device; + packet->objectType = objectType; + packet->objectHandle = objectHandle; + packet->privateDataSlot = privateDataSlot; + packet->data = data; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPrivateData(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkObjectType objectType; + uint64_t objectHandle; + format::HandleId privateDataSlot; + PointerDecoder pData; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &objectType); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &objectHandle); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &privateDataSlot); + bytes_read += pData.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPrivateData* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPrivateData; + packet->call_info = call_info; + packet->device = device; + packet->objectType = objectType; + packet->objectHandle = objectHandle; + packet->privateDataSlot = privateDataSlot; + packet->pData = pData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetEvent2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId event; + StructPointerDecoder pDependencyInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += pDependencyInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetEvent2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetEvent2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->event = event; + packet->pDependencyInfo = pDependencyInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdResetEvent2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId event; + VkPipelineStageFlags2 stageMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += ValueDecoder::DecodeFlags64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stageMask); + + Packet_vkCmdResetEvent2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdResetEvent2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->event = event; + packet->stageMask = stageMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWaitEvents2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t eventCount; + HandlePointerDecoder pEvents; + StructPointerDecoder pDependencyInfos; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &eventCount); + bytes_read += pEvents.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDependencyInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdWaitEvents2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWaitEvents2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->eventCount = eventCount; + packet->pEvents = pEvents; + packet->pDependencyInfos = pDependencyInfos; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdPipelineBarrier2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pDependencyInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pDependencyInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPipelineBarrier2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPipelineBarrier2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pDependencyInfo = pDependencyInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWriteTimestamp2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineStageFlags2 stage; + format::HandleId queryPool; + uint32_t query; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlags64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stage); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &query); + + Packet_vkCmdWriteTimestamp2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWriteTimestamp2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->stage = stage; + packet->queryPool = queryPool; + packet->query = query; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueSubmit2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + uint32_t submitCount; + StructPointerDecoder pSubmits; + format::HandleId fence; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &submitCount); + bytes_read += pSubmits.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fence); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkQueueSubmit2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueSubmit2; + packet->call_info = call_info; + packet->queue = queue; + packet->submitCount = submitCount; + packet->pSubmits = pSubmits; + packet->fence = fence; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyBuffer2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pCopyBufferInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pCopyBufferInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyBuffer2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyBuffer2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCopyBufferInfo = pCopyBufferInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyImage2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pCopyImageInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pCopyImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyImage2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyImage2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCopyImageInfo = pCopyImageInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyBufferToImage2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pCopyBufferToImageInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pCopyBufferToImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyBufferToImage2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyBufferToImage2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCopyBufferToImageInfo = pCopyBufferToImageInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyImageToBuffer2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pCopyImageToBufferInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pCopyImageToBufferInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyImageToBuffer2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyImageToBuffer2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCopyImageToBufferInfo = pCopyImageToBufferInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBlitImage2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pBlitImageInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pBlitImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBlitImage2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBlitImage2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pBlitImageInfo = pBlitImageInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdResolveImage2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pResolveImageInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pResolveImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdResolveImage2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdResolveImage2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pResolveImageInfo = pResolveImageInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginRendering(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pRenderingInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pRenderingInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBeginRendering* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginRendering; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pRenderingInfo = pRenderingInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndRendering(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + + Packet_vkCmdEndRendering* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndRendering; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCullMode(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkCullModeFlags cullMode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &cullMode); + + Packet_vkCmdSetCullMode* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCullMode; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->cullMode = cullMode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetFrontFace(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkFrontFace frontFace; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &frontFace); + + Packet_vkCmdSetFrontFace* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetFrontFace; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->frontFace = frontFace; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetPrimitiveTopology(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPrimitiveTopology primitiveTopology; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &primitiveTopology); + + Packet_vkCmdSetPrimitiveTopology* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetPrimitiveTopology; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->primitiveTopology = primitiveTopology; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetViewportWithCount(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t viewportCount; + StructPointerDecoder pViewports; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &viewportCount); + bytes_read += pViewports.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetViewportWithCount* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetViewportWithCount; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->viewportCount = viewportCount; + packet->pViewports = pViewports; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetScissorWithCount(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t scissorCount; + StructPointerDecoder pScissors; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &scissorCount); + bytes_read += pScissors.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetScissorWithCount* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetScissorWithCount; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->scissorCount = scissorCount; + packet->pScissors = pScissors; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindVertexBuffers2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstBinding; + uint32_t bindingCount; + HandlePointerDecoder pBuffers; + PointerDecoder pOffsets; + PointerDecoder pSizes; + PointerDecoder pStrides; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstBinding); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindingCount); + bytes_read += pBuffers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pOffsets.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSizes.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pStrides.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBindVertexBuffers2* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindVertexBuffers2; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstBinding = firstBinding; + packet->bindingCount = bindingCount; + packet->pBuffers = pBuffers; + packet->pOffsets = pOffsets; + packet->pSizes = pSizes; + packet->pStrides = pStrides; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthTestEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthTestEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthTestEnable); + + Packet_vkCmdSetDepthTestEnable* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthTestEnable; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthTestEnable = depthTestEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthWriteEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthWriteEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthWriteEnable); + + Packet_vkCmdSetDepthWriteEnable* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthWriteEnable; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthWriteEnable = depthWriteEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthCompareOp(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkCompareOp depthCompareOp; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthCompareOp); + + Packet_vkCmdSetDepthCompareOp* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthCompareOp; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthCompareOp = depthCompareOp; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthBoundsTestEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthBoundsTestEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthBoundsTestEnable); + + Packet_vkCmdSetDepthBoundsTestEnable* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthBoundsTestEnable; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthBoundsTestEnable = depthBoundsTestEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetStencilTestEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 stencilTestEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stencilTestEnable); + + Packet_vkCmdSetStencilTestEnable* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetStencilTestEnable; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->stencilTestEnable = stencilTestEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetStencilOp(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &faceMask); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &failOp); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &passOp); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthFailOp); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &compareOp); + + Packet_vkCmdSetStencilOp* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetStencilOp; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->faceMask = faceMask; + packet->failOp = failOp; + packet->passOp = passOp; + packet->depthFailOp = depthFailOp; + packet->compareOp = compareOp; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetRasterizerDiscardEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 rasterizerDiscardEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &rasterizerDiscardEnable); + + Packet_vkCmdSetRasterizerDiscardEnable* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetRasterizerDiscardEnable; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->rasterizerDiscardEnable = rasterizerDiscardEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthBiasEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthBiasEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthBiasEnable); + + Packet_vkCmdSetDepthBiasEnable* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthBiasEnable; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthBiasEnable = depthBiasEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetPrimitiveRestartEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 primitiveRestartEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &primitiveRestartEnable); + + Packet_vkCmdSetPrimitiveRestartEnable* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetPrimitiveRestartEnable; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->primitiveRestartEnable = primitiveRestartEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceBufferMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceBufferMemoryRequirements* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceBufferMemoryRequirements; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceImageMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceImageMemoryRequirements* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceImageMemoryRequirements; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceImageSparseMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSparseMemoryRequirementCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSparseMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceImageSparseMemoryRequirements* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceImageSparseMemoryRequirements; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + packet->pSparseMemoryRequirements = pSparseMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroySurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + format::HandleId surface; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &surface); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroySurfaceKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroySurfaceKHR; + packet->call_info = call_info; + packet->instance = instance; + packet->surface = surface; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSurfaceSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + format::HandleId surface; + PointerDecoder pSupported; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueFamilyIndex); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &surface); + bytes_read += pSupported.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceSurfaceSupportKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSurfaceSupportKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->queueFamilyIndex = queueFamilyIndex; + packet->surface = surface; + packet->pSupported = pSupported; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId surface; + StructPointerDecoder pSurfaceCapabilities; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &surface); + bytes_read += pSurfaceCapabilities.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceSurfaceCapabilitiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSurfaceCapabilitiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->surface = surface; + packet->pSurfaceCapabilities = pSurfaceCapabilities; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSurfaceFormatsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId surface; + PointerDecoder pSurfaceFormatCount; + StructPointerDecoder pSurfaceFormats; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &surface); + bytes_read += pSurfaceFormatCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurfaceFormats.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceSurfaceFormatsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSurfaceFormatsKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->surface = surface; + packet->pSurfaceFormatCount = pSurfaceFormatCount; + packet->pSurfaceFormats = pSurfaceFormats; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSurfacePresentModesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId surface; + PointerDecoder pPresentModeCount; + PointerDecoder pPresentModes; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &surface); + bytes_read += pPresentModeCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPresentModes.PreloadDecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceSurfacePresentModesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSurfacePresentModesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->surface = surface; + packet->pPresentModeCount = pPresentModeCount; + packet->pPresentModes = pPresentModes; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateSwapchainKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSwapchain; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSwapchain.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateSwapchainKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateSwapchainKHR; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSwapchain = pSwapchain; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroySwapchainKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroySwapchainKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroySwapchainKHR; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetSwapchainImagesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + PointerDecoder pSwapchainImageCount; + HandlePointerDecoder pSwapchainImages; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += pSwapchainImageCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSwapchainImages.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetSwapchainImagesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetSwapchainImagesKHR; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->pSwapchainImageCount = pSwapchainImageCount; + packet->pSwapchainImages = pSwapchainImages; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAcquireNextImageKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + uint64_t timeout; + format::HandleId semaphore; + format::HandleId fence; + PointerDecoder pImageIndex; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &timeout); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &semaphore); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fence); + bytes_read += pImageIndex.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAcquireNextImageKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAcquireNextImageKHR; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->timeout = timeout; + packet->semaphore = semaphore; + packet->fence = fence; + packet->pImageIndex = pImageIndex; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueuePresentKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + StructPointerDecoder pPresentInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += pPresentInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkQueuePresentKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueuePresentKHR; + packet->call_info = call_info; + packet->queue = queue; + packet->pPresentInfo = pPresentInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceGroupPresentCapabilitiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pDeviceGroupPresentCapabilities; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pDeviceGroupPresentCapabilities.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDeviceGroupPresentCapabilitiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceGroupPresentCapabilitiesKHR; + packet->call_info = call_info; + packet->device = device; + packet->pDeviceGroupPresentCapabilities = pDeviceGroupPresentCapabilities; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceGroupSurfacePresentModesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId surface; + PointerDecoder pModes; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &surface); + bytes_read += pModes.PreloadDecodeFlags((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDeviceGroupSurfacePresentModesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceGroupSurfacePresentModesKHR; + packet->call_info = call_info; + packet->device = device; + packet->surface = surface; + packet->pModes = pModes; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDevicePresentRectanglesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId surface; + PointerDecoder pRectCount; + StructPointerDecoder pRects; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &surface); + bytes_read += pRectCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pRects.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDevicePresentRectanglesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDevicePresentRectanglesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->surface = surface; + packet->pRectCount = pRectCount; + packet->pRects = pRects; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAcquireNextImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pAcquireInfo; + PointerDecoder pImageIndex; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pAcquireInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pImageIndex.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAcquireNextImage2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAcquireNextImage2KHR; + packet->call_info = call_info; + packet->device = device; + packet->pAcquireInfo = pAcquireInfo; + packet->pImageIndex = pImageIndex; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceDisplayPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceDisplayPropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceDisplayPropertiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceDisplayPlanePropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceDisplayPlanePropertiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDisplayPlaneSupportedDisplaysKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t planeIndex; + PointerDecoder pDisplayCount; + HandlePointerDecoder pDisplays; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &planeIndex); + bytes_read += pDisplayCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDisplays.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDisplayPlaneSupportedDisplaysKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDisplayPlaneSupportedDisplaysKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->planeIndex = planeIndex; + packet->pDisplayCount = pDisplayCount; + packet->pDisplays = pDisplays; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDisplayModePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId display; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDisplayModePropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDisplayModePropertiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->display = display; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDisplayModeKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId display; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pMode; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMode.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDisplayModeKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDisplayModeKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->display = display; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pMode = pMode; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDisplayPlaneCapabilitiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId mode; + uint32_t planeIndex; + StructPointerDecoder pCapabilities; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &mode); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &planeIndex); + bytes_read += pCapabilities.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDisplayPlaneCapabilitiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDisplayPlaneCapabilitiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->mode = mode; + packet->planeIndex = planeIndex; + packet->pCapabilities = pCapabilities; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDisplayPlaneSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDisplayPlaneSurfaceKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDisplayPlaneSurfaceKHR; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateSharedSwapchainsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t swapchainCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSwapchains; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchainCount); + bytes_read += pCreateInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSwapchains.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateSharedSwapchainsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateSharedSwapchainsKHR; + packet->call_info = call_info; + packet->device = device; + packet->swapchainCount = swapchainCount; + packet->pCreateInfos = pCreateInfos; + packet->pAllocator = pAllocator; + packet->pSwapchains = pSwapchains; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateXlibSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateXlibSurfaceKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateXlibSurfaceKHR; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceXlibPresentationSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t dpy; + size_t visualID; + VkBool32 return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueFamilyIndex); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dpy); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &visualID); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceXlibPresentationSupportKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceXlibPresentationSupportKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->queueFamilyIndex = queueFamilyIndex; + packet->dpy = dpy; + packet->visualID = visualID; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateXcbSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateXcbSurfaceKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateXcbSurfaceKHR; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceXcbPresentationSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t connection; + uint32_t visual_id; + VkBool32 return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueFamilyIndex); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &connection); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &visual_id); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceXcbPresentationSupportKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceXcbPresentationSupportKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->queueFamilyIndex = queueFamilyIndex; + packet->connection = connection; + packet->visual_id = visual_id; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateWaylandSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateWaylandSurfaceKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateWaylandSurfaceKHR; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceWaylandPresentationSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t display; + VkBool32 return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueFamilyIndex); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceWaylandPresentationSupportKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceWaylandPresentationSupportKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->queueFamilyIndex = queueFamilyIndex; + packet->display = display; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateAndroidSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateAndroidSurfaceKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateAndroidSurfaceKHR; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateWin32SurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateWin32SurfaceKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateWin32SurfaceKHR; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceWin32PresentationSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + VkBool32 return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueFamilyIndex); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceWin32PresentationSupportKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceWin32PresentationSupportKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->queueFamilyIndex = queueFamilyIndex; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceVideoCapabilitiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pVideoProfile; + StructPointerDecoder pCapabilities; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pVideoProfile.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCapabilities.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceVideoCapabilitiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceVideoCapabilitiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pVideoProfile = pVideoProfile; + packet->pCapabilities = pCapabilities; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceVideoFormatPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pVideoFormatInfo; + PointerDecoder pVideoFormatPropertyCount; + StructPointerDecoder pVideoFormatProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pVideoFormatInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pVideoFormatPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pVideoFormatProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceVideoFormatPropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceVideoFormatPropertiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pVideoFormatInfo = pVideoFormatInfo; + packet->pVideoFormatPropertyCount = pVideoFormatPropertyCount; + packet->pVideoFormatProperties = pVideoFormatProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateVideoSessionKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pVideoSession; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pVideoSession.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateVideoSessionKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateVideoSessionKHR; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pVideoSession = pVideoSession; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyVideoSessionKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId videoSession; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &videoSession); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyVideoSessionKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyVideoSessionKHR; + packet->call_info = call_info; + packet->device = device; + packet->videoSession = videoSession; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetVideoSessionMemoryRequirementsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId videoSession; + PointerDecoder pMemoryRequirementsCount; + StructPointerDecoder pMemoryRequirements; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &videoSession); + bytes_read += pMemoryRequirementsCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetVideoSessionMemoryRequirementsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetVideoSessionMemoryRequirementsKHR; + packet->call_info = call_info; + packet->device = device; + packet->videoSession = videoSession; + packet->pMemoryRequirementsCount = pMemoryRequirementsCount; + packet->pMemoryRequirements = pMemoryRequirements; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBindVideoSessionMemoryKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId videoSession; + uint32_t bindSessionMemoryInfoCount; + StructPointerDecoder pBindSessionMemoryInfos; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &videoSession); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindSessionMemoryInfoCount); + bytes_read += pBindSessionMemoryInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBindVideoSessionMemoryKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBindVideoSessionMemoryKHR; + packet->call_info = call_info; + packet->device = device; + packet->videoSession = videoSession; + packet->bindSessionMemoryInfoCount = bindSessionMemoryInfoCount; + packet->pBindSessionMemoryInfos = pBindSessionMemoryInfos; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateVideoSessionParametersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pVideoSessionParameters; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pVideoSessionParameters.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateVideoSessionParametersKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateVideoSessionParametersKHR; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pVideoSessionParameters = pVideoSessionParameters; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkUpdateVideoSessionParametersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId videoSessionParameters; + StructPointerDecoder pUpdateInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &videoSessionParameters); + bytes_read += pUpdateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkUpdateVideoSessionParametersKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkUpdateVideoSessionParametersKHR; + packet->call_info = call_info; + packet->device = device; + packet->videoSessionParameters = videoSessionParameters; + packet->pUpdateInfo = pUpdateInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyVideoSessionParametersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId videoSessionParameters; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &videoSessionParameters); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyVideoSessionParametersKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyVideoSessionParametersKHR; + packet->call_info = call_info; + packet->device = device; + packet->videoSessionParameters = videoSessionParameters; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginVideoCodingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pBeginInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pBeginInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBeginVideoCodingKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginVideoCodingKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pBeginInfo = pBeginInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndVideoCodingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pEndCodingInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pEndCodingInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdEndVideoCodingKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndVideoCodingKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pEndCodingInfo = pEndCodingInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdControlVideoCodingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pCodingControlInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pCodingControlInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdControlVideoCodingKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdControlVideoCodingKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCodingControlInfo = pCodingControlInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDecodeVideoKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pDecodeInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pDecodeInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdDecodeVideoKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDecodeVideoKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pDecodeInfo = pDecodeInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginRenderingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pRenderingInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pRenderingInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBeginRenderingKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginRenderingKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pRenderingInfo = pRenderingInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndRenderingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + + Packet_vkCmdEndRenderingKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndRenderingKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceFeatures2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pFeatures; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pFeatures.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceFeatures2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceFeatures2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pFeatures = pFeatures; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceProperties2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceProperties2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pProperties = pProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceFormatProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + VkFormat format; + StructPointerDecoder pFormatProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &format); + bytes_read += pFormatProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceFormatProperties2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceFormatProperties2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->format = format; + packet->pFormatProperties = pFormatProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceImageFormatProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pImageFormatInfo; + StructPointerDecoder pImageFormatProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pImageFormatInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pImageFormatProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceImageFormatProperties2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceImageFormatProperties2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pImageFormatInfo = pImageFormatInfo; + packet->pImageFormatProperties = pImageFormatProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceQueueFamilyProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pQueueFamilyPropertyCount; + StructPointerDecoder pQueueFamilyProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pQueueFamilyPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pQueueFamilyProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceQueueFamilyProperties2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceQueueFamilyProperties2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pQueueFamilyPropertyCount = pQueueFamilyPropertyCount; + packet->pQueueFamilyProperties = pQueueFamilyProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceMemoryProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pMemoryProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pMemoryProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceMemoryProperties2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceMemoryProperties2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pMemoryProperties = pMemoryProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pFormatInfo; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pFormatInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceSparseImageFormatProperties2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSparseImageFormatProperties2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pFormatInfo = pFormatInfo; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceGroupPeerMemoryFeaturesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t heapIndex; + uint32_t localDeviceIndex; + uint32_t remoteDeviceIndex; + PointerDecoder pPeerMemoryFeatures; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &heapIndex); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &localDeviceIndex); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &remoteDeviceIndex); + bytes_read += pPeerMemoryFeatures.PreloadDecodeFlags((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceGroupPeerMemoryFeaturesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceGroupPeerMemoryFeaturesKHR; + packet->call_info = call_info; + packet->device = device; + packet->heapIndex = heapIndex; + packet->localDeviceIndex = localDeviceIndex; + packet->remoteDeviceIndex = remoteDeviceIndex; + packet->pPeerMemoryFeatures = pPeerMemoryFeatures; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDeviceMaskKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t deviceMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &deviceMask); + + Packet_vkCmdSetDeviceMaskKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDeviceMaskKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->deviceMask = deviceMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDispatchBaseKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t baseGroupX; + uint32_t baseGroupY; + uint32_t baseGroupZ; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &baseGroupX); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &baseGroupY); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &baseGroupZ); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountX); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountY); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountZ); + + Packet_vkCmdDispatchBaseKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDispatchBaseKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->baseGroupX = baseGroupX; + packet->baseGroupY = baseGroupY; + packet->baseGroupZ = baseGroupZ; + packet->groupCountX = groupCountX; + packet->groupCountY = groupCountY; + packet->groupCountZ = groupCountZ; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkTrimCommandPoolKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId commandPool; + VkCommandPoolTrimFlags flags; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandPool); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + + Packet_vkTrimCommandPoolKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkTrimCommandPoolKHR; + packet->call_info = call_info; + packet->device = device; + packet->commandPool = commandPool; + packet->flags = flags; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkEnumeratePhysicalDeviceGroupsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + PointerDecoder pPhysicalDeviceGroupCount; + StructPointerDecoder pPhysicalDeviceGroupProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pPhysicalDeviceGroupCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPhysicalDeviceGroupProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkEnumeratePhysicalDeviceGroupsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkEnumeratePhysicalDeviceGroupsKHR; + packet->call_info = call_info; + packet->instance = instance; + packet->pPhysicalDeviceGroupCount = pPhysicalDeviceGroupCount; + packet->pPhysicalDeviceGroupProperties = pPhysicalDeviceGroupProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceExternalBufferPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pExternalBufferInfo; + StructPointerDecoder pExternalBufferProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pExternalBufferInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pExternalBufferProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceExternalBufferPropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceExternalBufferPropertiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pExternalBufferInfo = pExternalBufferInfo; + packet->pExternalBufferProperties = pExternalBufferProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pGetWin32HandleInfo; + PointerDecoder pHandle; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pGetWin32HandleInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pHandle.DecodeVoidPtr((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryWin32HandleKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryWin32HandleKHR; + packet->call_info = call_info; + packet->device = device; + packet->pGetWin32HandleInfo = pGetWin32HandleInfo; + packet->pHandle = pHandle; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryWin32HandlePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkExternalMemoryHandleTypeFlagBits handleType; + uint64_t handle; + StructPointerDecoder pMemoryWin32HandleProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &handleType); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &handle); + bytes_read += pMemoryWin32HandleProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryWin32HandlePropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryWin32HandlePropertiesKHR; + packet->call_info = call_info; + packet->device = device; + packet->handleType = handleType; + packet->handle = handle; + packet->pMemoryWin32HandleProperties = pMemoryWin32HandleProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pGetFdInfo; + PointerDecoder pFd; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pGetFdInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFd.PreloadDecodeInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryFdKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryFdKHR; + packet->call_info = call_info; + packet->device = device; + packet->pGetFdInfo = pGetFdInfo; + packet->pFd = pFd; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryFdPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; + StructPointerDecoder pMemoryFdProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &handleType); + bytes_read += ValueDecoder::DecodeInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fd); + bytes_read += pMemoryFdProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryFdPropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryFdPropertiesKHR; + packet->call_info = call_info; + packet->device = device; + packet->handleType = handleType; + packet->fd = fd; + packet->pMemoryFdProperties = pMemoryFdProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pExternalSemaphoreInfo; + StructPointerDecoder pExternalSemaphoreProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pExternalSemaphoreInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pExternalSemaphoreProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pExternalSemaphoreInfo = pExternalSemaphoreInfo; + packet->pExternalSemaphoreProperties = pExternalSemaphoreProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkImportSemaphoreWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pImportSemaphoreWin32HandleInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pImportSemaphoreWin32HandleInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkImportSemaphoreWin32HandleKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkImportSemaphoreWin32HandleKHR; + packet->call_info = call_info; + packet->device = device; + packet->pImportSemaphoreWin32HandleInfo = pImportSemaphoreWin32HandleInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetSemaphoreWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pGetWin32HandleInfo; + PointerDecoder pHandle; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pGetWin32HandleInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pHandle.DecodeVoidPtr((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetSemaphoreWin32HandleKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetSemaphoreWin32HandleKHR; + packet->call_info = call_info; + packet->device = device; + packet->pGetWin32HandleInfo = pGetWin32HandleInfo; + packet->pHandle = pHandle; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkImportSemaphoreFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pImportSemaphoreFdInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pImportSemaphoreFdInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkImportSemaphoreFdKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkImportSemaphoreFdKHR; + packet->call_info = call_info; + packet->device = device; + packet->pImportSemaphoreFdInfo = pImportSemaphoreFdInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetSemaphoreFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pGetFdInfo; + PointerDecoder pFd; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pGetFdInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFd.PreloadDecodeInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetSemaphoreFdKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetSemaphoreFdKHR; + packet->call_info = call_info; + packet->device = device; + packet->pGetFdInfo = pGetFdInfo; + packet->pFd = pFd; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdPushDescriptorSetKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId layout; + uint32_t set; + uint32_t descriptorWriteCount; + StructPointerDecoder pDescriptorWrites; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineBindPoint); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &layout); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &set); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorWriteCount); + bytes_read += pDescriptorWrites.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPushDescriptorSetKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPushDescriptorSetKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pipelineBindPoint = pipelineBindPoint; + packet->layout = layout; + packet->set = set; + packet->descriptorWriteCount = descriptorWriteCount; + packet->pDescriptorWrites = pDescriptorWrites; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDescriptorUpdateTemplateKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDescriptorUpdateTemplate; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDescriptorUpdateTemplate.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDescriptorUpdateTemplateKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDescriptorUpdateTemplateKHR; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pDescriptorUpdateTemplate = pDescriptorUpdateTemplate; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyDescriptorUpdateTemplateKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId descriptorUpdateTemplate; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorUpdateTemplate); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyDescriptorUpdateTemplateKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyDescriptorUpdateTemplateKHR; + packet->call_info = call_info; + packet->device = device; + packet->descriptorUpdateTemplate = descriptorUpdateTemplate; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateRenderPass2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pRenderPass; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pRenderPass.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateRenderPass2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateRenderPass2KHR; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pRenderPass = pRenderPass; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginRenderPass2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pRenderPassBegin; + StructPointerDecoder pSubpassBeginInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pRenderPassBegin.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSubpassBeginInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBeginRenderPass2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginRenderPass2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pRenderPassBegin = pRenderPassBegin; + packet->pSubpassBeginInfo = pSubpassBeginInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdNextSubpass2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pSubpassBeginInfo; + StructPointerDecoder pSubpassEndInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pSubpassBeginInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSubpassEndInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdNextSubpass2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdNextSubpass2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pSubpassBeginInfo = pSubpassBeginInfo; + packet->pSubpassEndInfo = pSubpassEndInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndRenderPass2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pSubpassEndInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pSubpassEndInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdEndRenderPass2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndRenderPass2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pSubpassEndInfo = pSubpassEndInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetSwapchainStatusKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetSwapchainStatusKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetSwapchainStatusKHR; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceExternalFencePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pExternalFenceInfo; + StructPointerDecoder pExternalFenceProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pExternalFenceInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pExternalFenceProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceExternalFencePropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceExternalFencePropertiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pExternalFenceInfo = pExternalFenceInfo; + packet->pExternalFenceProperties = pExternalFenceProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkImportFenceWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pImportFenceWin32HandleInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pImportFenceWin32HandleInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkImportFenceWin32HandleKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkImportFenceWin32HandleKHR; + packet->call_info = call_info; + packet->device = device; + packet->pImportFenceWin32HandleInfo = pImportFenceWin32HandleInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetFenceWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pGetWin32HandleInfo; + PointerDecoder pHandle; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pGetWin32HandleInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pHandle.DecodeVoidPtr((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetFenceWin32HandleKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetFenceWin32HandleKHR; + packet->call_info = call_info; + packet->device = device; + packet->pGetWin32HandleInfo = pGetWin32HandleInfo; + packet->pHandle = pHandle; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkImportFenceFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pImportFenceFdInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pImportFenceFdInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkImportFenceFdKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkImportFenceFdKHR; + packet->call_info = call_info; + packet->device = device; + packet->pImportFenceFdInfo = pImportFenceFdInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetFenceFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pGetFdInfo; + PointerDecoder pFd; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pGetFdInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFd.PreloadDecodeInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetFenceFdKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetFenceFdKHR; + packet->call_info = call_info; + packet->device = device; + packet->pGetFdInfo = pGetFdInfo; + packet->pFd = pFd; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + PointerDecoder pCounterCount; + StructPointerDecoder pCounters; + StructPointerDecoder pCounterDescriptions; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueFamilyIndex); + bytes_read += pCounterCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCounters.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCounterDescriptions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->queueFamilyIndex = queueFamilyIndex; + packet->pCounterCount = pCounterCount; + packet->pCounters = pCounters; + packet->pCounterDescriptions = pCounterDescriptions; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pPerformanceQueryCreateInfo; + PointerDecoder pNumPasses; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pPerformanceQueryCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pNumPasses.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pPerformanceQueryCreateInfo = pPerformanceQueryCreateInfo; + packet->pNumPasses = pNumPasses; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAcquireProfilingLockKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAcquireProfilingLockKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAcquireProfilingLockKHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkReleaseProfilingLockKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + + Packet_vkReleaseProfilingLockKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkReleaseProfilingLockKHR; + packet->call_info = call_info; + packet->device = device; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSurfaceCapabilities2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pSurfaceInfo; + StructPointerDecoder pSurfaceCapabilities; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pSurfaceInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurfaceCapabilities.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceSurfaceCapabilities2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSurfaceCapabilities2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pSurfaceInfo = pSurfaceInfo; + packet->pSurfaceCapabilities = pSurfaceCapabilities; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSurfaceFormats2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pSurfaceInfo; + PointerDecoder pSurfaceFormatCount; + StructPointerDecoder pSurfaceFormats; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pSurfaceInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurfaceFormatCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurfaceFormats.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceSurfaceFormats2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSurfaceFormats2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pSurfaceInfo = pSurfaceInfo; + packet->pSurfaceFormatCount = pSurfaceFormatCount; + packet->pSurfaceFormats = pSurfaceFormats; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceDisplayProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceDisplayProperties2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceDisplayProperties2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceDisplayPlaneProperties2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceDisplayPlaneProperties2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDisplayModeProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId display; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDisplayModeProperties2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDisplayModeProperties2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->display = display; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDisplayPlaneCapabilities2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pDisplayPlaneInfo; + StructPointerDecoder pCapabilities; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pDisplayPlaneInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCapabilities.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDisplayPlaneCapabilities2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDisplayPlaneCapabilities2KHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pDisplayPlaneInfo = pDisplayPlaneInfo; + packet->pCapabilities = pCapabilities; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageMemoryRequirements2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetImageMemoryRequirements2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageMemoryRequirements2KHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetBufferMemoryRequirements2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetBufferMemoryRequirements2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetBufferMemoryRequirements2KHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageSparseMemoryRequirements2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSparseMemoryRequirementCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSparseMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetImageSparseMemoryRequirements2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageSparseMemoryRequirements2KHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + packet->pSparseMemoryRequirements = pSparseMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateSamplerYcbcrConversionKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pYcbcrConversion; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pYcbcrConversion.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateSamplerYcbcrConversionKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateSamplerYcbcrConversionKHR; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pYcbcrConversion = pYcbcrConversion; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroySamplerYcbcrConversionKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId ycbcrConversion; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &ycbcrConversion); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroySamplerYcbcrConversionKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroySamplerYcbcrConversionKHR; + packet->call_info = call_info; + packet->device = device; + packet->ycbcrConversion = ycbcrConversion; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBindBufferMemory2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindInfoCount); + bytes_read += pBindInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBindBufferMemory2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBindBufferMemory2KHR; + packet->call_info = call_info; + packet->device = device; + packet->bindInfoCount = bindInfoCount; + packet->pBindInfos = pBindInfos; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBindImageMemory2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindInfoCount); + bytes_read += pBindInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBindImageMemory2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBindImageMemory2KHR; + packet->call_info = call_info; + packet->device = device; + packet->bindInfoCount = bindInfoCount; + packet->pBindInfos = pBindInfos; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDescriptorSetLayoutSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pSupport; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSupport.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDescriptorSetLayoutSupportKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDescriptorSetLayoutSupportKHR; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pSupport = pSupport; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndirectCountKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBufferOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &maxDrawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawIndirectCountKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndirectCountKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->countBuffer = countBuffer; + packet->countBufferOffset = countBufferOffset; + packet->maxDrawCount = maxDrawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndexedIndirectCountKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBufferOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &maxDrawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawIndexedIndirectCountKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndexedIndirectCountKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->countBuffer = countBuffer; + packet->countBufferOffset = countBufferOffset; + packet->maxDrawCount = maxDrawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetSemaphoreCounterValueKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId semaphore; + PointerDecoder pValue; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &semaphore); + bytes_read += pValue.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetSemaphoreCounterValueKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetSemaphoreCounterValueKHR; + packet->call_info = call_info; + packet->device = device; + packet->semaphore = semaphore; + packet->pValue = pValue; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkWaitSemaphoresKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pWaitInfo; + uint64_t timeout; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pWaitInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &timeout); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkWaitSemaphoresKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkWaitSemaphoresKHR; + packet->call_info = call_info; + packet->device = device; + packet->pWaitInfo = pWaitInfo; + packet->timeout = timeout; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSignalSemaphoreKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pSignalInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pSignalInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkSignalSemaphoreKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSignalSemaphoreKHR; + packet->call_info = call_info; + packet->device = device; + packet->pSignalInfo = pSignalInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceFragmentShadingRatesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pFragmentShadingRateCount; + StructPointerDecoder pFragmentShadingRates; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pFragmentShadingRateCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFragmentShadingRates.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceFragmentShadingRatesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceFragmentShadingRatesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pFragmentShadingRateCount = pFragmentShadingRateCount; + packet->pFragmentShadingRates = pFragmentShadingRates; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetFragmentShadingRateKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pFragmentSize; + PointerDecoder combinerOps; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pFragmentSize.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += combinerOps.PreloadDecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetFragmentShadingRateKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetFragmentShadingRateKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pFragmentSize = pFragmentSize; + packet->combinerOps = combinerOps; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetRenderingAttachmentLocationsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pLocationInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pLocationInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetRenderingAttachmentLocationsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetRenderingAttachmentLocationsKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pLocationInfo = pLocationInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetRenderingInputAttachmentIndicesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pInputAttachmentIndexInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pInputAttachmentIndexInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetRenderingInputAttachmentIndicesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetRenderingInputAttachmentIndicesKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pInputAttachmentIndexInfo = pInputAttachmentIndexInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkWaitForPresentKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + uint64_t presentId; + uint64_t timeout; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &presentId); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &timeout); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkWaitForPresentKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkWaitForPresentKHR; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->presentId = presentId; + packet->timeout = timeout; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetBufferDeviceAddressKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + VkDeviceAddress return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetBufferDeviceAddressKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetBufferDeviceAddressKHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetBufferOpaqueCaptureAddressKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + uint64_t return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetBufferOpaqueCaptureAddressKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetBufferOpaqueCaptureAddressKHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceMemoryOpaqueCaptureAddressKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + uint64_t return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDeviceMemoryOpaqueCaptureAddressKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceMemoryOpaqueCaptureAddressKHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDeferredOperationKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDeferredOperation; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDeferredOperation.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDeferredOperationKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDeferredOperationKHR; + packet->call_info = call_info; + packet->device = device; + packet->pAllocator = pAllocator; + packet->pDeferredOperation = pDeferredOperation; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyDeferredOperationKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId operation; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &operation); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyDeferredOperationKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyDeferredOperationKHR; + packet->call_info = call_info; + packet->device = device; + packet->operation = operation; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeferredOperationMaxConcurrencyKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId operation; + uint32_t return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &operation); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDeferredOperationMaxConcurrencyKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeferredOperationMaxConcurrencyKHR; + packet->call_info = call_info; + packet->device = device; + packet->operation = operation; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeferredOperationResultKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId operation; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &operation); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDeferredOperationResultKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeferredOperationResultKHR; + packet->call_info = call_info; + packet->device = device; + packet->operation = operation; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPipelineExecutablePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pPipelineInfo; + PointerDecoder pExecutableCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pPipelineInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pExecutableCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPipelineExecutablePropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPipelineExecutablePropertiesKHR; + packet->call_info = call_info; + packet->device = device; + packet->pPipelineInfo = pPipelineInfo; + packet->pExecutableCount = pExecutableCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPipelineExecutableStatisticsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pExecutableInfo; + PointerDecoder pStatisticCount; + StructPointerDecoder pStatistics; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pExecutableInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pStatisticCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pStatistics.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPipelineExecutableStatisticsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPipelineExecutableStatisticsKHR; + packet->call_info = call_info; + packet->device = device; + packet->pExecutableInfo = pExecutableInfo; + packet->pStatisticCount = pStatisticCount; + packet->pStatistics = pStatistics; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPipelineExecutableInternalRepresentationsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pExecutableInfo; + PointerDecoder pInternalRepresentationCount; + StructPointerDecoder pInternalRepresentations; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pExecutableInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pInternalRepresentationCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pInternalRepresentations.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPipelineExecutableInternalRepresentationsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPipelineExecutableInternalRepresentationsKHR; + packet->call_info = call_info; + packet->device = device; + packet->pExecutableInfo = pExecutableInfo; + packet->pInternalRepresentationCount = pInternalRepresentationCount; + packet->pInternalRepresentations = pInternalRepresentations; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkMapMemory2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pMemoryMapInfo; + PointerDecoder ppData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pMemoryMapInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ppData.DecodeVoidPtr((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkMapMemory2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkMapMemory2KHR; + packet->call_info = call_info; + packet->device = device; + packet->pMemoryMapInfo = pMemoryMapInfo; + packet->ppData = ppData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkUnmapMemory2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pMemoryUnmapInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pMemoryUnmapInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkUnmapMemory2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkUnmapMemory2KHR; + packet->call_info = call_info; + packet->device = device; + packet->pMemoryUnmapInfo = pMemoryUnmapInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pQualityLevelInfo; + StructPointerDecoder pQualityLevelProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pQualityLevelInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pQualityLevelProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pQualityLevelInfo = pQualityLevelInfo; + packet->pQualityLevelProperties = pQualityLevelProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetEncodedVideoSessionParametersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pVideoSessionParametersInfo; + StructPointerDecoder pFeedbackInfo; + PointerDecoder pDataSize; + PointerDecoder pData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pVideoSessionParametersInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFeedbackInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDataSize.PreloadDecodeSizeT((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetEncodedVideoSessionParametersKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetEncodedVideoSessionParametersKHR; + packet->call_info = call_info; + packet->device = device; + packet->pVideoSessionParametersInfo = pVideoSessionParametersInfo; + packet->pFeedbackInfo = pFeedbackInfo; + packet->pDataSize = pDataSize; + packet->pData = pData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEncodeVideoKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pEncodeInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pEncodeInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdEncodeVideoKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEncodeVideoKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pEncodeInfo = pEncodeInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetEvent2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId event; + StructPointerDecoder pDependencyInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += pDependencyInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetEvent2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetEvent2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->event = event; + packet->pDependencyInfo = pDependencyInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdResetEvent2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId event; + VkPipelineStageFlags2 stageMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &event); + bytes_read += ValueDecoder::DecodeFlags64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stageMask); + + Packet_vkCmdResetEvent2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdResetEvent2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->event = event; + packet->stageMask = stageMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWaitEvents2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t eventCount; + HandlePointerDecoder pEvents; + StructPointerDecoder pDependencyInfos; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &eventCount); + bytes_read += pEvents.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pDependencyInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdWaitEvents2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWaitEvents2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->eventCount = eventCount; + packet->pEvents = pEvents; + packet->pDependencyInfos = pDependencyInfos; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdPipelineBarrier2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pDependencyInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pDependencyInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPipelineBarrier2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPipelineBarrier2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pDependencyInfo = pDependencyInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWriteTimestamp2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineStageFlags2 stage; + format::HandleId queryPool; + uint32_t query; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlags64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stage); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &query); + + Packet_vkCmdWriteTimestamp2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWriteTimestamp2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->stage = stage; + packet->queryPool = queryPool; + packet->query = query; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueSubmit2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + uint32_t submitCount; + StructPointerDecoder pSubmits; + format::HandleId fence; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &submitCount); + bytes_read += pSubmits.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &fence); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkQueueSubmit2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueSubmit2KHR; + packet->call_info = call_info; + packet->queue = queue; + packet->submitCount = submitCount; + packet->pSubmits = pSubmits; + packet->fence = fence; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWriteBufferMarker2AMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineStageFlags2 stage; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + uint32_t marker; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlags64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stage); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &marker); + + Packet_vkCmdWriteBufferMarker2AMD* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWriteBufferMarker2AMD; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->stage = stage; + packet->dstBuffer = dstBuffer; + packet->dstOffset = dstOffset; + packet->marker = marker; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetQueueCheckpointData2NV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + PointerDecoder pCheckpointDataCount; + StructPointerDecoder pCheckpointData; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += pCheckpointDataCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCheckpointData.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetQueueCheckpointData2NV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetQueueCheckpointData2NV; + packet->call_info = call_info; + packet->queue = queue; + packet->pCheckpointDataCount = pCheckpointDataCount; + packet->pCheckpointData = pCheckpointData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyBuffer2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pCopyBufferInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pCopyBufferInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyBuffer2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyBuffer2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCopyBufferInfo = pCopyBufferInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pCopyImageInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pCopyImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyImage2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyImage2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCopyImageInfo = pCopyImageInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyBufferToImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pCopyBufferToImageInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pCopyBufferToImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyBufferToImage2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyBufferToImage2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCopyBufferToImageInfo = pCopyBufferToImageInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyImageToBuffer2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pCopyImageToBufferInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pCopyImageToBufferInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyImageToBuffer2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyImageToBuffer2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCopyImageToBufferInfo = pCopyImageToBufferInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBlitImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pBlitImageInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pBlitImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBlitImage2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBlitImage2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pBlitImageInfo = pBlitImageInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdResolveImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pResolveImageInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pResolveImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdResolveImage2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdResolveImage2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pResolveImageInfo = pResolveImageInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdTraceRaysIndirect2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkDeviceAddress indirectDeviceAddress; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indirectDeviceAddress); + + Packet_vkCmdTraceRaysIndirect2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdTraceRaysIndirect2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->indirectDeviceAddress = indirectDeviceAddress; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceBufferMemoryRequirementsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceBufferMemoryRequirementsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceBufferMemoryRequirementsKHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceImageMemoryRequirementsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceImageMemoryRequirementsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceImageMemoryRequirementsKHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceImageSparseMemoryRequirementsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSparseMemoryRequirementCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSparseMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceImageSparseMemoryRequirementsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceImageSparseMemoryRequirementsKHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pSparseMemoryRequirementCount = pSparseMemoryRequirementCount; + packet->pSparseMemoryRequirements = pSparseMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindIndexBuffer2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkIndexType indexType; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &size); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indexType); + + Packet_vkCmdBindIndexBuffer2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindIndexBuffer2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->size = size; + packet->indexType = indexType; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetRenderingAreaGranularityKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pRenderingAreaInfo; + StructPointerDecoder pGranularity; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pRenderingAreaInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pGranularity.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetRenderingAreaGranularityKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetRenderingAreaGranularityKHR; + packet->call_info = call_info; + packet->device = device; + packet->pRenderingAreaInfo = pRenderingAreaInfo; + packet->pGranularity = pGranularity; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceImageSubresourceLayoutKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pLayout; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pLayout.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceImageSubresourceLayoutKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceImageSubresourceLayoutKHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pLayout = pLayout; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageSubresourceLayout2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId image; + StructPointerDecoder pSubresource; + StructPointerDecoder pLayout; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += pSubresource.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pLayout.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetImageSubresourceLayout2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageSubresourceLayout2KHR; + packet->call_info = call_info; + packet->device = device; + packet->image = image; + packet->pSubresource = pSubresource; + packet->pLayout = pLayout; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetLineStippleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &lineStippleFactor); + bytes_read += ValueDecoder::DecodeUInt16Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &lineStipplePattern); + + Packet_vkCmdSetLineStippleKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetLineStippleKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->lineStippleFactor = lineStippleFactor; + packet->lineStipplePattern = lineStipplePattern; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pTimeDomainCount; + PointerDecoder pTimeDomains; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pTimeDomainCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pTimeDomains.PreloadDecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pTimeDomainCount = pTimeDomainCount; + packet->pTimeDomains = pTimeDomains; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetCalibratedTimestampsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t timestampCount; + StructPointerDecoder pTimestampInfos; + PointerDecoder pTimestamps; + PointerDecoder pMaxDeviation; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), ×tampCount); + bytes_read += pTimestampInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pTimestamps.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMaxDeviation.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetCalibratedTimestampsKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetCalibratedTimestampsKHR; + packet->call_info = call_info; + packet->device = device; + packet->timestampCount = timestampCount; + packet->pTimestampInfos = pTimestampInfos; + packet->pTimestamps = pTimestamps; + packet->pMaxDeviation = pMaxDeviation; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::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.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBindDescriptorSets2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindDescriptorSets2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pBindDescriptorSetsInfo = pBindDescriptorSetsInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::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.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPushConstants2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPushConstants2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pPushConstantsInfo = pPushConstantsInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::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.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPushDescriptorSet2KHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPushDescriptorSet2KHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pPushDescriptorSetInfo = pPushDescriptorSetInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::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.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetDescriptorBufferOffsets2EXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDescriptorBufferOffsets2EXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pSetDescriptorBufferOffsetsInfo = pSetDescriptorBufferOffsetsInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::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.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pBindDescriptorBufferEmbeddedSamplersInfo = pBindDescriptorBufferEmbeddedSamplersInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkFrameBoundaryANDROID(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId semaphore; + format::HandleId image; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &semaphore); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + + Packet_vkFrameBoundaryANDROID* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkFrameBoundaryANDROID; + packet->call_info = call_info; + packet->device = device; + packet->semaphore = semaphore; + packet->image = image; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDebugReportCallbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pCallback; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCallback.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDebugReportCallbackEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDebugReportCallbackEXT; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pCallback = pCallback; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyDebugReportCallbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + format::HandleId callback; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &callback); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyDebugReportCallbackEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyDebugReportCallbackEXT; + packet->call_info = call_info; + packet->instance = instance; + packet->callback = callback; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDebugReportMessageEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + VkDebugReportFlagsEXT flags; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + size_t location; + int32_t messageCode; + StringDecoder pLayerPrefix; + StringDecoder pMessage; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &objectType); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &object); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &location); + bytes_read += ValueDecoder::DecodeInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &messageCode); + bytes_read += pLayerPrefix.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMessage.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDebugReportMessageEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDebugReportMessageEXT; + packet->call_info = call_info; + packet->instance = instance; + packet->flags = flags; + packet->objectType = objectType; + packet->object = object; + packet->location = location; + packet->messageCode = messageCode; + packet->pLayerPrefix = pLayerPrefix; + packet->pMessage = pMessage; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDebugMarkerSetObjectTagEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pTagInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pTagInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkDebugMarkerSetObjectTagEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDebugMarkerSetObjectTagEXT; + packet->call_info = call_info; + packet->device = device; + packet->pTagInfo = pTagInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDebugMarkerSetObjectNameEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pNameInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pNameInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkDebugMarkerSetObjectNameEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDebugMarkerSetObjectNameEXT; + packet->call_info = call_info; + packet->device = device; + packet->pNameInfo = pNameInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDebugMarkerBeginEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pMarkerInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pMarkerInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdDebugMarkerBeginEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDebugMarkerBeginEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pMarkerInfo = pMarkerInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDebugMarkerEndEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + + Packet_vkCmdDebugMarkerEndEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDebugMarkerEndEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDebugMarkerInsertEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pMarkerInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pMarkerInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdDebugMarkerInsertEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDebugMarkerInsertEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pMarkerInfo = pMarkerInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindTransformFeedbackBuffersEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstBinding; + uint32_t bindingCount; + HandlePointerDecoder pBuffers; + PointerDecoder pOffsets; + PointerDecoder pSizes; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstBinding); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindingCount); + bytes_read += pBuffers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pOffsets.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSizes.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBindTransformFeedbackBuffersEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindTransformFeedbackBuffersEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstBinding = firstBinding; + packet->bindingCount = bindingCount; + packet->pBuffers = pBuffers; + packet->pOffsets = pOffsets; + packet->pSizes = pSizes; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginTransformFeedbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstCounterBuffer; + uint32_t counterBufferCount; + HandlePointerDecoder pCounterBuffers; + PointerDecoder pCounterBufferOffsets; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstCounterBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &counterBufferCount); + bytes_read += pCounterBuffers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCounterBufferOffsets.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBeginTransformFeedbackEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginTransformFeedbackEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstCounterBuffer = firstCounterBuffer; + packet->counterBufferCount = counterBufferCount; + packet->pCounterBuffers = pCounterBuffers; + packet->pCounterBufferOffsets = pCounterBufferOffsets; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndTransformFeedbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstCounterBuffer; + uint32_t counterBufferCount; + HandlePointerDecoder pCounterBuffers; + PointerDecoder pCounterBufferOffsets; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstCounterBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &counterBufferCount); + bytes_read += pCounterBuffers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCounterBufferOffsets.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdEndTransformFeedbackEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndTransformFeedbackEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstCounterBuffer = firstCounterBuffer; + packet->counterBufferCount = counterBufferCount; + packet->pCounterBuffers = pCounterBuffers; + packet->pCounterBufferOffsets = pCounterBufferOffsets; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginQueryIndexedEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t query; + VkQueryControlFlags flags; + uint32_t index; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &query); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &index); + + Packet_vkCmdBeginQueryIndexedEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginQueryIndexedEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->queryPool = queryPool; + packet->query = query; + packet->flags = flags; + packet->index = index; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndQueryIndexedEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t query; + uint32_t index; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &query); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &index); + + Packet_vkCmdEndQueryIndexedEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndQueryIndexedEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->queryPool = queryPool; + packet->query = query; + packet->index = index; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndirectByteCountEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t instanceCount; + uint32_t firstInstance; + format::HandleId counterBuffer; + VkDeviceSize counterBufferOffset; + uint32_t counterOffset; + uint32_t vertexStride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instanceCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstInstance); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &counterBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &counterBufferOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &counterOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &vertexStride); + + Packet_vkCmdDrawIndirectByteCountEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndirectByteCountEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->instanceCount = instanceCount; + packet->firstInstance = firstInstance; + packet->counterBuffer = counterBuffer; + packet->counterBufferOffset = counterBufferOffset; + packet->counterOffset = counterOffset; + packet->vertexStride = vertexStride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageViewHandleNVX(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + uint32_t return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetImageViewHandleNVX* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageViewHandleNVX; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageViewAddressNVX(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId imageView; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageView); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetImageViewAddressNVX* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageViewAddressNVX; + packet->call_info = call_info; + packet->device = device; + packet->imageView = imageView; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndirectCountAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBufferOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &maxDrawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawIndirectCountAMD* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndirectCountAMD; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->countBuffer = countBuffer; + packet->countBufferOffset = countBufferOffset; + packet->maxDrawCount = maxDrawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawIndexedIndirectCountAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBufferOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &maxDrawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawIndexedIndirectCountAMD* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawIndexedIndirectCountAMD; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->countBuffer = countBuffer; + packet->countBufferOffset = countBufferOffset; + packet->maxDrawCount = maxDrawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetShaderInfoAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipeline; + VkShaderStageFlagBits shaderStage; + VkShaderInfoTypeAMD infoType; + PointerDecoder pInfoSize; + PointerDecoder pInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &shaderStage); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &infoType); + bytes_read += pInfoSize.PreloadDecodeSizeT((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pInfo.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetShaderInfoAMD* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetShaderInfoAMD; + packet->call_info = call_info; + packet->device = device; + packet->pipeline = pipeline; + packet->shaderStage = shaderStage; + packet->infoType = infoType; + packet->pInfoSize = pInfoSize; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateStreamDescriptorSurfaceGGP(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateStreamDescriptorSurfaceGGP* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateStreamDescriptorSurfaceGGP; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; + VkExternalMemoryHandleTypeFlagsNV externalHandleType; + StructPointerDecoder pExternalImageFormatProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &format); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &type); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &tiling); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &usage); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &flags); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &externalHandleType); + bytes_read += pExternalImageFormatProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceExternalImageFormatPropertiesNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceExternalImageFormatPropertiesNV; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->format = format; + packet->type = type; + packet->tiling = tiling; + packet->usage = usage; + packet->flags = flags; + packet->externalHandleType = externalHandleType; + packet->pExternalImageFormatProperties = pExternalImageFormatProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryWin32HandleNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId memory; + VkExternalMemoryHandleTypeFlagsNV handleType; + PointerDecoder pHandle; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memory); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &handleType); + bytes_read += pHandle.DecodeVoidPtr((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryWin32HandleNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryWin32HandleNV; + packet->call_info = call_info; + packet->device = device; + packet->memory = memory; + packet->handleType = handleType; + packet->pHandle = pHandle; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateViSurfaceNN(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateViSurfaceNN* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateViSurfaceNN; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginConditionalRenderingEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pConditionalRenderingBegin; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pConditionalRenderingBegin.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBeginConditionalRenderingEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginConditionalRenderingEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pConditionalRenderingBegin = pConditionalRenderingBegin; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndConditionalRenderingEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + + Packet_vkCmdEndConditionalRenderingEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndConditionalRenderingEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetViewportWScalingNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstViewport; + uint32_t viewportCount; + StructPointerDecoder pViewportWScalings; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstViewport); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &viewportCount); + bytes_read += pViewportWScalings.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetViewportWScalingNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetViewportWScalingNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstViewport = firstViewport; + packet->viewportCount = viewportCount; + packet->pViewportWScalings = pViewportWScalings; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkReleaseDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId display; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkReleaseDisplayEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkReleaseDisplayEXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->display = display; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAcquireXlibDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint64_t dpy; + format::HandleId display; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dpy); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAcquireXlibDisplayEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAcquireXlibDisplayEXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->dpy = dpy; + packet->display = display; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetRandROutputDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint64_t dpy; + size_t rrOutput; + HandlePointerDecoder pDisplay; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dpy); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &rrOutput); + bytes_read += pDisplay.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetRandROutputDisplayEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetRandROutputDisplayEXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->dpy = dpy; + packet->rrOutput = rrOutput; + packet->pDisplay = pDisplay; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSurfaceCapabilities2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId surface; + StructPointerDecoder pSurfaceCapabilities; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &surface); + bytes_read += pSurfaceCapabilities.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceSurfaceCapabilities2EXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSurfaceCapabilities2EXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->surface = surface; + packet->pSurfaceCapabilities = pSurfaceCapabilities; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDisplayPowerControlEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId display; + StructPointerDecoder pDisplayPowerInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += pDisplayPowerInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkDisplayPowerControlEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDisplayPowerControlEXT; + packet->call_info = call_info; + packet->device = device; + packet->display = display; + packet->pDisplayPowerInfo = pDisplayPowerInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkRegisterDeviceEventEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pDeviceEventInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pFence; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pDeviceEventInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFence.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkRegisterDeviceEventEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkRegisterDeviceEventEXT; + packet->call_info = call_info; + packet->device = device; + packet->pDeviceEventInfo = pDeviceEventInfo; + packet->pAllocator = pAllocator; + packet->pFence = pFence; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkRegisterDisplayEventEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId display; + StructPointerDecoder pDisplayEventInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pFence; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += pDisplayEventInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFence.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkRegisterDisplayEventEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkRegisterDisplayEventEXT; + packet->call_info = call_info; + packet->device = device; + packet->display = display; + packet->pDisplayEventInfo = pDisplayEventInfo; + packet->pAllocator = pAllocator; + packet->pFence = pFence; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetSwapchainCounterEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + VkSurfaceCounterFlagBitsEXT counter; + PointerDecoder pCounterValue; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &counter); + bytes_read += pCounterValue.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetSwapchainCounterEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetSwapchainCounterEXT; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->counter = counter; + packet->pCounterValue = pCounterValue; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetRefreshCycleDurationGOOGLE(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pDisplayTimingProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += pDisplayTimingProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetRefreshCycleDurationGOOGLE* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetRefreshCycleDurationGOOGLE; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->pDisplayTimingProperties = pDisplayTimingProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPastPresentationTimingGOOGLE(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + PointerDecoder pPresentationTimingCount; + StructPointerDecoder pPresentationTimings; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += pPresentationTimingCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPresentationTimings.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPastPresentationTimingGOOGLE* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPastPresentationTimingGOOGLE; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->pPresentationTimingCount = pPresentationTimingCount; + packet->pPresentationTimings = pPresentationTimings; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDiscardRectangleEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstDiscardRectangle; + uint32_t discardRectangleCount; + StructPointerDecoder pDiscardRectangles; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstDiscardRectangle); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &discardRectangleCount); + bytes_read += pDiscardRectangles.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetDiscardRectangleEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDiscardRectangleEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstDiscardRectangle = firstDiscardRectangle; + packet->discardRectangleCount = discardRectangleCount; + packet->pDiscardRectangles = pDiscardRectangles; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDiscardRectangleEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 discardRectangleEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &discardRectangleEnable); + + Packet_vkCmdSetDiscardRectangleEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDiscardRectangleEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->discardRectangleEnable = discardRectangleEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDiscardRectangleModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkDiscardRectangleModeEXT discardRectangleMode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &discardRectangleMode); + + Packet_vkCmdSetDiscardRectangleModeEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDiscardRectangleModeEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->discardRectangleMode = discardRectangleMode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetHdrMetadataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t swapchainCount; + HandlePointerDecoder pSwapchains; + StructPointerDecoder pMetadata; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchainCount); + bytes_read += pSwapchains.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMetadata.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkSetHdrMetadataEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetHdrMetadataEXT; + packet->call_info = call_info; + packet->device = device; + packet->swapchainCount = swapchainCount; + packet->pSwapchains = pSwapchains; + packet->pMetadata = pMetadata; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateIOSSurfaceMVK(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateIOSSurfaceMVK* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateIOSSurfaceMVK; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateMacOSSurfaceMVK(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateMacOSSurfaceMVK* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateMacOSSurfaceMVK; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetDebugUtilsObjectNameEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pNameInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pNameInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkSetDebugUtilsObjectNameEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetDebugUtilsObjectNameEXT; + packet->call_info = call_info; + packet->device = device; + packet->pNameInfo = pNameInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetDebugUtilsObjectTagEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pTagInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pTagInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkSetDebugUtilsObjectTagEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetDebugUtilsObjectTagEXT; + packet->call_info = call_info; + packet->device = device; + packet->pTagInfo = pTagInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueBeginDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + StructPointerDecoder pLabelInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += pLabelInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkQueueBeginDebugUtilsLabelEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueBeginDebugUtilsLabelEXT; + packet->call_info = call_info; + packet->queue = queue; + packet->pLabelInfo = pLabelInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueEndDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + + Packet_vkQueueEndDebugUtilsLabelEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueEndDebugUtilsLabelEXT; + packet->call_info = call_info; + packet->queue = queue; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueInsertDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + StructPointerDecoder pLabelInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += pLabelInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkQueueInsertDebugUtilsLabelEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueInsertDebugUtilsLabelEXT; + packet->call_info = call_info; + packet->queue = queue; + packet->pLabelInfo = pLabelInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBeginDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pLabelInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pLabelInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBeginDebugUtilsLabelEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBeginDebugUtilsLabelEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pLabelInfo = pLabelInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdEndDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + + Packet_vkCmdEndDebugUtilsLabelEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdEndDebugUtilsLabelEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdInsertDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pLabelInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pLabelInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdInsertDebugUtilsLabelEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdInsertDebugUtilsLabelEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pLabelInfo = pLabelInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDebugUtilsMessengerEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pMessenger; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMessenger.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDebugUtilsMessengerEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDebugUtilsMessengerEXT; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pMessenger = pMessenger; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyDebugUtilsMessengerEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + format::HandleId messenger; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &messenger); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyDebugUtilsMessengerEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyDebugUtilsMessengerEXT; + packet->call_info = call_info; + packet->instance = instance; + packet->messenger = messenger; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSubmitDebugUtilsMessageEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageTypes; + StructPointerDecoder pCallbackData; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &messageSeverity); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &messageTypes); + bytes_read += pCallbackData.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkSubmitDebugUtilsMessageEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSubmitDebugUtilsMessageEXT; + packet->call_info = call_info; + packet->instance = instance; + packet->messageSeverity = messageSeverity; + packet->messageTypes = messageTypes; + packet->pCallbackData = pCallbackData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetAndroidHardwareBufferPropertiesANDROID(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint64_t buffer; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetAndroidHardwareBufferPropertiesANDROID* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetAndroidHardwareBufferPropertiesANDROID; + packet->call_info = call_info; + packet->device = device; + packet->buffer = buffer; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryAndroidHardwareBufferANDROID(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pBuffer; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pBuffer.DecodeVoidPtr((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryAndroidHardwareBufferANDROID* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryAndroidHardwareBufferANDROID; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pBuffer = pBuffer; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetSampleLocationsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pSampleLocationsInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pSampleLocationsInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetSampleLocationsEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetSampleLocationsEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pSampleLocationsInfo = pSampleLocationsInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceMultisamplePropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + VkSampleCountFlagBits samples; + StructPointerDecoder pMultisampleProperties; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &samples); + bytes_read += pMultisampleProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPhysicalDeviceMultisamplePropertiesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceMultisamplePropertiesEXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->samples = samples; + packet->pMultisampleProperties = pMultisampleProperties; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageDrmFormatModifierPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId image; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetImageDrmFormatModifierPropertiesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageDrmFormatModifierPropertiesEXT; + packet->call_info = call_info; + packet->device = device; + packet->image = image; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateValidationCacheEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pValidationCache; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pValidationCache.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateValidationCacheEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateValidationCacheEXT; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pValidationCache = pValidationCache; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyValidationCacheEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId validationCache; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &validationCache); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyValidationCacheEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyValidationCacheEXT; + packet->call_info = call_info; + packet->device = device; + packet->validationCache = validationCache; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkMergeValidationCachesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId dstCache; + uint32_t srcCacheCount; + HandlePointerDecoder pSrcCaches; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstCache); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &srcCacheCount); + bytes_read += pSrcCaches.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkMergeValidationCachesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkMergeValidationCachesEXT; + packet->call_info = call_info; + packet->device = device; + packet->dstCache = dstCache; + packet->srcCacheCount = srcCacheCount; + packet->pSrcCaches = pSrcCaches; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetValidationCacheDataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId validationCache; + PointerDecoder pDataSize; + PointerDecoder pData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &validationCache); + bytes_read += pDataSize.PreloadDecodeSizeT((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetValidationCacheDataEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetValidationCacheDataEXT; + packet->call_info = call_info; + packet->device = device; + packet->validationCache = validationCache; + packet->pDataSize = pDataSize; + packet->pData = pData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindShadingRateImageNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId imageView; + VkImageLayout imageLayout; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageView); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageLayout); + + Packet_vkCmdBindShadingRateImageNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindShadingRateImageNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->imageView = imageView; + packet->imageLayout = imageLayout; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetViewportShadingRatePaletteNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstViewport; + uint32_t viewportCount; + StructPointerDecoder pShadingRatePalettes; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstViewport); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &viewportCount); + bytes_read += pShadingRatePalettes.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetViewportShadingRatePaletteNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetViewportShadingRatePaletteNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstViewport = firstViewport; + packet->viewportCount = viewportCount; + packet->pShadingRatePalettes = pShadingRatePalettes; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCoarseSampleOrderNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + StructPointerDecoder pCustomSampleOrders; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &sampleOrderType); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &customSampleOrderCount); + bytes_read += pCustomSampleOrders.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetCoarseSampleOrderNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCoarseSampleOrderNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->sampleOrderType = sampleOrderType; + packet->customSampleOrderCount = customSampleOrderCount; + packet->pCustomSampleOrders = pCustomSampleOrders; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateAccelerationStructureNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pAccelerationStructure; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAccelerationStructure.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateAccelerationStructureNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateAccelerationStructureNV; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pAccelerationStructure = pAccelerationStructure; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyAccelerationStructureNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId accelerationStructure; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &accelerationStructure); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyAccelerationStructureNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyAccelerationStructureNV; + packet->call_info = call_info; + packet->device = device; + packet->accelerationStructure = accelerationStructure; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetAccelerationStructureMemoryRequirementsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetAccelerationStructureMemoryRequirementsNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetAccelerationStructureMemoryRequirementsNV; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBindAccelerationStructureMemoryNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindInfoCount); + bytes_read += pBindInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBindAccelerationStructureMemoryNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBindAccelerationStructureMemoryNV; + packet->call_info = call_info; + packet->device = device; + packet->bindInfoCount = bindInfoCount; + packet->pBindInfos = pBindInfos; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBuildAccelerationStructureNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pInfo; + format::HandleId instanceData; + VkDeviceSize instanceOffset; + VkBool32 update; + format::HandleId dst; + format::HandleId src; + format::HandleId scratch; + VkDeviceSize scratchOffset; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instanceData); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instanceOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &update); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dst); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &src); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &scratch); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &scratchOffset); + + Packet_vkCmdBuildAccelerationStructureNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBuildAccelerationStructureNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pInfo = pInfo; + packet->instanceData = instanceData; + packet->instanceOffset = instanceOffset; + packet->update = update; + packet->dst = dst; + packet->src = src; + packet->scratch = scratch; + packet->scratchOffset = scratchOffset; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyAccelerationStructureNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId dst; + format::HandleId src; + VkCopyAccelerationStructureModeKHR mode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dst); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &src); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &mode); + + Packet_vkCmdCopyAccelerationStructureNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyAccelerationStructureNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->dst = dst; + packet->src = src; + packet->mode = mode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdTraceRaysNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId raygenShaderBindingTableBuffer; + VkDeviceSize raygenShaderBindingOffset; + format::HandleId missShaderBindingTableBuffer; + VkDeviceSize missShaderBindingOffset; + VkDeviceSize missShaderBindingStride; + format::HandleId hitShaderBindingTableBuffer; + VkDeviceSize hitShaderBindingOffset; + VkDeviceSize hitShaderBindingStride; + format::HandleId callableShaderBindingTableBuffer; + VkDeviceSize callableShaderBindingOffset; + VkDeviceSize callableShaderBindingStride; + uint32_t width; + uint32_t height; + uint32_t depth; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &raygenShaderBindingTableBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &raygenShaderBindingOffset); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &missShaderBindingTableBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &missShaderBindingOffset); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &missShaderBindingStride); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &hitShaderBindingTableBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &hitShaderBindingOffset); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &hitShaderBindingStride); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &callableShaderBindingTableBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &callableShaderBindingOffset); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &callableShaderBindingStride); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &width); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &height); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depth); + + Packet_vkCmdTraceRaysNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdTraceRaysNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->raygenShaderBindingTableBuffer = raygenShaderBindingTableBuffer; + packet->raygenShaderBindingOffset = raygenShaderBindingOffset; + packet->missShaderBindingTableBuffer = missShaderBindingTableBuffer; + packet->missShaderBindingOffset = missShaderBindingOffset; + packet->missShaderBindingStride = missShaderBindingStride; + packet->hitShaderBindingTableBuffer = hitShaderBindingTableBuffer; + packet->hitShaderBindingOffset = hitShaderBindingOffset; + packet->hitShaderBindingStride = hitShaderBindingStride; + packet->callableShaderBindingTableBuffer = callableShaderBindingTableBuffer; + packet->callableShaderBindingOffset = callableShaderBindingOffset; + packet->callableShaderBindingStride = callableShaderBindingStride; + packet->width = width; + packet->height = height; + packet->depth = depth; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateRayTracingPipelinesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipelineCache; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineCache); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &createInfoCount); + bytes_read += pCreateInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPipelines.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateRayTracingPipelinesNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateRayTracingPipelinesNV; + packet->call_info = call_info; + packet->device = device; + packet->pipelineCache = pipelineCache; + packet->createInfoCount = createInfoCount; + packet->pCreateInfos = pCreateInfos; + packet->pAllocator = pAllocator; + packet->pPipelines = pPipelines; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetRayTracingShaderGroupHandlesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipeline; + uint32_t firstGroup; + uint32_t groupCount; + size_t dataSize; + PointerDecoder pData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstGroup); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCount); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dataSize); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetRayTracingShaderGroupHandlesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetRayTracingShaderGroupHandlesKHR; + packet->call_info = call_info; + packet->device = device; + packet->pipeline = pipeline; + packet->firstGroup = firstGroup; + packet->groupCount = groupCount; + packet->dataSize = dataSize; + packet->pData = pData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetRayTracingShaderGroupHandlesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipeline; + uint32_t firstGroup; + uint32_t groupCount; + size_t dataSize; + PointerDecoder pData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstGroup); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCount); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dataSize); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetRayTracingShaderGroupHandlesNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetRayTracingShaderGroupHandlesNV; + packet->call_info = call_info; + packet->device = device; + packet->pipeline = pipeline; + packet->firstGroup = firstGroup; + packet->groupCount = groupCount; + packet->dataSize = dataSize; + packet->pData = pData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetAccelerationStructureHandleNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId accelerationStructure; + size_t dataSize; + PointerDecoder pData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &accelerationStructure); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dataSize); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetAccelerationStructureHandleNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetAccelerationStructureHandleNV; + packet->call_info = call_info; + packet->device = device; + packet->accelerationStructure = accelerationStructure; + packet->dataSize = dataSize; + packet->pData = pData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWriteAccelerationStructuresPropertiesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t accelerationStructureCount; + HandlePointerDecoder pAccelerationStructures; + VkQueryType queryType; + format::HandleId queryPool; + uint32_t firstQuery; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &accelerationStructureCount); + bytes_read += pAccelerationStructures.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryType); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstQuery); + + Packet_vkCmdWriteAccelerationStructuresPropertiesNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWriteAccelerationStructuresPropertiesNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->accelerationStructureCount = accelerationStructureCount; + packet->pAccelerationStructures = pAccelerationStructures; + packet->queryType = queryType; + packet->queryPool = queryPool; + packet->firstQuery = firstQuery; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCompileDeferredNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipeline; + uint32_t shader; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &shader); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCompileDeferredNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCompileDeferredNV; + packet->call_info = call_info; + packet->device = device; + packet->pipeline = pipeline; + packet->shader = shader; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryHostPointerPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkExternalMemoryHandleTypeFlagBits handleType; + uint64_t pHostPointer; + StructPointerDecoder pMemoryHostPointerProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &handleType); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pHostPointer); + bytes_read += pMemoryHostPointerProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryHostPointerPropertiesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryHostPointerPropertiesEXT; + packet->call_info = call_info; + packet->device = device; + packet->handleType = handleType; + packet->pHostPointer = pHostPointer; + packet->pMemoryHostPointerProperties = pMemoryHostPointerProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWriteBufferMarkerAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineStageFlagBits pipelineStage; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + uint32_t marker; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineStage); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dstOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &marker); + + Packet_vkCmdWriteBufferMarkerAMD* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWriteBufferMarkerAMD; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pipelineStage = pipelineStage; + packet->dstBuffer = dstBuffer; + packet->dstOffset = dstOffset; + packet->marker = marker; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pTimeDomainCount; + PointerDecoder pTimeDomains; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pTimeDomainCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pTimeDomains.PreloadDecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pTimeDomainCount = pTimeDomainCount; + packet->pTimeDomains = pTimeDomains; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetCalibratedTimestampsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t timestampCount; + StructPointerDecoder pTimestampInfos; + PointerDecoder pTimestamps; + PointerDecoder pMaxDeviation; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), ×tampCount); + bytes_read += pTimestampInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pTimestamps.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMaxDeviation.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetCalibratedTimestampsEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetCalibratedTimestampsEXT; + packet->call_info = call_info; + packet->device = device; + packet->timestampCount = timestampCount; + packet->pTimestampInfos = pTimestampInfos; + packet->pTimestamps = pTimestamps; + packet->pMaxDeviation = pMaxDeviation; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawMeshTasksNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t taskCount; + uint32_t firstTask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &taskCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstTask); + + Packet_vkCmdDrawMeshTasksNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawMeshTasksNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->taskCount = taskCount; + packet->firstTask = firstTask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawMeshTasksIndirectNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + uint32_t drawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &drawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawMeshTasksIndirectNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawMeshTasksIndirectNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->drawCount = drawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawMeshTasksIndirectCountNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBufferOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &maxDrawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawMeshTasksIndirectCountNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawMeshTasksIndirectCountNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->countBuffer = countBuffer; + packet->countBufferOffset = countBufferOffset; + packet->maxDrawCount = maxDrawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetExclusiveScissorEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstExclusiveScissor; + uint32_t exclusiveScissorCount; + PointerDecoder pExclusiveScissorEnables; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstExclusiveScissor); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &exclusiveScissorCount); + bytes_read += pExclusiveScissorEnables.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetExclusiveScissorEnableNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetExclusiveScissorEnableNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstExclusiveScissor = firstExclusiveScissor; + packet->exclusiveScissorCount = exclusiveScissorCount; + packet->pExclusiveScissorEnables = pExclusiveScissorEnables; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetExclusiveScissorNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstExclusiveScissor; + uint32_t exclusiveScissorCount; + StructPointerDecoder pExclusiveScissors; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstExclusiveScissor); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &exclusiveScissorCount); + bytes_read += pExclusiveScissors.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetExclusiveScissorNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetExclusiveScissorNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstExclusiveScissor = firstExclusiveScissor; + packet->exclusiveScissorCount = exclusiveScissorCount; + packet->pExclusiveScissors = pExclusiveScissors; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCheckpointNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint64_t pCheckpointMarker; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pCheckpointMarker); + + Packet_vkCmdSetCheckpointNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCheckpointNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pCheckpointMarker = pCheckpointMarker; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetQueueCheckpointDataNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + PointerDecoder pCheckpointDataCount; + StructPointerDecoder pCheckpointData; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += pCheckpointDataCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCheckpointData.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetQueueCheckpointDataNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetQueueCheckpointDataNV; + packet->call_info = call_info; + packet->queue = queue; + packet->pCheckpointDataCount = pCheckpointDataCount; + packet->pCheckpointData = pCheckpointData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkInitializePerformanceApiINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInitializeInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInitializeInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkInitializePerformanceApiINTEL* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkInitializePerformanceApiINTEL; + packet->call_info = call_info; + packet->device = device; + packet->pInitializeInfo = pInitializeInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkUninitializePerformanceApiINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + + Packet_vkUninitializePerformanceApiINTEL* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkUninitializePerformanceApiINTEL; + packet->call_info = call_info; + packet->device = device; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetPerformanceMarkerINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pMarkerInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pMarkerInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCmdSetPerformanceMarkerINTEL* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetPerformanceMarkerINTEL; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pMarkerInfo = pMarkerInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetPerformanceStreamMarkerINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pMarkerInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pMarkerInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCmdSetPerformanceStreamMarkerINTEL* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetPerformanceStreamMarkerINTEL; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pMarkerInfo = pMarkerInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetPerformanceOverrideINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pOverrideInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pOverrideInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCmdSetPerformanceOverrideINTEL* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetPerformanceOverrideINTEL; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pOverrideInfo = pOverrideInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAcquirePerformanceConfigurationINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pAcquireInfo; + HandlePointerDecoder pConfiguration; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pAcquireInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pConfiguration.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAcquirePerformanceConfigurationINTEL* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAcquirePerformanceConfigurationINTEL; + packet->call_info = call_info; + packet->device = device; + packet->pAcquireInfo = pAcquireInfo; + packet->pConfiguration = pConfiguration; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkReleasePerformanceConfigurationINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId configuration; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &configuration); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkReleasePerformanceConfigurationINTEL* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkReleasePerformanceConfigurationINTEL; + packet->call_info = call_info; + packet->device = device; + packet->configuration = configuration; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueSetPerformanceConfigurationINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + format::HandleId configuration; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &configuration); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkQueueSetPerformanceConfigurationINTEL* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueSetPerformanceConfigurationINTEL; + packet->call_info = call_info; + packet->queue = queue; + packet->configuration = configuration; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPerformanceParameterINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkPerformanceParameterTypeINTEL parameter; + StructPointerDecoder pValue; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), ¶meter); + bytes_read += pValue.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPerformanceParameterINTEL* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPerformanceParameterINTEL; + packet->call_info = call_info; + packet->device = device; + packet->parameter = parameter; + packet->pValue = pValue; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetLocalDimmingAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapChain; + VkBool32 localDimmingEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapChain); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &localDimmingEnable); + + Packet_vkSetLocalDimmingAMD* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetLocalDimmingAMD; + packet->call_info = call_info; + packet->device = device; + packet->swapChain = swapChain; + packet->localDimmingEnable = localDimmingEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateImagePipeSurfaceFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateImagePipeSurfaceFUCHSIA* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateImagePipeSurfaceFUCHSIA; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateMetalSurfaceEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateMetalSurfaceEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateMetalSurfaceEXT; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetBufferDeviceAddressEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + VkDeviceAddress return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetBufferDeviceAddressEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetBufferDeviceAddressEXT; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceToolPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pToolCount; + StructPointerDecoder pToolProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pToolCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pToolProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceToolPropertiesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceToolPropertiesEXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pToolCount = pToolCount; + packet->pToolProperties = pToolProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pPropertyCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pPropertyCount = pPropertyCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pCombinationCount; + StructPointerDecoder pCombinations; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pCombinationCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCombinations.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pCombinationCount = pCombinationCount; + packet->pCombinations = pCombinations; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceSurfacePresentModes2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pSurfaceInfo; + PointerDecoder pPresentModeCount; + PointerDecoder pPresentModes; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pSurfaceInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPresentModeCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPresentModes.PreloadDecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceSurfacePresentModes2EXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceSurfacePresentModes2EXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pSurfaceInfo = pSurfaceInfo; + packet->pPresentModeCount = pPresentModeCount; + packet->pPresentModes = pPresentModes; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAcquireFullScreenExclusiveModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAcquireFullScreenExclusiveModeEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAcquireFullScreenExclusiveModeEXT; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkReleaseFullScreenExclusiveModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkReleaseFullScreenExclusiveModeEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkReleaseFullScreenExclusiveModeEXT; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceGroupSurfacePresentModes2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pSurfaceInfo; + PointerDecoder pModes; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pSurfaceInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pModes.PreloadDecodeFlags((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDeviceGroupSurfacePresentModes2EXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceGroupSurfacePresentModes2EXT; + packet->call_info = call_info; + packet->device = device; + packet->pSurfaceInfo = pSurfaceInfo; + packet->pModes = pModes; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateHeadlessSurfaceEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateHeadlessSurfaceEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateHeadlessSurfaceEXT; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetLineStippleEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &lineStippleFactor); + bytes_read += ValueDecoder::DecodeUInt16Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &lineStipplePattern); + + Packet_vkCmdSetLineStippleEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetLineStippleEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->lineStippleFactor = lineStippleFactor; + packet->lineStipplePattern = lineStipplePattern; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkResetQueryPoolEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstQuery); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryCount); + + Packet_vkResetQueryPoolEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkResetQueryPoolEXT; + packet->call_info = call_info; + packet->device = device; + packet->queryPool = queryPool; + packet->firstQuery = firstQuery; + packet->queryCount = queryCount; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCullModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkCullModeFlags cullMode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &cullMode); + + Packet_vkCmdSetCullModeEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCullModeEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->cullMode = cullMode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetFrontFaceEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkFrontFace frontFace; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &frontFace); + + Packet_vkCmdSetFrontFaceEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetFrontFaceEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->frontFace = frontFace; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetPrimitiveTopologyEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPrimitiveTopology primitiveTopology; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &primitiveTopology); + + Packet_vkCmdSetPrimitiveTopologyEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetPrimitiveTopologyEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->primitiveTopology = primitiveTopology; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetViewportWithCountEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t viewportCount; + StructPointerDecoder pViewports; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &viewportCount); + bytes_read += pViewports.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetViewportWithCountEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetViewportWithCountEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->viewportCount = viewportCount; + packet->pViewports = pViewports; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetScissorWithCountEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t scissorCount; + StructPointerDecoder pScissors; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &scissorCount); + bytes_read += pScissors.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetScissorWithCountEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetScissorWithCountEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->scissorCount = scissorCount; + packet->pScissors = pScissors; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindVertexBuffers2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstBinding; + uint32_t bindingCount; + HandlePointerDecoder pBuffers; + PointerDecoder pOffsets; + PointerDecoder pSizes; + PointerDecoder pStrides; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstBinding); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindingCount); + bytes_read += pBuffers.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pOffsets.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSizes.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pStrides.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBindVertexBuffers2EXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindVertexBuffers2EXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstBinding = firstBinding; + packet->bindingCount = bindingCount; + packet->pBuffers = pBuffers; + packet->pOffsets = pOffsets; + packet->pSizes = pSizes; + packet->pStrides = pStrides; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthTestEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthTestEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthTestEnable); + + Packet_vkCmdSetDepthTestEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthTestEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthTestEnable = depthTestEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthWriteEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthWriteEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthWriteEnable); + + Packet_vkCmdSetDepthWriteEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthWriteEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthWriteEnable = depthWriteEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthCompareOpEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkCompareOp depthCompareOp; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthCompareOp); + + Packet_vkCmdSetDepthCompareOpEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthCompareOpEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthCompareOp = depthCompareOp; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthBoundsTestEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthBoundsTestEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthBoundsTestEnable); + + Packet_vkCmdSetDepthBoundsTestEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthBoundsTestEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthBoundsTestEnable = depthBoundsTestEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetStencilTestEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 stencilTestEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stencilTestEnable); + + Packet_vkCmdSetStencilTestEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetStencilTestEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->stencilTestEnable = stencilTestEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetStencilOpEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &faceMask); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &failOp); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &passOp); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthFailOp); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &compareOp); + + Packet_vkCmdSetStencilOpEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetStencilOpEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->faceMask = faceMask; + packet->failOp = failOp; + packet->passOp = passOp; + packet->depthFailOp = depthFailOp; + packet->compareOp = compareOp; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCopyMemoryToImageEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCopyMemoryToImageInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCopyMemoryToImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCopyMemoryToImageEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCopyMemoryToImageEXT; + packet->call_info = call_info; + packet->device = device; + packet->pCopyMemoryToImageInfo = pCopyMemoryToImageInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCopyImageToMemoryEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCopyImageToMemoryInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCopyImageToMemoryInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCopyImageToMemoryEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCopyImageToMemoryEXT; + packet->call_info = call_info; + packet->device = device; + packet->pCopyImageToMemoryInfo = pCopyImageToMemoryInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCopyImageToImageEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCopyImageToImageInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCopyImageToImageInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCopyImageToImageEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCopyImageToImageEXT; + packet->call_info = call_info; + packet->device = device; + packet->pCopyImageToImageInfo = pCopyImageToImageInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkTransitionImageLayoutEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t transitionCount; + StructPointerDecoder pTransitions; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &transitionCount); + bytes_read += pTransitions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkTransitionImageLayoutEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkTransitionImageLayoutEXT; + packet->call_info = call_info; + packet->device = device; + packet->transitionCount = transitionCount; + packet->pTransitions = pTransitions; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetImageSubresourceLayout2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId image; + StructPointerDecoder pSubresource; + StructPointerDecoder pLayout; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &image); + bytes_read += pSubresource.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pLayout.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetImageSubresourceLayout2EXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetImageSubresourceLayout2EXT; + packet->call_info = call_info; + packet->device = device; + packet->image = image; + packet->pSubresource = pSubresource; + packet->pLayout = pLayout; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkReleaseSwapchainImagesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pReleaseInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pReleaseInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkReleaseSwapchainImagesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkReleaseSwapchainImagesEXT; + packet->call_info = call_info; + packet->device = device; + packet->pReleaseInfo = pReleaseInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetGeneratedCommandsMemoryRequirementsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetGeneratedCommandsMemoryRequirementsNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetGeneratedCommandsMemoryRequirementsNV; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdPreprocessGeneratedCommandsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pGeneratedCommandsInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pGeneratedCommandsInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdPreprocessGeneratedCommandsNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdPreprocessGeneratedCommandsNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pGeneratedCommandsInfo = pGeneratedCommandsInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdExecuteGeneratedCommandsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 isPreprocessed; + StructPointerDecoder pGeneratedCommandsInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &isPreprocessed); + bytes_read += pGeneratedCommandsInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdExecuteGeneratedCommandsNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdExecuteGeneratedCommandsNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->isPreprocessed = isPreprocessed; + packet->pGeneratedCommandsInfo = pGeneratedCommandsInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindPipelineShaderGroupNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId pipeline; + uint32_t groupIndex; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineBindPoint); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupIndex); + + Packet_vkCmdBindPipelineShaderGroupNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindPipelineShaderGroupNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pipelineBindPoint = pipelineBindPoint; + packet->pipeline = pipeline; + packet->groupIndex = groupIndex; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateIndirectCommandsLayoutNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pIndirectCommandsLayout; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pIndirectCommandsLayout.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateIndirectCommandsLayoutNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateIndirectCommandsLayoutNV; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pIndirectCommandsLayout = pIndirectCommandsLayout; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyIndirectCommandsLayoutNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId indirectCommandsLayout; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indirectCommandsLayout); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyIndirectCommandsLayoutNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyIndirectCommandsLayoutNV; + packet->call_info = call_info; + packet->device = device; + packet->indirectCommandsLayout = indirectCommandsLayout; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthBias2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pDepthBiasInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pDepthBiasInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetDepthBias2EXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthBias2EXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pDepthBiasInfo = pDepthBiasInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAcquireDrmDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + int32_t drmFd; + format::HandleId display; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &drmFd); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAcquireDrmDisplayEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAcquireDrmDisplayEXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->drmFd = drmFd; + packet->display = display; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDrmDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + int32_t drmFd; + uint32_t connectorId; + HandlePointerDecoder display; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &drmFd); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &connectorId); + bytes_read += display.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDrmDisplayEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDrmDisplayEXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->drmFd = drmFd; + packet->connectorId = connectorId; + packet->display = display; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreatePrivateDataSlotEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPrivateDataSlot; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pPrivateDataSlot.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreatePrivateDataSlotEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreatePrivateDataSlotEXT; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pPrivateDataSlot = pPrivateDataSlot; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyPrivateDataSlotEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId privateDataSlot; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &privateDataSlot); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyPrivateDataSlotEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyPrivateDataSlotEXT; + packet->call_info = call_info; + packet->device = device; + packet->privateDataSlot = privateDataSlot; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetPrivateDataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkObjectType objectType; + uint64_t objectHandle; + format::HandleId privateDataSlot; + uint64_t data; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &objectType); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &objectHandle); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &privateDataSlot); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &data); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkSetPrivateDataEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetPrivateDataEXT; + packet->call_info = call_info; + packet->device = device; + packet->objectType = objectType; + packet->objectHandle = objectHandle; + packet->privateDataSlot = privateDataSlot; + packet->data = data; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPrivateDataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkObjectType objectType; + uint64_t objectHandle; + format::HandleId privateDataSlot; + PointerDecoder pData; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &objectType); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &objectHandle); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &privateDataSlot); + bytes_read += pData.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPrivateDataEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPrivateDataEXT; + packet->call_info = call_info; + packet->device = device; + packet->objectType = objectType; + packet->objectHandle = objectHandle; + packet->privateDataSlot = privateDataSlot; + packet->pData = pData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetFragmentShadingRateEnumNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkFragmentShadingRateNV shadingRate; + PointerDecoder combinerOps; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &shadingRate); + bytes_read += combinerOps.PreloadDecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetFragmentShadingRateEnumNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetFragmentShadingRateEnumNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->shadingRate = shadingRate; + packet->combinerOps = combinerOps; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceFaultInfoEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pFaultCounts; + StructPointerDecoder pFaultInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pFaultCounts.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFaultInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDeviceFaultInfoEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceFaultInfoEXT; + packet->call_info = call_info; + packet->device = device; + packet->pFaultCounts = pFaultCounts; + packet->pFaultInfo = pFaultInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkAcquireWinrtDisplayNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + format::HandleId display; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &display); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkAcquireWinrtDisplayNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkAcquireWinrtDisplayNV; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->display = display; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetWinrtDisplayNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t deviceRelativeId; + HandlePointerDecoder pDisplay; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &deviceRelativeId); + bytes_read += pDisplay.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetWinrtDisplayNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetWinrtDisplayNV; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->deviceRelativeId = deviceRelativeId; + packet->pDisplay = pDisplay; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateDirectFBSurfaceEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateDirectFBSurfaceEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateDirectFBSurfaceEXT; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t dfb; + VkBool32 return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueFamilyIndex); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dfb); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceDirectFBPresentationSupportEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceDirectFBPresentationSupportEXT; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->queueFamilyIndex = queueFamilyIndex; + packet->dfb = dfb; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetVertexInputEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t vertexBindingDescriptionCount; + StructPointerDecoder pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + StructPointerDecoder pVertexAttributeDescriptions; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &vertexBindingDescriptionCount); + bytes_read += pVertexBindingDescriptions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &vertexAttributeDescriptionCount); + bytes_read += pVertexAttributeDescriptions.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetVertexInputEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetVertexInputEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->vertexBindingDescriptionCount = vertexBindingDescriptionCount; + packet->pVertexBindingDescriptions = pVertexBindingDescriptions; + packet->vertexAttributeDescriptionCount = vertexAttributeDescriptionCount; + packet->pVertexAttributeDescriptions = pVertexAttributeDescriptions; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryZirconHandleFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pGetZirconHandleInfo; + PointerDecoder pZirconHandle; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pGetZirconHandleInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pZirconHandle.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryZirconHandleFUCHSIA* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryZirconHandleFUCHSIA; + packet->call_info = call_info; + packet->device = device; + packet->pGetZirconHandleInfo = pGetZirconHandleInfo; + packet->pZirconHandle = pZirconHandle; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryZirconHandlePropertiesFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkExternalMemoryHandleTypeFlagBits handleType; + uint32_t zirconHandle; + StructPointerDecoder pMemoryZirconHandleProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &handleType); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &zirconHandle); + bytes_read += pMemoryZirconHandleProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryZirconHandlePropertiesFUCHSIA* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryZirconHandlePropertiesFUCHSIA; + packet->call_info = call_info; + packet->device = device; + packet->handleType = handleType; + packet->zirconHandle = zirconHandle; + packet->pMemoryZirconHandleProperties = pMemoryZirconHandleProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkImportSemaphoreZirconHandleFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pImportSemaphoreZirconHandleInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pImportSemaphoreZirconHandleInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkImportSemaphoreZirconHandleFUCHSIA* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkImportSemaphoreZirconHandleFUCHSIA; + packet->call_info = call_info; + packet->device = device; + packet->pImportSemaphoreZirconHandleInfo = pImportSemaphoreZirconHandleInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetSemaphoreZirconHandleFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pGetZirconHandleInfo; + PointerDecoder pZirconHandle; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pGetZirconHandleInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pZirconHandle.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetSemaphoreZirconHandleFUCHSIA* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetSemaphoreZirconHandleFUCHSIA; + packet->call_info = call_info; + packet->device = device; + packet->pGetZirconHandleInfo = pGetZirconHandleInfo; + packet->pZirconHandle = pZirconHandle; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindInvocationMaskHUAWEI(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId imageView; + VkImageLayout imageLayout; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageView); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &imageLayout); + + Packet_vkCmdBindInvocationMaskHUAWEI* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindInvocationMaskHUAWEI; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->imageView = imageView; + packet->imageLayout = imageLayout; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMemoryRemoteAddressNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pMemoryGetRemoteAddressInfo; + PointerDecoder pAddress; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pMemoryGetRemoteAddressInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAddress.DecodeVoidPtr((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetMemoryRemoteAddressNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMemoryRemoteAddressNV; + packet->call_info = call_info; + packet->device = device; + packet->pMemoryGetRemoteAddressInfo = pMemoryGetRemoteAddressInfo; + packet->pAddress = pAddress; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetPatchControlPointsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t patchControlPoints; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &patchControlPoints); + + Packet_vkCmdSetPatchControlPointsEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetPatchControlPointsEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->patchControlPoints = patchControlPoints; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetRasterizerDiscardEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 rasterizerDiscardEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &rasterizerDiscardEnable); + + Packet_vkCmdSetRasterizerDiscardEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetRasterizerDiscardEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->rasterizerDiscardEnable = rasterizerDiscardEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthBiasEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthBiasEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthBiasEnable); + + Packet_vkCmdSetDepthBiasEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthBiasEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthBiasEnable = depthBiasEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetLogicOpEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkLogicOp logicOp; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &logicOp); + + Packet_vkCmdSetLogicOpEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetLogicOpEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->logicOp = logicOp; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetPrimitiveRestartEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 primitiveRestartEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &primitiveRestartEnable); + + Packet_vkCmdSetPrimitiveRestartEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetPrimitiveRestartEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->primitiveRestartEnable = primitiveRestartEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateScreenSurfaceQNX(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instance); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSurface.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateScreenSurfaceQNX* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateScreenSurfaceQNX; + packet->call_info = call_info; + packet->instance = instance; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSurface = pSurface; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceScreenPresentationSupportQNX(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t window; + VkBool32 return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queueFamilyIndex); + bytes_read += ValueDecoder::DecodeAddress((parameter_buffer + bytes_read), (buffer_size - bytes_read), &window); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceScreenPresentationSupportQNX* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceScreenPresentationSupportQNX; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->queueFamilyIndex = queueFamilyIndex; + packet->window = window; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetColorWriteEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t attachmentCount; + PointerDecoder pColorWriteEnables; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &attachmentCount); + bytes_read += pColorWriteEnables.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetColorWriteEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetColorWriteEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->attachmentCount = attachmentCount; + packet->pColorWriteEnables = pColorWriteEnables; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawMultiEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t drawCount; + StructPointerDecoder pVertexInfo; + uint32_t instanceCount; + uint32_t firstInstance; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &drawCount); + bytes_read += pVertexInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instanceCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstInstance); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawMultiEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawMultiEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->drawCount = drawCount; + packet->pVertexInfo = pVertexInfo; + packet->instanceCount = instanceCount; + packet->firstInstance = firstInstance; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawMultiIndexedEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t drawCount; + StructPointerDecoder pIndexInfo; + uint32_t instanceCount; + uint32_t firstInstance; + uint32_t stride; + PointerDecoder pVertexOffset; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &drawCount); + bytes_read += pIndexInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &instanceCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstInstance); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + bytes_read += pVertexOffset.PreloadDecodeInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdDrawMultiIndexedEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawMultiIndexedEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->drawCount = drawCount; + packet->pIndexInfo = pIndexInfo; + packet->instanceCount = instanceCount; + packet->firstInstance = firstInstance; + packet->stride = stride; + packet->pVertexOffset = pVertexOffset; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pMicromap; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMicromap.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateMicromapEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateMicromapEXT; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pMicromap = pMicromap; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId micromap; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), µmap); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyMicromapEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyMicromapEXT; + packet->call_info = call_info; + packet->device = device; + packet->micromap = micromap; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBuildMicromapsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t infoCount; + StructPointerDecoder pInfos; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &infoCount); + bytes_read += pInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBuildMicromapsEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBuildMicromapsEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->infoCount = infoCount; + packet->pInfos = pInfos; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBuildMicromapsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId deferredOperation; + uint32_t infoCount; + StructPointerDecoder pInfos; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &deferredOperation); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &infoCount); + bytes_read += pInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBuildMicromapsEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBuildMicromapsEXT; + packet->call_info = call_info; + packet->device = device; + packet->deferredOperation = deferredOperation; + packet->infoCount = infoCount; + packet->pInfos = pInfos; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCopyMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &deferredOperation); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCopyMicromapEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCopyMicromapEXT; + packet->call_info = call_info; + packet->device = device; + packet->deferredOperation = deferredOperation; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCopyMicromapToMemoryEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &deferredOperation); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCopyMicromapToMemoryEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCopyMicromapToMemoryEXT; + packet->call_info = call_info; + packet->device = device; + packet->deferredOperation = deferredOperation; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCopyMemoryToMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &deferredOperation); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCopyMemoryToMicromapEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCopyMemoryToMicromapEXT; + packet->call_info = call_info; + packet->device = device; + packet->deferredOperation = deferredOperation; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkWriteMicromapsPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t micromapCount; + HandlePointerDecoder pMicromaps; + VkQueryType queryType; + size_t dataSize; + PointerDecoder pData; + size_t stride; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), µmapCount); + bytes_read += pMicromaps.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryType); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dataSize); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkWriteMicromapsPropertiesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkWriteMicromapsPropertiesEXT; + packet->call_info = call_info; + packet->device = device; + packet->micromapCount = micromapCount; + packet->pMicromaps = pMicromaps; + packet->queryType = queryType; + packet->dataSize = dataSize; + packet->pData = pData; + packet->stride = stride; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyMicromapEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyMicromapEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pInfo = pInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyMicromapToMemoryEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyMicromapToMemoryEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyMicromapToMemoryEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pInfo = pInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyMemoryToMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyMemoryToMicromapEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyMemoryToMicromapEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pInfo = pInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWriteMicromapsPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t micromapCount; + HandlePointerDecoder pMicromaps; + VkQueryType queryType; + format::HandleId queryPool; + uint32_t firstQuery; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), µmapCount); + bytes_read += pMicromaps.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryType); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstQuery); + + Packet_vkCmdWriteMicromapsPropertiesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWriteMicromapsPropertiesEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->micromapCount = micromapCount; + packet->pMicromaps = pMicromaps; + packet->queryType = queryType; + packet->queryPool = queryPool; + packet->firstQuery = firstQuery; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceMicromapCompatibilityEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pVersionInfo; + PointerDecoder pCompatibility; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pVersionInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCompatibility.PreloadDecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceMicromapCompatibilityEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceMicromapCompatibilityEXT; + packet->call_info = call_info; + packet->device = device; + packet->pVersionInfo = pVersionInfo; + packet->pCompatibility = pCompatibility; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetMicromapBuildSizesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkAccelerationStructureBuildTypeKHR buildType; + StructPointerDecoder pBuildInfo; + StructPointerDecoder pSizeInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buildType); + bytes_read += pBuildInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSizeInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetMicromapBuildSizesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetMicromapBuildSizesEXT; + packet->call_info = call_info; + packet->device = device; + packet->buildType = buildType; + packet->pBuildInfo = pBuildInfo; + packet->pSizeInfo = pSizeInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawClusterHUAWEI(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountX); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountY); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountZ); + + Packet_vkCmdDrawClusterHUAWEI* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawClusterHUAWEI; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->groupCountX = groupCountX; + packet->groupCountY = groupCountY; + packet->groupCountZ = groupCountZ; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawClusterIndirectHUAWEI(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + + Packet_vkCmdDrawClusterIndirectHUAWEI* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawClusterIndirectHUAWEI; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetDeviceMemoryPriorityEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId memory; + float priority; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &memory); + bytes_read += ValueDecoder::DecodeFloatValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &priority); + + Packet_vkSetDeviceMemoryPriorityEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetDeviceMemoryPriorityEXT; + packet->call_info = call_info; + packet->device = device; + packet->memory = memory; + packet->priority = priority; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDescriptorSetLayoutHostMappingInfoVALVE(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pBindingReference; + StructPointerDecoder pHostMapping; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pBindingReference.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pHostMapping.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDescriptorSetLayoutHostMappingInfoVALVE* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDescriptorSetLayoutHostMappingInfoVALVE; + packet->call_info = call_info; + packet->device = device; + packet->pBindingReference = pBindingReference; + packet->pHostMapping = pHostMapping; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDescriptorSetHostMappingVALVE(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId descriptorSet; + PointerDecoder ppData; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &descriptorSet); + bytes_read += ppData.DecodeVoidPtr((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDescriptorSetHostMappingVALVE* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDescriptorSetHostMappingVALVE; + packet->call_info = call_info; + packet->device = device; + packet->descriptorSet = descriptorSet; + packet->ppData = ppData; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPipelineIndirectMemoryRequirementsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetPipelineIndirectMemoryRequirementsNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPipelineIndirectMemoryRequirementsNV; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pMemoryRequirements = pMemoryRequirements; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdUpdatePipelineIndirectBufferNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId pipeline; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineBindPoint); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + + Packet_vkCmdUpdatePipelineIndirectBufferNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdUpdatePipelineIndirectBufferNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pipelineBindPoint = pipelineBindPoint; + packet->pipeline = pipeline; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPipelineIndirectDeviceAddressNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + VkDeviceAddress return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPipelineIndirectDeviceAddressNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPipelineIndirectDeviceAddressNV; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthClampEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthClampEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthClampEnable); + + Packet_vkCmdSetDepthClampEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthClampEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthClampEnable = depthClampEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetPolygonModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkPolygonMode polygonMode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &polygonMode); + + Packet_vkCmdSetPolygonModeEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetPolygonModeEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->polygonMode = polygonMode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetRasterizationSamplesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkSampleCountFlagBits rasterizationSamples; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &rasterizationSamples); + + Packet_vkCmdSetRasterizationSamplesEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetRasterizationSamplesEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->rasterizationSamples = rasterizationSamples; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetSampleMaskEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkSampleCountFlagBits samples; + PointerDecoder pSampleMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &samples); + bytes_read += pSampleMask.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetSampleMaskEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetSampleMaskEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->samples = samples; + packet->pSampleMask = pSampleMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetAlphaToCoverageEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 alphaToCoverageEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &alphaToCoverageEnable); + + Packet_vkCmdSetAlphaToCoverageEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetAlphaToCoverageEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->alphaToCoverageEnable = alphaToCoverageEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetAlphaToOneEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 alphaToOneEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &alphaToOneEnable); + + Packet_vkCmdSetAlphaToOneEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetAlphaToOneEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->alphaToOneEnable = alphaToOneEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetLogicOpEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 logicOpEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &logicOpEnable); + + Packet_vkCmdSetLogicOpEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetLogicOpEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->logicOpEnable = logicOpEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetColorBlendEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstAttachment; + uint32_t attachmentCount; + PointerDecoder pColorBlendEnables; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstAttachment); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &attachmentCount); + bytes_read += pColorBlendEnables.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetColorBlendEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetColorBlendEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstAttachment = firstAttachment; + packet->attachmentCount = attachmentCount; + packet->pColorBlendEnables = pColorBlendEnables; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetColorBlendEquationEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstAttachment; + uint32_t attachmentCount; + StructPointerDecoder pColorBlendEquations; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstAttachment); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &attachmentCount); + bytes_read += pColorBlendEquations.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetColorBlendEquationEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetColorBlendEquationEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstAttachment = firstAttachment; + packet->attachmentCount = attachmentCount; + packet->pColorBlendEquations = pColorBlendEquations; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetColorWriteMaskEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstAttachment; + uint32_t attachmentCount; + PointerDecoder pColorWriteMasks; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstAttachment); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &attachmentCount); + bytes_read += pColorWriteMasks.PreloadDecodeFlags((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetColorWriteMaskEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetColorWriteMaskEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstAttachment = firstAttachment; + packet->attachmentCount = attachmentCount; + packet->pColorWriteMasks = pColorWriteMasks; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetTessellationDomainOriginEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkTessellationDomainOrigin domainOrigin; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &domainOrigin); + + Packet_vkCmdSetTessellationDomainOriginEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetTessellationDomainOriginEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->domainOrigin = domainOrigin; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetRasterizationStreamEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t rasterizationStream; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &rasterizationStream); + + Packet_vkCmdSetRasterizationStreamEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetRasterizationStreamEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->rasterizationStream = rasterizationStream; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetConservativeRasterizationModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &conservativeRasterizationMode); + + Packet_vkCmdSetConservativeRasterizationModeEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetConservativeRasterizationModeEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->conservativeRasterizationMode = conservativeRasterizationMode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetExtraPrimitiveOverestimationSizeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + float extraPrimitiveOverestimationSize; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFloatValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &extraPrimitiveOverestimationSize); + + Packet_vkCmdSetExtraPrimitiveOverestimationSizeEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetExtraPrimitiveOverestimationSizeEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthClipEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 depthClipEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthClipEnable); + + Packet_vkCmdSetDepthClipEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthClipEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->depthClipEnable = depthClipEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetSampleLocationsEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 sampleLocationsEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &sampleLocationsEnable); + + Packet_vkCmdSetSampleLocationsEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetSampleLocationsEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->sampleLocationsEnable = sampleLocationsEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetColorBlendAdvancedEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstAttachment; + uint32_t attachmentCount; + StructPointerDecoder pColorBlendAdvanced; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstAttachment); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &attachmentCount); + bytes_read += pColorBlendAdvanced.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetColorBlendAdvancedEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetColorBlendAdvancedEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstAttachment = firstAttachment; + packet->attachmentCount = attachmentCount; + packet->pColorBlendAdvanced = pColorBlendAdvanced; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetProvokingVertexModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkProvokingVertexModeEXT provokingVertexMode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &provokingVertexMode); + + Packet_vkCmdSetProvokingVertexModeEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetProvokingVertexModeEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->provokingVertexMode = provokingVertexMode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetLineRasterizationModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkLineRasterizationModeEXT lineRasterizationMode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &lineRasterizationMode); + + Packet_vkCmdSetLineRasterizationModeEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetLineRasterizationModeEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->lineRasterizationMode = lineRasterizationMode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetLineStippleEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 stippledLineEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stippledLineEnable); + + Packet_vkCmdSetLineStippleEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetLineStippleEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->stippledLineEnable = stippledLineEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetDepthClipNegativeOneToOneEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 negativeOneToOne; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &negativeOneToOne); + + Packet_vkCmdSetDepthClipNegativeOneToOneEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetDepthClipNegativeOneToOneEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->negativeOneToOne = negativeOneToOne; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetViewportWScalingEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 viewportWScalingEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &viewportWScalingEnable); + + Packet_vkCmdSetViewportWScalingEnableNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetViewportWScalingEnableNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->viewportWScalingEnable = viewportWScalingEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetViewportSwizzleNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t firstViewport; + uint32_t viewportCount; + StructPointerDecoder pViewportSwizzles; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstViewport); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &viewportCount); + bytes_read += pViewportSwizzles.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetViewportSwizzleNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetViewportSwizzleNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->firstViewport = firstViewport; + packet->viewportCount = viewportCount; + packet->pViewportSwizzles = pViewportSwizzles; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCoverageToColorEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 coverageToColorEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &coverageToColorEnable); + + Packet_vkCmdSetCoverageToColorEnableNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCoverageToColorEnableNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->coverageToColorEnable = coverageToColorEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCoverageToColorLocationNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t coverageToColorLocation; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &coverageToColorLocation); + + Packet_vkCmdSetCoverageToColorLocationNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCoverageToColorLocationNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->coverageToColorLocation = coverageToColorLocation; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCoverageModulationModeNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkCoverageModulationModeNV coverageModulationMode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &coverageModulationMode); + + Packet_vkCmdSetCoverageModulationModeNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCoverageModulationModeNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->coverageModulationMode = coverageModulationMode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCoverageModulationTableEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 coverageModulationTableEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &coverageModulationTableEnable); + + Packet_vkCmdSetCoverageModulationTableEnableNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCoverageModulationTableEnableNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->coverageModulationTableEnable = coverageModulationTableEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCoverageModulationTableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t coverageModulationTableCount; + PointerDecoder pCoverageModulationTable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &coverageModulationTableCount); + bytes_read += pCoverageModulationTable.PreloadDecodeFloat((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdSetCoverageModulationTableNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCoverageModulationTableNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->coverageModulationTableCount = coverageModulationTableCount; + packet->pCoverageModulationTable = pCoverageModulationTable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetShadingRateImageEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 shadingRateImageEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &shadingRateImageEnable); + + Packet_vkCmdSetShadingRateImageEnableNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetShadingRateImageEnableNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->shadingRateImageEnable = shadingRateImageEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetRepresentativeFragmentTestEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 representativeFragmentTestEnable; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &representativeFragmentTestEnable); + + Packet_vkCmdSetRepresentativeFragmentTestEnableNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetRepresentativeFragmentTestEnableNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->representativeFragmentTestEnable = representativeFragmentTestEnable; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetCoverageReductionModeNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkCoverageReductionModeNV coverageReductionMode; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &coverageReductionMode); + + Packet_vkCmdSetCoverageReductionModeNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetCoverageReductionModeNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->coverageReductionMode = coverageReductionMode; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetShaderModuleIdentifierEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId shaderModule; + StructPointerDecoder pIdentifier; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &shaderModule); + bytes_read += pIdentifier.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetShaderModuleIdentifierEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetShaderModuleIdentifierEXT; + packet->call_info = call_info; + packet->device = device; + packet->shaderModule = shaderModule; + packet->pIdentifier = pIdentifier; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetShaderModuleCreateInfoIdentifierEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pIdentifier; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pIdentifier.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetShaderModuleCreateInfoIdentifierEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetShaderModuleCreateInfoIdentifierEXT; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pIdentifier = pIdentifier; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + StructPointerDecoder pOpticalFlowImageFormatInfo; + PointerDecoder pFormatCount; + StructPointerDecoder pImageFormatProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pOpticalFlowImageFormatInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pFormatCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pImageFormatProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetPhysicalDeviceOpticalFlowImageFormatsNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetPhysicalDeviceOpticalFlowImageFormatsNV; + packet->call_info = call_info; + packet->physicalDevice = physicalDevice; + packet->pOpticalFlowImageFormatInfo = pOpticalFlowImageFormatInfo; + packet->pFormatCount = pFormatCount; + packet->pImageFormatProperties = pImageFormatProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateOpticalFlowSessionNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSession; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSession.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateOpticalFlowSessionNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateOpticalFlowSessionNV; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pSession = pSession; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyOpticalFlowSessionNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId session; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &session); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyOpticalFlowSessionNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyOpticalFlowSessionNV; + packet->call_info = call_info; + packet->device = device; + packet->session = session; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkBindOpticalFlowSessionImageNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId session; + VkOpticalFlowSessionBindingPointNV bindingPoint; + format::HandleId view; + VkImageLayout layout; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &session); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &bindingPoint); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &view); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &layout); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkBindOpticalFlowSessionImageNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkBindOpticalFlowSessionImageNV; + packet->call_info = call_info; + packet->device = device; + packet->session = session; + packet->bindingPoint = bindingPoint; + packet->view = view; + packet->layout = layout; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdOpticalFlowExecuteNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId session; + StructPointerDecoder pExecuteInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &session); + bytes_read += pExecuteInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdOpticalFlowExecuteNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdOpticalFlowExecuteNV; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->session = session; + packet->pExecuteInfo = pExecuteInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateShadersEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pShaders; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &createInfoCount); + bytes_read += pCreateInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pShaders.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateShadersEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateShadersEXT; + packet->call_info = call_info; + packet->device = device; + packet->createInfoCount = createInfoCount; + packet->pCreateInfos = pCreateInfos; + packet->pAllocator = pAllocator; + packet->pShaders = pShaders; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyShaderEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId shader; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &shader); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyShaderEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyShaderEXT; + packet->call_info = call_info; + packet->device = device; + packet->shader = shader; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetShaderBinaryDataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId shader; + PointerDecoder pDataSize; + PointerDecoder pData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &shader); + bytes_read += pDataSize.PreloadDecodeSizeT((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetShaderBinaryDataEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetShaderBinaryDataEXT; + packet->call_info = call_info; + packet->device = device; + packet->shader = shader; + packet->pDataSize = pDataSize; + packet->pData = pData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBindShadersEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t stageCount; + PointerDecoder pStages; + HandlePointerDecoder pShaders; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stageCount); + bytes_read += pStages.PreloadDecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pShaders.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBindShadersEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBindShadersEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->stageCount = stageCount; + packet->pStages = pStages; + packet->pShaders = pShaders; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetFramebufferTilePropertiesQCOM(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId framebuffer; + PointerDecoder pPropertiesCount; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &framebuffer); + bytes_read += pPropertiesCount.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetFramebufferTilePropertiesQCOM* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetFramebufferTilePropertiesQCOM; + packet->call_info = call_info; + packet->device = device; + packet->framebuffer = framebuffer; + packet->pPropertiesCount = pPropertiesCount; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDynamicRenderingTilePropertiesQCOM(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pRenderingInfo; + StructPointerDecoder pProperties; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pRenderingInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pProperties.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetDynamicRenderingTilePropertiesQCOM* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDynamicRenderingTilePropertiesQCOM; + packet->call_info = call_info; + packet->device = device; + packet->pRenderingInfo = pRenderingInfo; + packet->pProperties = pProperties; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetLatencySleepModeNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pSleepModeInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += pSleepModeInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkSetLatencySleepModeNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetLatencySleepModeNV; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->pSleepModeInfo = pSleepModeInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkLatencySleepNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pSleepInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += pSleepInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkLatencySleepNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkLatencySleepNV; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->pSleepInfo = pSleepInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkSetLatencyMarkerNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pLatencyMarkerInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += pLatencyMarkerInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkSetLatencyMarkerNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkSetLatencyMarkerNV; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->pLatencyMarkerInfo = pLatencyMarkerInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetLatencyTimingsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pLatencyMarkerInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &swapchain); + bytes_read += pLatencyMarkerInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetLatencyTimingsNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetLatencyTimingsNV; + packet->call_info = call_info; + packet->device = device; + packet->swapchain = swapchain; + packet->pLatencyMarkerInfo = pLatencyMarkerInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkQueueNotifyOutOfBandNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId queue; + StructPointerDecoder pQueueTypeInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queue); + bytes_read += pQueueTypeInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkQueueNotifyOutOfBandNV* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkQueueNotifyOutOfBandNV; + packet->call_info = call_info; + packet->queue = queue; + packet->pQueueTypeInfo = pQueueTypeInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetAttachmentFeedbackLoopEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkImageAspectFlags aspectMask; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeFlagsValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &aspectMask); + + Packet_vkCmdSetAttachmentFeedbackLoopEnableEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetAttachmentFeedbackLoopEnableEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->aspectMask = aspectMask; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCreateAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pAccelerationStructure; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAccelerationStructure.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCreateAccelerationStructureKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCreateAccelerationStructureKHR; + packet->call_info = call_info; + packet->device = device; + packet->pCreateInfo = pCreateInfo; + packet->pAllocator = pAllocator; + packet->pAccelerationStructure = pAccelerationStructure; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkDestroyAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId accelerationStructure; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &accelerationStructure); + bytes_read += pAllocator.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkDestroyAccelerationStructureKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkDestroyAccelerationStructureKHR; + packet->call_info = call_info; + packet->device = device; + packet->accelerationStructure = accelerationStructure; + packet->pAllocator = pAllocator; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBuildAccelerationStructuresKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t infoCount; + StructPointerDecoder pInfos; + StructPointerDecoder ppBuildRangeInfos; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &infoCount); + bytes_read += pInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ppBuildRangeInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBuildAccelerationStructuresKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBuildAccelerationStructuresKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->infoCount = infoCount; + packet->pInfos = pInfos; + packet->ppBuildRangeInfos = ppBuildRangeInfos; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdBuildAccelerationStructuresIndirectKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t infoCount; + StructPointerDecoder pInfos; + PointerDecoder pIndirectDeviceAddresses; + PointerDecoder pIndirectStrides; + PointerDecoder ppMaxPrimitiveCounts; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &infoCount); + bytes_read += pInfos.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pIndirectDeviceAddresses.PreloadDecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pIndirectStrides.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ppMaxPrimitiveCounts.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdBuildAccelerationStructuresIndirectKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdBuildAccelerationStructuresIndirectKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->infoCount = infoCount; + packet->pInfos = pInfos; + packet->pIndirectDeviceAddresses = pIndirectDeviceAddresses; + packet->pIndirectStrides = pIndirectStrides; + packet->ppMaxPrimitiveCounts = ppMaxPrimitiveCounts; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCopyAccelerationStructureToMemoryKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &deferredOperation); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCopyAccelerationStructureToMemoryKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCopyAccelerationStructureToMemoryKHR; + packet->call_info = call_info; + packet->device = device; + packet->deferredOperation = deferredOperation; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCopyMemoryToAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &deferredOperation); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkCopyMemoryToAccelerationStructureKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCopyMemoryToAccelerationStructureKHR; + packet->call_info = call_info; + packet->device = device; + packet->deferredOperation = deferredOperation; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkWriteAccelerationStructuresPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t accelerationStructureCount; + HandlePointerDecoder pAccelerationStructures; + VkQueryType queryType; + size_t dataSize; + PointerDecoder pData; + size_t stride; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &accelerationStructureCount); + bytes_read += pAccelerationStructures.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryType); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dataSize); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkWriteAccelerationStructuresPropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkWriteAccelerationStructuresPropertiesKHR; + packet->call_info = call_info; + packet->device = device; + packet->accelerationStructureCount = accelerationStructureCount; + packet->pAccelerationStructures = pAccelerationStructures; + packet->queryType = queryType; + packet->dataSize = dataSize; + packet->pData = pData; + packet->stride = stride; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyAccelerationStructureKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyAccelerationStructureKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pInfo = pInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyAccelerationStructureToMemoryKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyAccelerationStructureToMemoryKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyAccelerationStructureToMemoryKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pInfo = pInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdCopyMemoryToAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkCmdCopyMemoryToAccelerationStructureKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdCopyMemoryToAccelerationStructureKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pInfo = pInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetAccelerationStructureDeviceAddressKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + VkDeviceAddress return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetAccelerationStructureDeviceAddressKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetAccelerationStructureDeviceAddressKHR; + packet->call_info = call_info; + packet->device = device; + packet->pInfo = pInfo; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdWriteAccelerationStructuresPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t accelerationStructureCount; + HandlePointerDecoder pAccelerationStructures; + VkQueryType queryType; + format::HandleId queryPool; + uint32_t firstQuery; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &accelerationStructureCount); + bytes_read += pAccelerationStructures.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryType); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &queryPool); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstQuery); + + Packet_vkCmdWriteAccelerationStructuresPropertiesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdWriteAccelerationStructuresPropertiesKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->accelerationStructureCount = accelerationStructureCount; + packet->pAccelerationStructures = pAccelerationStructures; + packet->queryType = queryType; + packet->queryPool = queryPool; + packet->firstQuery = firstQuery; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetDeviceAccelerationStructureCompatibilityKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pVersionInfo; + PointerDecoder pCompatibility; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pVersionInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCompatibility.PreloadDecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetDeviceAccelerationStructureCompatibilityKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetDeviceAccelerationStructureCompatibilityKHR; + packet->call_info = call_info; + packet->device = device; + packet->pVersionInfo = pVersionInfo; + packet->pCompatibility = pCompatibility; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetAccelerationStructureBuildSizesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + VkAccelerationStructureBuildTypeKHR buildType; + StructPointerDecoder pBuildInfo; + PointerDecoder pMaxPrimitiveCounts; + StructPointerDecoder pSizeInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buildType); + bytes_read += pBuildInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMaxPrimitiveCounts.PreloadDecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pSizeInfo.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + Packet_vkGetAccelerationStructureBuildSizesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetAccelerationStructureBuildSizesKHR; + packet->call_info = call_info; + packet->device = device; + packet->buildType = buildType; + packet->pBuildInfo = pBuildInfo; + packet->pMaxPrimitiveCounts = pMaxPrimitiveCounts; + packet->pSizeInfo = pSizeInfo; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdTraceRaysKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pRaygenShaderBindingTable; + StructPointerDecoder pMissShaderBindingTable; + StructPointerDecoder pHitShaderBindingTable; + StructPointerDecoder pCallableShaderBindingTable; + uint32_t width; + uint32_t height; + uint32_t depth; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pRaygenShaderBindingTable.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMissShaderBindingTable.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pHitShaderBindingTable.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCallableShaderBindingTable.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &width); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &height); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depth); + + Packet_vkCmdTraceRaysKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdTraceRaysKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pRaygenShaderBindingTable = pRaygenShaderBindingTable; + packet->pMissShaderBindingTable = pMissShaderBindingTable; + packet->pHitShaderBindingTable = pHitShaderBindingTable; + packet->pCallableShaderBindingTable = pCallableShaderBindingTable; + packet->width = width; + packet->height = height; + packet->depth = depth; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipeline; + uint32_t firstGroup; + uint32_t groupCount; + size_t dataSize; + PointerDecoder pData; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &firstGroup); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCount); + bytes_read += ValueDecoder::DecodeSizeTValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &dataSize); + bytes_read += pData.PreloadDecodeVoid((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; + packet->call_info = call_info; + packet->device = device; + packet->pipeline = pipeline; + packet->firstGroup = firstGroup; + packet->groupCount = groupCount; + packet->dataSize = dataSize; + packet->pData = pData; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdTraceRaysIndirectKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pRaygenShaderBindingTable; + StructPointerDecoder pMissShaderBindingTable; + StructPointerDecoder pHitShaderBindingTable; + StructPointerDecoder pCallableShaderBindingTable; + VkDeviceAddress indirectDeviceAddress; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pRaygenShaderBindingTable.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMissShaderBindingTable.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pHitShaderBindingTable.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pCallableShaderBindingTable.PreloadDecode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indirectDeviceAddress); + + Packet_vkCmdTraceRaysIndirectKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdTraceRaysIndirectKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pRaygenShaderBindingTable = pRaygenShaderBindingTable; + packet->pMissShaderBindingTable = pMissShaderBindingTable; + packet->pHitShaderBindingTable = pHitShaderBindingTable; + packet->pCallableShaderBindingTable = pCallableShaderBindingTable; + packet->indirectDeviceAddress = indirectDeviceAddress; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkGetRayTracingShaderGroupStackSizeKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId pipeline; + uint32_t group; + VkShaderGroupShaderKHR groupShader; + VkDeviceSize return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipeline); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &group); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupShader); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + Packet_vkGetRayTracingShaderGroupStackSizeKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkGetRayTracingShaderGroupStackSizeKHR; + packet->call_info = call_info; + packet->device = device; + packet->pipeline = pipeline; + packet->group = group; + packet->groupShader = groupShader; + packet->return_value = return_value; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdSetRayTracingPipelineStackSizeKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t pipelineStackSize; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &pipelineStackSize); + + Packet_vkCmdSetRayTracingPipelineStackSizeKHR* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdSetRayTracingPipelineStackSizeKHR; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->pipelineStackSize = pipelineStackSize; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawMeshTasksEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountX); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountY); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &groupCountZ); + + Packet_vkCmdDrawMeshTasksEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawMeshTasksEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->groupCountX = groupCountX; + packet->groupCountY = groupCountY; + packet->groupCountZ = groupCountZ; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawMeshTasksIndirectEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + uint32_t drawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &drawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawMeshTasksIndirectEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawMeshTasksIndirectEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->drawCount = drawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +size_t VulkanPreloadDecoder::Decode_vkCmdDrawMeshTasksIndirectCountEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &buffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &countBufferOffset); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &maxDrawCount); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stride); + + Packet_vkCmdDrawMeshTasksIndirectCountEXT* packet = PreloadDecodeAllocator::Allocate(); + packet->packet_id = gfxrecon::format::PacketCall_vkCmdDrawMeshTasksIndirectCountEXT; + packet->call_info = call_info; + packet->commandBuffer = commandBuffer; + packet->buffer = buffer; + packet->offset = offset; + packet->countBuffer = countBuffer; + packet->countBufferOffset = countBufferOffset; + packet->maxDrawCount = maxDrawCount; + packet->stride = stride; + + AddPacket(reinterpret_cast(packet)); + + return bytes_read; +} + +void VulkanPreloadDecoder::DecodeFunctionCall(format::ApiCallId call_id, + const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size) +{ + switch(call_id) + { + default: + VulkanPreloadDecoderBase::DecodeFunctionCall(call_id, call_info, parameter_buffer, buffer_size); + break; + + case format::ApiCallId::ApiCall_vkCreateInstance: + Decode_vkCreateInstance(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyInstance: + Decode_vkDestroyInstance(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkEnumeratePhysicalDevices: + Decode_vkEnumeratePhysicalDevices(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceFeatures: + Decode_vkGetPhysicalDeviceFeatures(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceFormatProperties: + Decode_vkGetPhysicalDeviceFormatProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceImageFormatProperties: + Decode_vkGetPhysicalDeviceImageFormatProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceProperties: + Decode_vkGetPhysicalDeviceProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceQueueFamilyProperties: + Decode_vkGetPhysicalDeviceQueueFamilyProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceMemoryProperties: + Decode_vkGetPhysicalDeviceMemoryProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDevice: + Decode_vkCreateDevice(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyDevice: + Decode_vkDestroyDevice(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceQueue: + Decode_vkGetDeviceQueue(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueSubmit: + Decode_vkQueueSubmit(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueWaitIdle: + Decode_vkQueueWaitIdle(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDeviceWaitIdle: + Decode_vkDeviceWaitIdle(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAllocateMemory: + Decode_vkAllocateMemory(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkFreeMemory: + Decode_vkFreeMemory(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkMapMemory: + Decode_vkMapMemory(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkUnmapMemory: + Decode_vkUnmapMemory(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkFlushMappedMemoryRanges: + Decode_vkFlushMappedMemoryRanges(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkInvalidateMappedMemoryRanges: + Decode_vkInvalidateMappedMemoryRanges(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceMemoryCommitment: + Decode_vkGetDeviceMemoryCommitment(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBindBufferMemory: + Decode_vkBindBufferMemory(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBindImageMemory: + Decode_vkBindImageMemory(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetBufferMemoryRequirements: + Decode_vkGetBufferMemoryRequirements(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageMemoryRequirements: + Decode_vkGetImageMemoryRequirements(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageSparseMemoryRequirements: + Decode_vkGetImageSparseMemoryRequirements(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSparseImageFormatProperties: + Decode_vkGetPhysicalDeviceSparseImageFormatProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueBindSparse: + Decode_vkQueueBindSparse(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateFence: + Decode_vkCreateFence(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyFence: + Decode_vkDestroyFence(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkResetFences: + Decode_vkResetFences(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetFenceStatus: + Decode_vkGetFenceStatus(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkWaitForFences: + Decode_vkWaitForFences(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateSemaphore: + Decode_vkCreateSemaphore(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroySemaphore: + Decode_vkDestroySemaphore(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateEvent: + Decode_vkCreateEvent(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyEvent: + Decode_vkDestroyEvent(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetEventStatus: + Decode_vkGetEventStatus(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetEvent: + Decode_vkSetEvent(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkResetEvent: + Decode_vkResetEvent(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateQueryPool: + Decode_vkCreateQueryPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyQueryPool: + Decode_vkDestroyQueryPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetQueryPoolResults: + Decode_vkGetQueryPoolResults(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateBuffer: + Decode_vkCreateBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyBuffer: + Decode_vkDestroyBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateBufferView: + Decode_vkCreateBufferView(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyBufferView: + Decode_vkDestroyBufferView(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateImage: + Decode_vkCreateImage(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyImage: + Decode_vkDestroyImage(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageSubresourceLayout: + Decode_vkGetImageSubresourceLayout(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateImageView: + Decode_vkCreateImageView(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyImageView: + Decode_vkDestroyImageView(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateShaderModule: + Decode_vkCreateShaderModule(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyShaderModule: + Decode_vkDestroyShaderModule(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreatePipelineCache: + Decode_vkCreatePipelineCache(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyPipelineCache: + Decode_vkDestroyPipelineCache(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPipelineCacheData: + Decode_vkGetPipelineCacheData(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkMergePipelineCaches: + Decode_vkMergePipelineCaches(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateGraphicsPipelines: + Decode_vkCreateGraphicsPipelines(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateComputePipelines: + Decode_vkCreateComputePipelines(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyPipeline: + Decode_vkDestroyPipeline(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreatePipelineLayout: + Decode_vkCreatePipelineLayout(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyPipelineLayout: + Decode_vkDestroyPipelineLayout(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateSampler: + Decode_vkCreateSampler(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroySampler: + Decode_vkDestroySampler(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDescriptorSetLayout: + Decode_vkCreateDescriptorSetLayout(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyDescriptorSetLayout: + Decode_vkDestroyDescriptorSetLayout(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDescriptorPool: + Decode_vkCreateDescriptorPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyDescriptorPool: + Decode_vkDestroyDescriptorPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkResetDescriptorPool: + Decode_vkResetDescriptorPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAllocateDescriptorSets: + Decode_vkAllocateDescriptorSets(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkFreeDescriptorSets: + Decode_vkFreeDescriptorSets(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkUpdateDescriptorSets: + Decode_vkUpdateDescriptorSets(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateFramebuffer: + Decode_vkCreateFramebuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyFramebuffer: + Decode_vkDestroyFramebuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateRenderPass: + Decode_vkCreateRenderPass(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyRenderPass: + Decode_vkDestroyRenderPass(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetRenderAreaGranularity: + Decode_vkGetRenderAreaGranularity(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateCommandPool: + Decode_vkCreateCommandPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyCommandPool: + Decode_vkDestroyCommandPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkResetCommandPool: + Decode_vkResetCommandPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAllocateCommandBuffers: + Decode_vkAllocateCommandBuffers(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkFreeCommandBuffers: + Decode_vkFreeCommandBuffers(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBeginCommandBuffer: + Decode_vkBeginCommandBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkEndCommandBuffer: + Decode_vkEndCommandBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkResetCommandBuffer: + Decode_vkResetCommandBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindPipeline: + Decode_vkCmdBindPipeline(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetViewport: + Decode_vkCmdSetViewport(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetScissor: + Decode_vkCmdSetScissor(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetLineWidth: + Decode_vkCmdSetLineWidth(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthBias: + Decode_vkCmdSetDepthBias(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetBlendConstants: + Decode_vkCmdSetBlendConstants(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthBounds: + Decode_vkCmdSetDepthBounds(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetStencilCompareMask: + Decode_vkCmdSetStencilCompareMask(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetStencilWriteMask: + Decode_vkCmdSetStencilWriteMask(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetStencilReference: + Decode_vkCmdSetStencilReference(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindDescriptorSets: + Decode_vkCmdBindDescriptorSets(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindIndexBuffer: + Decode_vkCmdBindIndexBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindVertexBuffers: + Decode_vkCmdBindVertexBuffers(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDraw: + Decode_vkCmdDraw(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndexed: + Decode_vkCmdDrawIndexed(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndirect: + Decode_vkCmdDrawIndirect(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndexedIndirect: + Decode_vkCmdDrawIndexedIndirect(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDispatch: + Decode_vkCmdDispatch(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDispatchIndirect: + Decode_vkCmdDispatchIndirect(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyBuffer: + Decode_vkCmdCopyBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyImage: + Decode_vkCmdCopyImage(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBlitImage: + Decode_vkCmdBlitImage(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyBufferToImage: + Decode_vkCmdCopyBufferToImage(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyImageToBuffer: + Decode_vkCmdCopyImageToBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdUpdateBuffer: + Decode_vkCmdUpdateBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdFillBuffer: + Decode_vkCmdFillBuffer(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdClearColorImage: + Decode_vkCmdClearColorImage(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdClearDepthStencilImage: + Decode_vkCmdClearDepthStencilImage(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdClearAttachments: + Decode_vkCmdClearAttachments(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdResolveImage: + Decode_vkCmdResolveImage(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetEvent: + Decode_vkCmdSetEvent(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdResetEvent: + Decode_vkCmdResetEvent(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWaitEvents: + Decode_vkCmdWaitEvents(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPipelineBarrier: + Decode_vkCmdPipelineBarrier(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginQuery: + Decode_vkCmdBeginQuery(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndQuery: + Decode_vkCmdEndQuery(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdResetQueryPool: + Decode_vkCmdResetQueryPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWriteTimestamp: + Decode_vkCmdWriteTimestamp(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyQueryPoolResults: + Decode_vkCmdCopyQueryPoolResults(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPushConstants: + Decode_vkCmdPushConstants(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginRenderPass: + Decode_vkCmdBeginRenderPass(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdNextSubpass: + Decode_vkCmdNextSubpass(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndRenderPass: + Decode_vkCmdEndRenderPass(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdExecuteCommands: + Decode_vkCmdExecuteCommands(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBindBufferMemory2: + Decode_vkBindBufferMemory2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBindImageMemory2: + Decode_vkBindImageMemory2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceGroupPeerMemoryFeatures: + Decode_vkGetDeviceGroupPeerMemoryFeatures(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDeviceMask: + Decode_vkCmdSetDeviceMask(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDispatchBase: + Decode_vkCmdDispatchBase(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkEnumeratePhysicalDeviceGroups: + Decode_vkEnumeratePhysicalDeviceGroups(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageMemoryRequirements2: + Decode_vkGetImageMemoryRequirements2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetBufferMemoryRequirements2: + Decode_vkGetBufferMemoryRequirements2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageSparseMemoryRequirements2: + Decode_vkGetImageSparseMemoryRequirements2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceFeatures2: + Decode_vkGetPhysicalDeviceFeatures2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceProperties2: + Decode_vkGetPhysicalDeviceProperties2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceFormatProperties2: + Decode_vkGetPhysicalDeviceFormatProperties2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceImageFormatProperties2: + Decode_vkGetPhysicalDeviceImageFormatProperties2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceQueueFamilyProperties2: + Decode_vkGetPhysicalDeviceQueueFamilyProperties2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceMemoryProperties2: + Decode_vkGetPhysicalDeviceMemoryProperties2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSparseImageFormatProperties2: + Decode_vkGetPhysicalDeviceSparseImageFormatProperties2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkTrimCommandPool: + Decode_vkTrimCommandPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceQueue2: + Decode_vkGetDeviceQueue2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateSamplerYcbcrConversion: + Decode_vkCreateSamplerYcbcrConversion(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroySamplerYcbcrConversion: + Decode_vkDestroySamplerYcbcrConversion(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDescriptorUpdateTemplate: + Decode_vkCreateDescriptorUpdateTemplate(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyDescriptorUpdateTemplate: + Decode_vkDestroyDescriptorUpdateTemplate(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceExternalBufferProperties: + Decode_vkGetPhysicalDeviceExternalBufferProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceExternalFenceProperties: + Decode_vkGetPhysicalDeviceExternalFenceProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceExternalSemaphoreProperties: + Decode_vkGetPhysicalDeviceExternalSemaphoreProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDescriptorSetLayoutSupport: + Decode_vkGetDescriptorSetLayoutSupport(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndirectCount: + Decode_vkCmdDrawIndirectCount(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndexedIndirectCount: + Decode_vkCmdDrawIndexedIndirectCount(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateRenderPass2: + Decode_vkCreateRenderPass2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginRenderPass2: + Decode_vkCmdBeginRenderPass2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdNextSubpass2: + Decode_vkCmdNextSubpass2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndRenderPass2: + Decode_vkCmdEndRenderPass2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkResetQueryPool: + Decode_vkResetQueryPool(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetSemaphoreCounterValue: + Decode_vkGetSemaphoreCounterValue(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkWaitSemaphores: + Decode_vkWaitSemaphores(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSignalSemaphore: + Decode_vkSignalSemaphore(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetBufferDeviceAddress: + Decode_vkGetBufferDeviceAddress(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetBufferOpaqueCaptureAddress: + Decode_vkGetBufferOpaqueCaptureAddress(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceMemoryOpaqueCaptureAddress: + Decode_vkGetDeviceMemoryOpaqueCaptureAddress(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceToolProperties: + Decode_vkGetPhysicalDeviceToolProperties(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreatePrivateDataSlot: + Decode_vkCreatePrivateDataSlot(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyPrivateDataSlot: + Decode_vkDestroyPrivateDataSlot(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetPrivateData: + Decode_vkSetPrivateData(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPrivateData: + Decode_vkGetPrivateData(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetEvent2: + Decode_vkCmdSetEvent2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdResetEvent2: + Decode_vkCmdResetEvent2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWaitEvents2: + Decode_vkCmdWaitEvents2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPipelineBarrier2: + Decode_vkCmdPipelineBarrier2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWriteTimestamp2: + Decode_vkCmdWriteTimestamp2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueSubmit2: + Decode_vkQueueSubmit2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyBuffer2: + Decode_vkCmdCopyBuffer2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyImage2: + Decode_vkCmdCopyImage2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyBufferToImage2: + Decode_vkCmdCopyBufferToImage2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyImageToBuffer2: + Decode_vkCmdCopyImageToBuffer2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBlitImage2: + Decode_vkCmdBlitImage2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdResolveImage2: + Decode_vkCmdResolveImage2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginRendering: + Decode_vkCmdBeginRendering(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndRendering: + Decode_vkCmdEndRendering(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCullMode: + Decode_vkCmdSetCullMode(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetFrontFace: + Decode_vkCmdSetFrontFace(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetPrimitiveTopology: + Decode_vkCmdSetPrimitiveTopology(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetViewportWithCount: + Decode_vkCmdSetViewportWithCount(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetScissorWithCount: + Decode_vkCmdSetScissorWithCount(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindVertexBuffers2: + Decode_vkCmdBindVertexBuffers2(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthTestEnable: + Decode_vkCmdSetDepthTestEnable(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthWriteEnable: + Decode_vkCmdSetDepthWriteEnable(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthCompareOp: + Decode_vkCmdSetDepthCompareOp(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthBoundsTestEnable: + Decode_vkCmdSetDepthBoundsTestEnable(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetStencilTestEnable: + Decode_vkCmdSetStencilTestEnable(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetStencilOp: + Decode_vkCmdSetStencilOp(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetRasterizerDiscardEnable: + Decode_vkCmdSetRasterizerDiscardEnable(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthBiasEnable: + Decode_vkCmdSetDepthBiasEnable(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetPrimitiveRestartEnable: + Decode_vkCmdSetPrimitiveRestartEnable(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceBufferMemoryRequirements: + Decode_vkGetDeviceBufferMemoryRequirements(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceImageMemoryRequirements: + Decode_vkGetDeviceImageMemoryRequirements(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceImageSparseMemoryRequirements: + Decode_vkGetDeviceImageSparseMemoryRequirements(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroySurfaceKHR: + Decode_vkDestroySurfaceKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSurfaceSupportKHR: + Decode_vkGetPhysicalDeviceSurfaceSupportKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSurfaceCapabilitiesKHR: + Decode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSurfaceFormatsKHR: + Decode_vkGetPhysicalDeviceSurfaceFormatsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSurfacePresentModesKHR: + Decode_vkGetPhysicalDeviceSurfacePresentModesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateSwapchainKHR: + Decode_vkCreateSwapchainKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroySwapchainKHR: + Decode_vkDestroySwapchainKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetSwapchainImagesKHR: + Decode_vkGetSwapchainImagesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAcquireNextImageKHR: + Decode_vkAcquireNextImageKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueuePresentKHR: + Decode_vkQueuePresentKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceGroupPresentCapabilitiesKHR: + Decode_vkGetDeviceGroupPresentCapabilitiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceGroupSurfacePresentModesKHR: + Decode_vkGetDeviceGroupSurfacePresentModesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDevicePresentRectanglesKHR: + Decode_vkGetPhysicalDevicePresentRectanglesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAcquireNextImage2KHR: + Decode_vkAcquireNextImage2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceDisplayPropertiesKHR: + Decode_vkGetPhysicalDeviceDisplayPropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceDisplayPlanePropertiesKHR: + Decode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDisplayPlaneSupportedDisplaysKHR: + Decode_vkGetDisplayPlaneSupportedDisplaysKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDisplayModePropertiesKHR: + Decode_vkGetDisplayModePropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDisplayModeKHR: + Decode_vkCreateDisplayModeKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDisplayPlaneCapabilitiesKHR: + Decode_vkGetDisplayPlaneCapabilitiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDisplayPlaneSurfaceKHR: + Decode_vkCreateDisplayPlaneSurfaceKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateSharedSwapchainsKHR: + Decode_vkCreateSharedSwapchainsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateXlibSurfaceKHR: + Decode_vkCreateXlibSurfaceKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceXlibPresentationSupportKHR: + Decode_vkGetPhysicalDeviceXlibPresentationSupportKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateXcbSurfaceKHR: + Decode_vkCreateXcbSurfaceKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceXcbPresentationSupportKHR: + Decode_vkGetPhysicalDeviceXcbPresentationSupportKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateWaylandSurfaceKHR: + Decode_vkCreateWaylandSurfaceKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceWaylandPresentationSupportKHR: + Decode_vkGetPhysicalDeviceWaylandPresentationSupportKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateAndroidSurfaceKHR: + Decode_vkCreateAndroidSurfaceKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateWin32SurfaceKHR: + Decode_vkCreateWin32SurfaceKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceWin32PresentationSupportKHR: + Decode_vkGetPhysicalDeviceWin32PresentationSupportKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceVideoCapabilitiesKHR: + Decode_vkGetPhysicalDeviceVideoCapabilitiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceVideoFormatPropertiesKHR: + Decode_vkGetPhysicalDeviceVideoFormatPropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateVideoSessionKHR: + Decode_vkCreateVideoSessionKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyVideoSessionKHR: + Decode_vkDestroyVideoSessionKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetVideoSessionMemoryRequirementsKHR: + Decode_vkGetVideoSessionMemoryRequirementsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBindVideoSessionMemoryKHR: + Decode_vkBindVideoSessionMemoryKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateVideoSessionParametersKHR: + Decode_vkCreateVideoSessionParametersKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkUpdateVideoSessionParametersKHR: + Decode_vkUpdateVideoSessionParametersKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyVideoSessionParametersKHR: + Decode_vkDestroyVideoSessionParametersKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginVideoCodingKHR: + Decode_vkCmdBeginVideoCodingKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndVideoCodingKHR: + Decode_vkCmdEndVideoCodingKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdControlVideoCodingKHR: + Decode_vkCmdControlVideoCodingKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDecodeVideoKHR: + Decode_vkCmdDecodeVideoKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginRenderingKHR: + Decode_vkCmdBeginRenderingKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndRenderingKHR: + Decode_vkCmdEndRenderingKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceFeatures2KHR: + Decode_vkGetPhysicalDeviceFeatures2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceProperties2KHR: + Decode_vkGetPhysicalDeviceProperties2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceFormatProperties2KHR: + Decode_vkGetPhysicalDeviceFormatProperties2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceImageFormatProperties2KHR: + Decode_vkGetPhysicalDeviceImageFormatProperties2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceQueueFamilyProperties2KHR: + Decode_vkGetPhysicalDeviceQueueFamilyProperties2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceMemoryProperties2KHR: + Decode_vkGetPhysicalDeviceMemoryProperties2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSparseImageFormatProperties2KHR: + Decode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceGroupPeerMemoryFeaturesKHR: + Decode_vkGetDeviceGroupPeerMemoryFeaturesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDeviceMaskKHR: + Decode_vkCmdSetDeviceMaskKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDispatchBaseKHR: + Decode_vkCmdDispatchBaseKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkTrimCommandPoolKHR: + Decode_vkTrimCommandPoolKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkEnumeratePhysicalDeviceGroupsKHR: + Decode_vkEnumeratePhysicalDeviceGroupsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceExternalBufferPropertiesKHR: + Decode_vkGetPhysicalDeviceExternalBufferPropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryWin32HandleKHR: + Decode_vkGetMemoryWin32HandleKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryWin32HandlePropertiesKHR: + Decode_vkGetMemoryWin32HandlePropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryFdKHR: + Decode_vkGetMemoryFdKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryFdPropertiesKHR: + Decode_vkGetMemoryFdPropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: + Decode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkImportSemaphoreWin32HandleKHR: + Decode_vkImportSemaphoreWin32HandleKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetSemaphoreWin32HandleKHR: + Decode_vkGetSemaphoreWin32HandleKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkImportSemaphoreFdKHR: + Decode_vkImportSemaphoreFdKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetSemaphoreFdKHR: + Decode_vkGetSemaphoreFdKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPushDescriptorSetKHR: + Decode_vkCmdPushDescriptorSetKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDescriptorUpdateTemplateKHR: + Decode_vkCreateDescriptorUpdateTemplateKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyDescriptorUpdateTemplateKHR: + Decode_vkDestroyDescriptorUpdateTemplateKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateRenderPass2KHR: + Decode_vkCreateRenderPass2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginRenderPass2KHR: + Decode_vkCmdBeginRenderPass2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdNextSubpass2KHR: + Decode_vkCmdNextSubpass2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndRenderPass2KHR: + Decode_vkCmdEndRenderPass2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetSwapchainStatusKHR: + Decode_vkGetSwapchainStatusKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceExternalFencePropertiesKHR: + Decode_vkGetPhysicalDeviceExternalFencePropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkImportFenceWin32HandleKHR: + Decode_vkImportFenceWin32HandleKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetFenceWin32HandleKHR: + Decode_vkGetFenceWin32HandleKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkImportFenceFdKHR: + Decode_vkImportFenceFdKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetFenceFdKHR: + Decode_vkGetFenceFdKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: + Decode_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: + Decode_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAcquireProfilingLockKHR: + Decode_vkAcquireProfilingLockKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkReleaseProfilingLockKHR: + Decode_vkReleaseProfilingLockKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSurfaceCapabilities2KHR: + Decode_vkGetPhysicalDeviceSurfaceCapabilities2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSurfaceFormats2KHR: + Decode_vkGetPhysicalDeviceSurfaceFormats2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceDisplayProperties2KHR: + Decode_vkGetPhysicalDeviceDisplayProperties2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceDisplayPlaneProperties2KHR: + Decode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDisplayModeProperties2KHR: + Decode_vkGetDisplayModeProperties2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDisplayPlaneCapabilities2KHR: + Decode_vkGetDisplayPlaneCapabilities2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageMemoryRequirements2KHR: + Decode_vkGetImageMemoryRequirements2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetBufferMemoryRequirements2KHR: + Decode_vkGetBufferMemoryRequirements2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageSparseMemoryRequirements2KHR: + Decode_vkGetImageSparseMemoryRequirements2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateSamplerYcbcrConversionKHR: + Decode_vkCreateSamplerYcbcrConversionKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroySamplerYcbcrConversionKHR: + Decode_vkDestroySamplerYcbcrConversionKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBindBufferMemory2KHR: + Decode_vkBindBufferMemory2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBindImageMemory2KHR: + Decode_vkBindImageMemory2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDescriptorSetLayoutSupportKHR: + Decode_vkGetDescriptorSetLayoutSupportKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndirectCountKHR: + Decode_vkCmdDrawIndirectCountKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndexedIndirectCountKHR: + Decode_vkCmdDrawIndexedIndirectCountKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetSemaphoreCounterValueKHR: + Decode_vkGetSemaphoreCounterValueKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkWaitSemaphoresKHR: + Decode_vkWaitSemaphoresKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSignalSemaphoreKHR: + Decode_vkSignalSemaphoreKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceFragmentShadingRatesKHR: + Decode_vkGetPhysicalDeviceFragmentShadingRatesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetFragmentShadingRateKHR: + Decode_vkCmdSetFragmentShadingRateKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetRenderingAttachmentLocationsKHR: + Decode_vkCmdSetRenderingAttachmentLocationsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetRenderingInputAttachmentIndicesKHR: + Decode_vkCmdSetRenderingInputAttachmentIndicesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkWaitForPresentKHR: + Decode_vkWaitForPresentKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetBufferDeviceAddressKHR: + Decode_vkGetBufferDeviceAddressKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetBufferOpaqueCaptureAddressKHR: + Decode_vkGetBufferOpaqueCaptureAddressKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceMemoryOpaqueCaptureAddressKHR: + Decode_vkGetDeviceMemoryOpaqueCaptureAddressKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDeferredOperationKHR: + Decode_vkCreateDeferredOperationKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyDeferredOperationKHR: + Decode_vkDestroyDeferredOperationKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeferredOperationMaxConcurrencyKHR: + Decode_vkGetDeferredOperationMaxConcurrencyKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeferredOperationResultKHR: + Decode_vkGetDeferredOperationResultKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPipelineExecutablePropertiesKHR: + Decode_vkGetPipelineExecutablePropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPipelineExecutableStatisticsKHR: + Decode_vkGetPipelineExecutableStatisticsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPipelineExecutableInternalRepresentationsKHR: + Decode_vkGetPipelineExecutableInternalRepresentationsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkMapMemory2KHR: + Decode_vkMapMemory2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkUnmapMemory2KHR: + Decode_vkUnmapMemory2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR: + Decode_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetEncodedVideoSessionParametersKHR: + Decode_vkGetEncodedVideoSessionParametersKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEncodeVideoKHR: + Decode_vkCmdEncodeVideoKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetEvent2KHR: + Decode_vkCmdSetEvent2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdResetEvent2KHR: + Decode_vkCmdResetEvent2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWaitEvents2KHR: + Decode_vkCmdWaitEvents2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPipelineBarrier2KHR: + Decode_vkCmdPipelineBarrier2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWriteTimestamp2KHR: + Decode_vkCmdWriteTimestamp2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueSubmit2KHR: + Decode_vkQueueSubmit2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWriteBufferMarker2AMD: + Decode_vkCmdWriteBufferMarker2AMD(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetQueueCheckpointData2NV: + Decode_vkGetQueueCheckpointData2NV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyBuffer2KHR: + Decode_vkCmdCopyBuffer2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyImage2KHR: + Decode_vkCmdCopyImage2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyBufferToImage2KHR: + Decode_vkCmdCopyBufferToImage2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyImageToBuffer2KHR: + Decode_vkCmdCopyImageToBuffer2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBlitImage2KHR: + Decode_vkCmdBlitImage2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdResolveImage2KHR: + Decode_vkCmdResolveImage2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdTraceRaysIndirect2KHR: + Decode_vkCmdTraceRaysIndirect2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceBufferMemoryRequirementsKHR: + Decode_vkGetDeviceBufferMemoryRequirementsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceImageMemoryRequirementsKHR: + Decode_vkGetDeviceImageMemoryRequirementsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceImageSparseMemoryRequirementsKHR: + Decode_vkGetDeviceImageSparseMemoryRequirementsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindIndexBuffer2KHR: + Decode_vkCmdBindIndexBuffer2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetRenderingAreaGranularityKHR: + Decode_vkGetRenderingAreaGranularityKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceImageSubresourceLayoutKHR: + Decode_vkGetDeviceImageSubresourceLayoutKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageSubresourceLayout2KHR: + Decode_vkGetImageSubresourceLayout2KHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR: + Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetLineStippleKHR: + Decode_vkCmdSetLineStippleKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR: + Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(call_info, parameter_buffer, buffer_size); + break; + 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_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; + case format::ApiCallId::ApiCall_vkCreateDebugReportCallbackEXT: + Decode_vkCreateDebugReportCallbackEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyDebugReportCallbackEXT: + Decode_vkDestroyDebugReportCallbackEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDebugReportMessageEXT: + Decode_vkDebugReportMessageEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDebugMarkerSetObjectTagEXT: + Decode_vkDebugMarkerSetObjectTagEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDebugMarkerSetObjectNameEXT: + Decode_vkDebugMarkerSetObjectNameEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDebugMarkerBeginEXT: + Decode_vkCmdDebugMarkerBeginEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDebugMarkerEndEXT: + Decode_vkCmdDebugMarkerEndEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDebugMarkerInsertEXT: + Decode_vkCmdDebugMarkerInsertEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindTransformFeedbackBuffersEXT: + Decode_vkCmdBindTransformFeedbackBuffersEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginTransformFeedbackEXT: + Decode_vkCmdBeginTransformFeedbackEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndTransformFeedbackEXT: + Decode_vkCmdEndTransformFeedbackEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginQueryIndexedEXT: + Decode_vkCmdBeginQueryIndexedEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndQueryIndexedEXT: + Decode_vkCmdEndQueryIndexedEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndirectByteCountEXT: + Decode_vkCmdDrawIndirectByteCountEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageViewHandleNVX: + Decode_vkGetImageViewHandleNVX(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageViewAddressNVX: + Decode_vkGetImageViewAddressNVX(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndirectCountAMD: + Decode_vkCmdDrawIndirectCountAMD(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawIndexedIndirectCountAMD: + Decode_vkCmdDrawIndexedIndirectCountAMD(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetShaderInfoAMD: + Decode_vkGetShaderInfoAMD(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateStreamDescriptorSurfaceGGP: + Decode_vkCreateStreamDescriptorSurfaceGGP(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceExternalImageFormatPropertiesNV: + Decode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryWin32HandleNV: + Decode_vkGetMemoryWin32HandleNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateViSurfaceNN: + Decode_vkCreateViSurfaceNN(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginConditionalRenderingEXT: + Decode_vkCmdBeginConditionalRenderingEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndConditionalRenderingEXT: + Decode_vkCmdEndConditionalRenderingEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetViewportWScalingNV: + Decode_vkCmdSetViewportWScalingNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkReleaseDisplayEXT: + Decode_vkReleaseDisplayEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAcquireXlibDisplayEXT: + Decode_vkAcquireXlibDisplayEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetRandROutputDisplayEXT: + Decode_vkGetRandROutputDisplayEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSurfaceCapabilities2EXT: + Decode_vkGetPhysicalDeviceSurfaceCapabilities2EXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDisplayPowerControlEXT: + Decode_vkDisplayPowerControlEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkRegisterDeviceEventEXT: + Decode_vkRegisterDeviceEventEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkRegisterDisplayEventEXT: + Decode_vkRegisterDisplayEventEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetSwapchainCounterEXT: + Decode_vkGetSwapchainCounterEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetRefreshCycleDurationGOOGLE: + Decode_vkGetRefreshCycleDurationGOOGLE(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPastPresentationTimingGOOGLE: + Decode_vkGetPastPresentationTimingGOOGLE(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDiscardRectangleEXT: + Decode_vkCmdSetDiscardRectangleEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDiscardRectangleEnableEXT: + Decode_vkCmdSetDiscardRectangleEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDiscardRectangleModeEXT: + Decode_vkCmdSetDiscardRectangleModeEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetHdrMetadataEXT: + Decode_vkSetHdrMetadataEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateIOSSurfaceMVK: + Decode_vkCreateIOSSurfaceMVK(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateMacOSSurfaceMVK: + Decode_vkCreateMacOSSurfaceMVK(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetDebugUtilsObjectNameEXT: + Decode_vkSetDebugUtilsObjectNameEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetDebugUtilsObjectTagEXT: + Decode_vkSetDebugUtilsObjectTagEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueBeginDebugUtilsLabelEXT: + Decode_vkQueueBeginDebugUtilsLabelEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueEndDebugUtilsLabelEXT: + Decode_vkQueueEndDebugUtilsLabelEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueInsertDebugUtilsLabelEXT: + Decode_vkQueueInsertDebugUtilsLabelEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBeginDebugUtilsLabelEXT: + Decode_vkCmdBeginDebugUtilsLabelEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdEndDebugUtilsLabelEXT: + Decode_vkCmdEndDebugUtilsLabelEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdInsertDebugUtilsLabelEXT: + Decode_vkCmdInsertDebugUtilsLabelEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDebugUtilsMessengerEXT: + Decode_vkCreateDebugUtilsMessengerEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyDebugUtilsMessengerEXT: + Decode_vkDestroyDebugUtilsMessengerEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSubmitDebugUtilsMessageEXT: + Decode_vkSubmitDebugUtilsMessageEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetAndroidHardwareBufferPropertiesANDROID: + Decode_vkGetAndroidHardwareBufferPropertiesANDROID(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryAndroidHardwareBufferANDROID: + Decode_vkGetMemoryAndroidHardwareBufferANDROID(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetSampleLocationsEXT: + Decode_vkCmdSetSampleLocationsEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceMultisamplePropertiesEXT: + Decode_vkGetPhysicalDeviceMultisamplePropertiesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageDrmFormatModifierPropertiesEXT: + Decode_vkGetImageDrmFormatModifierPropertiesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateValidationCacheEXT: + Decode_vkCreateValidationCacheEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyValidationCacheEXT: + Decode_vkDestroyValidationCacheEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkMergeValidationCachesEXT: + Decode_vkMergeValidationCachesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetValidationCacheDataEXT: + Decode_vkGetValidationCacheDataEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindShadingRateImageNV: + Decode_vkCmdBindShadingRateImageNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetViewportShadingRatePaletteNV: + Decode_vkCmdSetViewportShadingRatePaletteNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCoarseSampleOrderNV: + Decode_vkCmdSetCoarseSampleOrderNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateAccelerationStructureNV: + Decode_vkCreateAccelerationStructureNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyAccelerationStructureNV: + Decode_vkDestroyAccelerationStructureNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetAccelerationStructureMemoryRequirementsNV: + Decode_vkGetAccelerationStructureMemoryRequirementsNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBindAccelerationStructureMemoryNV: + Decode_vkBindAccelerationStructureMemoryNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBuildAccelerationStructureNV: + Decode_vkCmdBuildAccelerationStructureNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyAccelerationStructureNV: + Decode_vkCmdCopyAccelerationStructureNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdTraceRaysNV: + Decode_vkCmdTraceRaysNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateRayTracingPipelinesNV: + Decode_vkCreateRayTracingPipelinesNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetRayTracingShaderGroupHandlesKHR: + Decode_vkGetRayTracingShaderGroupHandlesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetRayTracingShaderGroupHandlesNV: + Decode_vkGetRayTracingShaderGroupHandlesNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetAccelerationStructureHandleNV: + Decode_vkGetAccelerationStructureHandleNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWriteAccelerationStructuresPropertiesNV: + Decode_vkCmdWriteAccelerationStructuresPropertiesNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCompileDeferredNV: + Decode_vkCompileDeferredNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryHostPointerPropertiesEXT: + Decode_vkGetMemoryHostPointerPropertiesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWriteBufferMarkerAMD: + Decode_vkCmdWriteBufferMarkerAMD(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT: + Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetCalibratedTimestampsEXT: + Decode_vkGetCalibratedTimestampsEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawMeshTasksNV: + Decode_vkCmdDrawMeshTasksNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawMeshTasksIndirectNV: + Decode_vkCmdDrawMeshTasksIndirectNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawMeshTasksIndirectCountNV: + Decode_vkCmdDrawMeshTasksIndirectCountNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetExclusiveScissorEnableNV: + Decode_vkCmdSetExclusiveScissorEnableNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetExclusiveScissorNV: + Decode_vkCmdSetExclusiveScissorNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCheckpointNV: + Decode_vkCmdSetCheckpointNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetQueueCheckpointDataNV: + Decode_vkGetQueueCheckpointDataNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkInitializePerformanceApiINTEL: + Decode_vkInitializePerformanceApiINTEL(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkUninitializePerformanceApiINTEL: + Decode_vkUninitializePerformanceApiINTEL(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetPerformanceMarkerINTEL: + Decode_vkCmdSetPerformanceMarkerINTEL(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetPerformanceStreamMarkerINTEL: + Decode_vkCmdSetPerformanceStreamMarkerINTEL(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetPerformanceOverrideINTEL: + Decode_vkCmdSetPerformanceOverrideINTEL(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAcquirePerformanceConfigurationINTEL: + Decode_vkAcquirePerformanceConfigurationINTEL(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkReleasePerformanceConfigurationINTEL: + Decode_vkReleasePerformanceConfigurationINTEL(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueSetPerformanceConfigurationINTEL: + Decode_vkQueueSetPerformanceConfigurationINTEL(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPerformanceParameterINTEL: + Decode_vkGetPerformanceParameterINTEL(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetLocalDimmingAMD: + Decode_vkSetLocalDimmingAMD(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateImagePipeSurfaceFUCHSIA: + Decode_vkCreateImagePipeSurfaceFUCHSIA(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateMetalSurfaceEXT: + Decode_vkCreateMetalSurfaceEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetBufferDeviceAddressEXT: + Decode_vkGetBufferDeviceAddressEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceToolPropertiesEXT: + Decode_vkGetPhysicalDeviceToolPropertiesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV: + Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV: + Decode_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceSurfacePresentModes2EXT: + Decode_vkGetPhysicalDeviceSurfacePresentModes2EXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAcquireFullScreenExclusiveModeEXT: + Decode_vkAcquireFullScreenExclusiveModeEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkReleaseFullScreenExclusiveModeEXT: + Decode_vkReleaseFullScreenExclusiveModeEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceGroupSurfacePresentModes2EXT: + Decode_vkGetDeviceGroupSurfacePresentModes2EXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateHeadlessSurfaceEXT: + Decode_vkCreateHeadlessSurfaceEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetLineStippleEXT: + Decode_vkCmdSetLineStippleEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkResetQueryPoolEXT: + Decode_vkResetQueryPoolEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCullModeEXT: + Decode_vkCmdSetCullModeEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetFrontFaceEXT: + Decode_vkCmdSetFrontFaceEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetPrimitiveTopologyEXT: + Decode_vkCmdSetPrimitiveTopologyEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetViewportWithCountEXT: + Decode_vkCmdSetViewportWithCountEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetScissorWithCountEXT: + Decode_vkCmdSetScissorWithCountEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindVertexBuffers2EXT: + Decode_vkCmdBindVertexBuffers2EXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthTestEnableEXT: + Decode_vkCmdSetDepthTestEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthWriteEnableEXT: + Decode_vkCmdSetDepthWriteEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthCompareOpEXT: + Decode_vkCmdSetDepthCompareOpEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthBoundsTestEnableEXT: + Decode_vkCmdSetDepthBoundsTestEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetStencilTestEnableEXT: + Decode_vkCmdSetStencilTestEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetStencilOpEXT: + Decode_vkCmdSetStencilOpEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCopyMemoryToImageEXT: + Decode_vkCopyMemoryToImageEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCopyImageToMemoryEXT: + Decode_vkCopyImageToMemoryEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCopyImageToImageEXT: + Decode_vkCopyImageToImageEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkTransitionImageLayoutEXT: + Decode_vkTransitionImageLayoutEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetImageSubresourceLayout2EXT: + Decode_vkGetImageSubresourceLayout2EXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkReleaseSwapchainImagesEXT: + Decode_vkReleaseSwapchainImagesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetGeneratedCommandsMemoryRequirementsNV: + Decode_vkGetGeneratedCommandsMemoryRequirementsNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPreprocessGeneratedCommandsNV: + Decode_vkCmdPreprocessGeneratedCommandsNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdExecuteGeneratedCommandsNV: + Decode_vkCmdExecuteGeneratedCommandsNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindPipelineShaderGroupNV: + Decode_vkCmdBindPipelineShaderGroupNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateIndirectCommandsLayoutNV: + Decode_vkCreateIndirectCommandsLayoutNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyIndirectCommandsLayoutNV: + Decode_vkDestroyIndirectCommandsLayoutNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthBias2EXT: + Decode_vkCmdSetDepthBias2EXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAcquireDrmDisplayEXT: + Decode_vkAcquireDrmDisplayEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDrmDisplayEXT: + Decode_vkGetDrmDisplayEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreatePrivateDataSlotEXT: + Decode_vkCreatePrivateDataSlotEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyPrivateDataSlotEXT: + Decode_vkDestroyPrivateDataSlotEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetPrivateDataEXT: + Decode_vkSetPrivateDataEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPrivateDataEXT: + Decode_vkGetPrivateDataEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetFragmentShadingRateEnumNV: + Decode_vkCmdSetFragmentShadingRateEnumNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceFaultInfoEXT: + Decode_vkGetDeviceFaultInfoEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkAcquireWinrtDisplayNV: + Decode_vkAcquireWinrtDisplayNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetWinrtDisplayNV: + Decode_vkGetWinrtDisplayNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateDirectFBSurfaceEXT: + Decode_vkCreateDirectFBSurfaceEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceDirectFBPresentationSupportEXT: + Decode_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetVertexInputEXT: + Decode_vkCmdSetVertexInputEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryZirconHandleFUCHSIA: + Decode_vkGetMemoryZirconHandleFUCHSIA(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryZirconHandlePropertiesFUCHSIA: + Decode_vkGetMemoryZirconHandlePropertiesFUCHSIA(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkImportSemaphoreZirconHandleFUCHSIA: + Decode_vkImportSemaphoreZirconHandleFUCHSIA(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetSemaphoreZirconHandleFUCHSIA: + Decode_vkGetSemaphoreZirconHandleFUCHSIA(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindInvocationMaskHUAWEI: + Decode_vkCmdBindInvocationMaskHUAWEI(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMemoryRemoteAddressNV: + Decode_vkGetMemoryRemoteAddressNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetPatchControlPointsEXT: + Decode_vkCmdSetPatchControlPointsEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetRasterizerDiscardEnableEXT: + Decode_vkCmdSetRasterizerDiscardEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthBiasEnableEXT: + Decode_vkCmdSetDepthBiasEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetLogicOpEXT: + Decode_vkCmdSetLogicOpEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetPrimitiveRestartEnableEXT: + Decode_vkCmdSetPrimitiveRestartEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateScreenSurfaceQNX: + Decode_vkCreateScreenSurfaceQNX(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceScreenPresentationSupportQNX: + Decode_vkGetPhysicalDeviceScreenPresentationSupportQNX(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetColorWriteEnableEXT: + Decode_vkCmdSetColorWriteEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawMultiEXT: + Decode_vkCmdDrawMultiEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawMultiIndexedEXT: + Decode_vkCmdDrawMultiIndexedEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateMicromapEXT: + Decode_vkCreateMicromapEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyMicromapEXT: + Decode_vkDestroyMicromapEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBuildMicromapsEXT: + Decode_vkCmdBuildMicromapsEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBuildMicromapsEXT: + Decode_vkBuildMicromapsEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCopyMicromapEXT: + Decode_vkCopyMicromapEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCopyMicromapToMemoryEXT: + Decode_vkCopyMicromapToMemoryEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCopyMemoryToMicromapEXT: + Decode_vkCopyMemoryToMicromapEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkWriteMicromapsPropertiesEXT: + Decode_vkWriteMicromapsPropertiesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyMicromapEXT: + Decode_vkCmdCopyMicromapEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyMicromapToMemoryEXT: + Decode_vkCmdCopyMicromapToMemoryEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyMemoryToMicromapEXT: + Decode_vkCmdCopyMemoryToMicromapEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWriteMicromapsPropertiesEXT: + Decode_vkCmdWriteMicromapsPropertiesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceMicromapCompatibilityEXT: + Decode_vkGetDeviceMicromapCompatibilityEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetMicromapBuildSizesEXT: + Decode_vkGetMicromapBuildSizesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawClusterHUAWEI: + Decode_vkCmdDrawClusterHUAWEI(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawClusterIndirectHUAWEI: + Decode_vkCmdDrawClusterIndirectHUAWEI(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetDeviceMemoryPriorityEXT: + Decode_vkSetDeviceMemoryPriorityEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDescriptorSetLayoutHostMappingInfoVALVE: + Decode_vkGetDescriptorSetLayoutHostMappingInfoVALVE(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDescriptorSetHostMappingVALVE: + Decode_vkGetDescriptorSetHostMappingVALVE(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPipelineIndirectMemoryRequirementsNV: + Decode_vkGetPipelineIndirectMemoryRequirementsNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdUpdatePipelineIndirectBufferNV: + Decode_vkCmdUpdatePipelineIndirectBufferNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPipelineIndirectDeviceAddressNV: + Decode_vkGetPipelineIndirectDeviceAddressNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthClampEnableEXT: + Decode_vkCmdSetDepthClampEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetPolygonModeEXT: + Decode_vkCmdSetPolygonModeEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetRasterizationSamplesEXT: + Decode_vkCmdSetRasterizationSamplesEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetSampleMaskEXT: + Decode_vkCmdSetSampleMaskEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetAlphaToCoverageEnableEXT: + Decode_vkCmdSetAlphaToCoverageEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetAlphaToOneEnableEXT: + Decode_vkCmdSetAlphaToOneEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetLogicOpEnableEXT: + Decode_vkCmdSetLogicOpEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetColorBlendEnableEXT: + Decode_vkCmdSetColorBlendEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetColorBlendEquationEXT: + Decode_vkCmdSetColorBlendEquationEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetColorWriteMaskEXT: + Decode_vkCmdSetColorWriteMaskEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetTessellationDomainOriginEXT: + Decode_vkCmdSetTessellationDomainOriginEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetRasterizationStreamEXT: + Decode_vkCmdSetRasterizationStreamEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetConservativeRasterizationModeEXT: + Decode_vkCmdSetConservativeRasterizationModeEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetExtraPrimitiveOverestimationSizeEXT: + Decode_vkCmdSetExtraPrimitiveOverestimationSizeEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthClipEnableEXT: + Decode_vkCmdSetDepthClipEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetSampleLocationsEnableEXT: + Decode_vkCmdSetSampleLocationsEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetColorBlendAdvancedEXT: + Decode_vkCmdSetColorBlendAdvancedEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetProvokingVertexModeEXT: + Decode_vkCmdSetProvokingVertexModeEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetLineRasterizationModeEXT: + Decode_vkCmdSetLineRasterizationModeEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetLineStippleEnableEXT: + Decode_vkCmdSetLineStippleEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetDepthClipNegativeOneToOneEXT: + Decode_vkCmdSetDepthClipNegativeOneToOneEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetViewportWScalingEnableNV: + Decode_vkCmdSetViewportWScalingEnableNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetViewportSwizzleNV: + Decode_vkCmdSetViewportSwizzleNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCoverageToColorEnableNV: + Decode_vkCmdSetCoverageToColorEnableNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCoverageToColorLocationNV: + Decode_vkCmdSetCoverageToColorLocationNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCoverageModulationModeNV: + Decode_vkCmdSetCoverageModulationModeNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCoverageModulationTableEnableNV: + Decode_vkCmdSetCoverageModulationTableEnableNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCoverageModulationTableNV: + Decode_vkCmdSetCoverageModulationTableNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetShadingRateImageEnableNV: + Decode_vkCmdSetShadingRateImageEnableNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetRepresentativeFragmentTestEnableNV: + Decode_vkCmdSetRepresentativeFragmentTestEnableNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetCoverageReductionModeNV: + Decode_vkCmdSetCoverageReductionModeNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetShaderModuleIdentifierEXT: + Decode_vkGetShaderModuleIdentifierEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetShaderModuleCreateInfoIdentifierEXT: + Decode_vkGetShaderModuleCreateInfoIdentifierEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceOpticalFlowImageFormatsNV: + Decode_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateOpticalFlowSessionNV: + Decode_vkCreateOpticalFlowSessionNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyOpticalFlowSessionNV: + Decode_vkDestroyOpticalFlowSessionNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkBindOpticalFlowSessionImageNV: + Decode_vkBindOpticalFlowSessionImageNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdOpticalFlowExecuteNV: + Decode_vkCmdOpticalFlowExecuteNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateShadersEXT: + Decode_vkCreateShadersEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyShaderEXT: + Decode_vkDestroyShaderEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetShaderBinaryDataEXT: + Decode_vkGetShaderBinaryDataEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBindShadersEXT: + Decode_vkCmdBindShadersEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetFramebufferTilePropertiesQCOM: + Decode_vkGetFramebufferTilePropertiesQCOM(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDynamicRenderingTilePropertiesQCOM: + Decode_vkGetDynamicRenderingTilePropertiesQCOM(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetLatencySleepModeNV: + Decode_vkSetLatencySleepModeNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkLatencySleepNV: + Decode_vkLatencySleepNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkSetLatencyMarkerNV: + Decode_vkSetLatencyMarkerNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetLatencyTimingsNV: + Decode_vkGetLatencyTimingsNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkQueueNotifyOutOfBandNV: + Decode_vkQueueNotifyOutOfBandNV(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetAttachmentFeedbackLoopEnableEXT: + Decode_vkCmdSetAttachmentFeedbackLoopEnableEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateAccelerationStructureKHR: + Decode_vkCreateAccelerationStructureKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyAccelerationStructureKHR: + Decode_vkDestroyAccelerationStructureKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBuildAccelerationStructuresKHR: + Decode_vkCmdBuildAccelerationStructuresKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdBuildAccelerationStructuresIndirectKHR: + Decode_vkCmdBuildAccelerationStructuresIndirectKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCopyAccelerationStructureToMemoryKHR: + Decode_vkCopyAccelerationStructureToMemoryKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCopyMemoryToAccelerationStructureKHR: + Decode_vkCopyMemoryToAccelerationStructureKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkWriteAccelerationStructuresPropertiesKHR: + Decode_vkWriteAccelerationStructuresPropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyAccelerationStructureKHR: + Decode_vkCmdCopyAccelerationStructureKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyAccelerationStructureToMemoryKHR: + Decode_vkCmdCopyAccelerationStructureToMemoryKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdCopyMemoryToAccelerationStructureKHR: + Decode_vkCmdCopyMemoryToAccelerationStructureKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetAccelerationStructureDeviceAddressKHR: + Decode_vkGetAccelerationStructureDeviceAddressKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdWriteAccelerationStructuresPropertiesKHR: + Decode_vkCmdWriteAccelerationStructuresPropertiesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetDeviceAccelerationStructureCompatibilityKHR: + Decode_vkGetDeviceAccelerationStructureCompatibilityKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetAccelerationStructureBuildSizesKHR: + Decode_vkGetAccelerationStructureBuildSizesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdTraceRaysKHR: + Decode_vkCmdTraceRaysKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: + Decode_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdTraceRaysIndirectKHR: + Decode_vkCmdTraceRaysIndirectKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetRayTracingShaderGroupStackSizeKHR: + Decode_vkGetRayTracingShaderGroupStackSizeKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdSetRayTracingPipelineStackSizeKHR: + Decode_vkCmdSetRayTracingPipelineStackSizeKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawMeshTasksEXT: + Decode_vkCmdDrawMeshTasksEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawMeshTasksIndirectEXT: + Decode_vkCmdDrawMeshTasksIndirectEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdDrawMeshTasksIndirectCountEXT: + Decode_vkCmdDrawMeshTasksIndirectCountEXT(call_info, parameter_buffer, buffer_size); + break; + } +} + + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/generated/generated_vulkan_preload_decoder.h b/framework/generated/generated_vulkan_preload_decoder.h new file mode 100644 index 0000000000..52314455ca --- /dev/null +++ b/framework/generated/generated_vulkan_preload_decoder.h @@ -0,0 +1,1311 @@ +/* +** Copyright (c) 2018-2023 Valve Corporation +** Copyright (c) 2018-2023 LunarG, Inc. +** Copyright (c) 2023 Advanced Micro Devices, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +/* +** This file is generated from the Khronos Vulkan XML API Registry. +** +*/ + +#ifndef GFXRECON_GENERATED_VULKAN_PRELOAD_DECODER_H +#define GFXRECON_GENERATED_VULKAN_PRELOAD_DECODER_H + +#include "decode/vulkan_preload_decoder_base.h" +#include "util/defines.h" + +#include "vulkan/vulkan.h" +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#include "vk_video/vulkan_video_codecs_common.h" + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +class VulkanPreloadDecoder : public VulkanPreloadDecoderBase +{ + public: + VulkanPreloadDecoder() { } + + virtual ~VulkanPreloadDecoder() override { } + + virtual void DecodeFunctionCall(format::ApiCallId call_id, + const ApiCallInfo& call_info, + const uint8_t* parameter_buffer, + size_t buffer_size) override; + + private: + size_t Decode_vkCreateInstance(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyInstance(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkEnumeratePhysicalDevices(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceFeatures(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceFormatProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceImageFormatProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceQueueFamilyProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceMemoryProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDevice(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyDevice(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceQueue(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueSubmit(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueWaitIdle(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDeviceWaitIdle(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAllocateMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkFreeMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkMapMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkUnmapMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkFlushMappedMemoryRanges(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkInvalidateMappedMemoryRanges(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceMemoryCommitment(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBindBufferMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBindImageMemory(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetBufferMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageSparseMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSparseImageFormatProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueBindSparse(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateFence(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyFence(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkResetFences(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetFenceStatus(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkWaitForFences(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateSemaphore(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroySemaphore(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetEventStatus(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkResetEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateQueryPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyQueryPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetQueryPoolResults(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateBufferView(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyBufferView(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageSubresourceLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateImageView(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyImageView(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateShaderModule(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyShaderModule(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreatePipelineCache(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyPipelineCache(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPipelineCacheData(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkMergePipelineCaches(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateGraphicsPipelines(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateComputePipelines(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyPipeline(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreatePipelineLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyPipelineLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateSampler(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroySampler(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDescriptorSetLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyDescriptorSetLayout(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDescriptorPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyDescriptorPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkResetDescriptorPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAllocateDescriptorSets(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkFreeDescriptorSets(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkUpdateDescriptorSets(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateFramebuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyFramebuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateRenderPass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyRenderPass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetRenderAreaGranularity(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateCommandPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyCommandPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkResetCommandPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAllocateCommandBuffers(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkFreeCommandBuffers(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBeginCommandBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkEndCommandBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkResetCommandBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindPipeline(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetViewport(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetScissor(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetLineWidth(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthBias(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetBlendConstants(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthBounds(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetStencilCompareMask(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetStencilWriteMask(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetStencilReference(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindDescriptorSets(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindIndexBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindVertexBuffers(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDraw(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndexed(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndirect(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndexedIndirect(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDispatch(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDispatchIndirect(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBlitImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyBufferToImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyImageToBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdUpdateBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdFillBuffer(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdClearColorImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdClearDepthStencilImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdClearAttachments(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdResolveImage(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdResetEvent(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWaitEvents(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPipelineBarrier(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginQuery(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndQuery(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdResetQueryPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWriteTimestamp(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyQueryPoolResults(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPushConstants(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginRenderPass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdNextSubpass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndRenderPass(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdExecuteCommands(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBindBufferMemory2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBindImageMemory2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceGroupPeerMemoryFeatures(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDeviceMask(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDispatchBase(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkEnumeratePhysicalDeviceGroups(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageMemoryRequirements2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetBufferMemoryRequirements2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageSparseMemoryRequirements2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceFeatures2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceFormatProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceImageFormatProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceQueueFamilyProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceMemoryProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSparseImageFormatProperties2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkTrimCommandPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceQueue2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateSamplerYcbcrConversion(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroySamplerYcbcrConversion(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDescriptorUpdateTemplate(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyDescriptorUpdateTemplate(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceExternalBufferProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceExternalFenceProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceExternalSemaphoreProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDescriptorSetLayoutSupport(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndirectCount(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndexedIndirectCount(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateRenderPass2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginRenderPass2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdNextSubpass2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndRenderPass2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkResetQueryPool(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetSemaphoreCounterValue(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkWaitSemaphores(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSignalSemaphore(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetBufferDeviceAddress(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetBufferOpaqueCaptureAddress(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceMemoryOpaqueCaptureAddress(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceToolProperties(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreatePrivateDataSlot(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyPrivateDataSlot(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetPrivateData(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPrivateData(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetEvent2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdResetEvent2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWaitEvents2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPipelineBarrier2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWriteTimestamp2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueSubmit2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyBuffer2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyImage2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyBufferToImage2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyImageToBuffer2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBlitImage2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdResolveImage2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginRendering(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndRendering(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCullMode(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetFrontFace(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetPrimitiveTopology(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetViewportWithCount(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetScissorWithCount(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindVertexBuffers2(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthTestEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthWriteEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthCompareOp(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthBoundsTestEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetStencilTestEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetStencilOp(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetRasterizerDiscardEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthBiasEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetPrimitiveRestartEnable(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceBufferMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceImageMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceImageSparseMemoryRequirements(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroySurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSurfaceSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSurfaceFormatsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSurfacePresentModesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateSwapchainKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroySwapchainKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetSwapchainImagesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAcquireNextImageKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueuePresentKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceGroupPresentCapabilitiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceGroupSurfacePresentModesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDevicePresentRectanglesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAcquireNextImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceDisplayPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDisplayPlaneSupportedDisplaysKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDisplayModePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDisplayModeKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDisplayPlaneCapabilitiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDisplayPlaneSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateSharedSwapchainsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateXlibSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceXlibPresentationSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateXcbSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceXcbPresentationSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateWaylandSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceWaylandPresentationSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateAndroidSurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateWin32SurfaceKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceWin32PresentationSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceVideoCapabilitiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceVideoFormatPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateVideoSessionKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyVideoSessionKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetVideoSessionMemoryRequirementsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBindVideoSessionMemoryKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateVideoSessionParametersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkUpdateVideoSessionParametersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyVideoSessionParametersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginVideoCodingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndVideoCodingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdControlVideoCodingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDecodeVideoKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginRenderingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndRenderingKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceFeatures2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceFormatProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceImageFormatProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceQueueFamilyProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceMemoryProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceGroupPeerMemoryFeaturesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDeviceMaskKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDispatchBaseKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkTrimCommandPoolKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkEnumeratePhysicalDeviceGroupsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceExternalBufferPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryWin32HandlePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryFdPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkImportSemaphoreWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetSemaphoreWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkImportSemaphoreFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetSemaphoreFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPushDescriptorSetKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDescriptorUpdateTemplateKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyDescriptorUpdateTemplateKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateRenderPass2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginRenderPass2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdNextSubpass2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndRenderPass2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetSwapchainStatusKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceExternalFencePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkImportFenceWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetFenceWin32HandleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkImportFenceFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetFenceFdKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAcquireProfilingLockKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkReleaseProfilingLockKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSurfaceCapabilities2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSurfaceFormats2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceDisplayProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDisplayModeProperties2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDisplayPlaneCapabilities2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageMemoryRequirements2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetBufferMemoryRequirements2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageSparseMemoryRequirements2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateSamplerYcbcrConversionKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroySamplerYcbcrConversionKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBindBufferMemory2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBindImageMemory2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDescriptorSetLayoutSupportKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndirectCountKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndexedIndirectCountKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetSemaphoreCounterValueKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkWaitSemaphoresKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSignalSemaphoreKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceFragmentShadingRatesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetFragmentShadingRateKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetRenderingAttachmentLocationsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetRenderingInputAttachmentIndicesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkWaitForPresentKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetBufferDeviceAddressKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetBufferOpaqueCaptureAddressKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceMemoryOpaqueCaptureAddressKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDeferredOperationKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyDeferredOperationKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeferredOperationMaxConcurrencyKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeferredOperationResultKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPipelineExecutablePropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPipelineExecutableStatisticsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPipelineExecutableInternalRepresentationsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkMapMemory2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkUnmapMemory2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetEncodedVideoSessionParametersKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEncodeVideoKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetEvent2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdResetEvent2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWaitEvents2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPipelineBarrier2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWriteTimestamp2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueSubmit2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWriteBufferMarker2AMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetQueueCheckpointData2NV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyBuffer2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyBufferToImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyImageToBuffer2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBlitImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdResolveImage2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdTraceRaysIndirect2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceBufferMemoryRequirementsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceImageMemoryRequirementsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceImageSparseMemoryRequirementsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindIndexBuffer2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetRenderingAreaGranularityKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceImageSubresourceLayoutKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageSubresourceLayout2KHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetLineStippleKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + 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_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); + + size_t Decode_vkDestroyDebugReportCallbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDebugReportMessageEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDebugMarkerSetObjectTagEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDebugMarkerSetObjectNameEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDebugMarkerBeginEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDebugMarkerEndEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDebugMarkerInsertEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindTransformFeedbackBuffersEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginTransformFeedbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndTransformFeedbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginQueryIndexedEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndQueryIndexedEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndirectByteCountEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageViewHandleNVX(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageViewAddressNVX(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndirectCountAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawIndexedIndirectCountAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetShaderInfoAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateStreamDescriptorSurfaceGGP(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryWin32HandleNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateViSurfaceNN(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginConditionalRenderingEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndConditionalRenderingEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetViewportWScalingNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkReleaseDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAcquireXlibDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetRandROutputDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSurfaceCapabilities2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDisplayPowerControlEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkRegisterDeviceEventEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkRegisterDisplayEventEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetSwapchainCounterEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetRefreshCycleDurationGOOGLE(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPastPresentationTimingGOOGLE(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDiscardRectangleEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDiscardRectangleEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDiscardRectangleModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetHdrMetadataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateIOSSurfaceMVK(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateMacOSSurfaceMVK(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetDebugUtilsObjectNameEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetDebugUtilsObjectTagEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueBeginDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueEndDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueInsertDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBeginDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdEndDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdInsertDebugUtilsLabelEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDebugUtilsMessengerEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyDebugUtilsMessengerEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSubmitDebugUtilsMessageEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetAndroidHardwareBufferPropertiesANDROID(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryAndroidHardwareBufferANDROID(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetSampleLocationsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceMultisamplePropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageDrmFormatModifierPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateValidationCacheEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyValidationCacheEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkMergeValidationCachesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetValidationCacheDataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindShadingRateImageNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetViewportShadingRatePaletteNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCoarseSampleOrderNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateAccelerationStructureNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyAccelerationStructureNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetAccelerationStructureMemoryRequirementsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBindAccelerationStructureMemoryNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBuildAccelerationStructureNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyAccelerationStructureNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdTraceRaysNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateRayTracingPipelinesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetRayTracingShaderGroupHandlesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetRayTracingShaderGroupHandlesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetAccelerationStructureHandleNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWriteAccelerationStructuresPropertiesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCompileDeferredNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryHostPointerPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWriteBufferMarkerAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetCalibratedTimestampsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawMeshTasksNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawMeshTasksIndirectNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawMeshTasksIndirectCountNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetExclusiveScissorEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetExclusiveScissorNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCheckpointNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetQueueCheckpointDataNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkInitializePerformanceApiINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkUninitializePerformanceApiINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetPerformanceMarkerINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetPerformanceStreamMarkerINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetPerformanceOverrideINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAcquirePerformanceConfigurationINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkReleasePerformanceConfigurationINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueSetPerformanceConfigurationINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPerformanceParameterINTEL(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetLocalDimmingAMD(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateImagePipeSurfaceFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateMetalSurfaceEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetBufferDeviceAddressEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceToolPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceSurfacePresentModes2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAcquireFullScreenExclusiveModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkReleaseFullScreenExclusiveModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceGroupSurfacePresentModes2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateHeadlessSurfaceEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetLineStippleEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkResetQueryPoolEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCullModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetFrontFaceEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetPrimitiveTopologyEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetViewportWithCountEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetScissorWithCountEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindVertexBuffers2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthTestEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthWriteEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthCompareOpEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthBoundsTestEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetStencilTestEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetStencilOpEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCopyMemoryToImageEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCopyImageToMemoryEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCopyImageToImageEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkTransitionImageLayoutEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetImageSubresourceLayout2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkReleaseSwapchainImagesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetGeneratedCommandsMemoryRequirementsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPreprocessGeneratedCommandsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdExecuteGeneratedCommandsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindPipelineShaderGroupNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateIndirectCommandsLayoutNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyIndirectCommandsLayoutNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthBias2EXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAcquireDrmDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDrmDisplayEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreatePrivateDataSlotEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyPrivateDataSlotEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetPrivateDataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPrivateDataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetFragmentShadingRateEnumNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceFaultInfoEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkAcquireWinrtDisplayNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetWinrtDisplayNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateDirectFBSurfaceEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetVertexInputEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryZirconHandleFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryZirconHandlePropertiesFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkImportSemaphoreZirconHandleFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetSemaphoreZirconHandleFUCHSIA(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindInvocationMaskHUAWEI(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMemoryRemoteAddressNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetPatchControlPointsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetRasterizerDiscardEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthBiasEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetLogicOpEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetPrimitiveRestartEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateScreenSurfaceQNX(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceScreenPresentationSupportQNX(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetColorWriteEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawMultiEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawMultiIndexedEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBuildMicromapsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBuildMicromapsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCopyMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCopyMicromapToMemoryEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCopyMemoryToMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkWriteMicromapsPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyMicromapToMemoryEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyMemoryToMicromapEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWriteMicromapsPropertiesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceMicromapCompatibilityEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetMicromapBuildSizesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawClusterHUAWEI(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawClusterIndirectHUAWEI(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetDeviceMemoryPriorityEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDescriptorSetLayoutHostMappingInfoVALVE(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDescriptorSetHostMappingVALVE(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPipelineIndirectMemoryRequirementsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdUpdatePipelineIndirectBufferNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPipelineIndirectDeviceAddressNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthClampEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetPolygonModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetRasterizationSamplesEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetSampleMaskEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetAlphaToCoverageEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetAlphaToOneEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetLogicOpEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetColorBlendEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetColorBlendEquationEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetColorWriteMaskEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetTessellationDomainOriginEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetRasterizationStreamEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetConservativeRasterizationModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetExtraPrimitiveOverestimationSizeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthClipEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetSampleLocationsEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetColorBlendAdvancedEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetProvokingVertexModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetLineRasterizationModeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetLineStippleEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetDepthClipNegativeOneToOneEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetViewportWScalingEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetViewportSwizzleNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCoverageToColorEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCoverageToColorLocationNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCoverageModulationModeNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCoverageModulationTableEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCoverageModulationTableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetShadingRateImageEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetRepresentativeFragmentTestEnableNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetCoverageReductionModeNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetShaderModuleIdentifierEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetShaderModuleCreateInfoIdentifierEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateOpticalFlowSessionNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyOpticalFlowSessionNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkBindOpticalFlowSessionImageNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdOpticalFlowExecuteNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateShadersEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyShaderEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetShaderBinaryDataEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBindShadersEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetFramebufferTilePropertiesQCOM(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDynamicRenderingTilePropertiesQCOM(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetLatencySleepModeNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkLatencySleepNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkSetLatencyMarkerNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetLatencyTimingsNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkQueueNotifyOutOfBandNV(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetAttachmentFeedbackLoopEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBuildAccelerationStructuresKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdBuildAccelerationStructuresIndirectKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCopyAccelerationStructureToMemoryKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCopyMemoryToAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkWriteAccelerationStructuresPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyAccelerationStructureToMemoryKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdCopyMemoryToAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetAccelerationStructureDeviceAddressKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdWriteAccelerationStructuresPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetDeviceAccelerationStructureCompatibilityKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetAccelerationStructureBuildSizesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdTraceRaysKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdTraceRaysIndirectKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetRayTracingShaderGroupStackSizeKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdSetRayTracingPipelineStackSizeKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawMeshTasksEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawMeshTasksIndirectEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdDrawMeshTasksIndirectCountEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); +}; + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) + +#endif diff --git a/framework/generated/generated_vulkan_preload_replayer.cpp b/framework/generated/generated_vulkan_preload_replayer.cpp new file mode 100644 index 0000000000..e27f74e10f --- /dev/null +++ b/framework/generated/generated_vulkan_preload_replayer.cpp @@ -0,0 +1,6310 @@ +/* +** Copyright (c) 2018-2023 Valve Corporation +** Copyright (c) 2018-2023 LunarG, Inc. +** Copyright (c) 2023 Advanced Micro Devices, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +/* +** This file is generated from the Khronos Vulkan XML API Registry. +** +*/ + +#include "decode/handle_pointer_decoder.h" +#include "decode/pointer_decoder.h" +#include "decode/string_array_decoder.h" +#include "decode/string_decoder.h" +#include "decode/struct_pointer_decoder.h" +#include "decode/value_decoder.h" +#include "decode/vulkan_pnext_node.h" +#include "generated/generated_vulkan_preload_replayer.h" +#include "generated/generated_vulkan_decoder.h" +#include "generated/generated_vulkan_struct_decoders_forward.h" +#include "generated/generated_vulkan_preload_decoder.h" +#include "generated/generated_vulkan_preload_replayer.h" +#include "util/defines.h" + +#include "vulkan/vulkan.h" +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#include "vk_video/vulkan_video_codecs_common.h" + +#include + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +void VulkanPreloadReplayer::Replay_vkCreateInstance(Packet_vkCreateInstance* packet) +{ + vulkan_replay_consumer_->Process_vkCreateInstance(packet->call_info, packet->return_value, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pInstance)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyInstance(Packet_vkDestroyInstance* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyInstance(packet->call_info, packet->instance, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkEnumeratePhysicalDevices(Packet_vkEnumeratePhysicalDevices* packet) +{ + vulkan_replay_consumer_->Process_vkEnumeratePhysicalDevices(packet->call_info, packet->return_value, packet->instance, &(packet->pPhysicalDeviceCount), &(packet->pPhysicalDevices)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceFeatures(Packet_vkGetPhysicalDeviceFeatures* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceFeatures(packet->call_info, packet->physicalDevice, &(packet->pFeatures)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceFormatProperties(Packet_vkGetPhysicalDeviceFormatProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceFormatProperties(packet->call_info, packet->physicalDevice, packet->format, &(packet->pFormatProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceImageFormatProperties(Packet_vkGetPhysicalDeviceImageFormatProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceImageFormatProperties(packet->call_info, packet->return_value, packet->physicalDevice, packet->format, packet->type, packet->tiling, packet->usage, packet->flags, &(packet->pImageFormatProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceProperties(Packet_vkGetPhysicalDeviceProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceProperties(packet->call_info, packet->physicalDevice, &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceQueueFamilyProperties(Packet_vkGetPhysicalDeviceQueueFamilyProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceQueueFamilyProperties(packet->call_info, packet->physicalDevice, &(packet->pQueueFamilyPropertyCount), &(packet->pQueueFamilyProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceMemoryProperties(Packet_vkGetPhysicalDeviceMemoryProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceMemoryProperties(packet->call_info, packet->physicalDevice, &(packet->pMemoryProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDevice(Packet_vkCreateDevice* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDevice(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pDevice)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyDevice(Packet_vkDestroyDevice* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyDevice(packet->call_info, packet->device, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceQueue(Packet_vkGetDeviceQueue* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceQueue(packet->call_info, packet->device, packet->queueFamilyIndex, packet->queueIndex, &(packet->pQueue)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueSubmit(Packet_vkQueueSubmit* packet) +{ + vulkan_replay_consumer_->Process_vkQueueSubmit(packet->call_info, packet->return_value, packet->queue, packet->submitCount, &(packet->pSubmits), packet->fence); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueWaitIdle(Packet_vkQueueWaitIdle* packet) +{ + vulkan_replay_consumer_->Process_vkQueueWaitIdle(packet->call_info, packet->return_value, packet->queue); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDeviceWaitIdle(Packet_vkDeviceWaitIdle* packet) +{ + vulkan_replay_consumer_->Process_vkDeviceWaitIdle(packet->call_info, packet->return_value, packet->device); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAllocateMemory(Packet_vkAllocateMemory* packet) +{ + vulkan_replay_consumer_->Process_vkAllocateMemory(packet->call_info, packet->return_value, packet->device, &(packet->pAllocateInfo), &(packet->pAllocator), &(packet->pMemory)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkFreeMemory(Packet_vkFreeMemory* packet) +{ + vulkan_replay_consumer_->Process_vkFreeMemory(packet->call_info, packet->device, packet->memory, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkMapMemory(Packet_vkMapMemory* packet) +{ + vulkan_replay_consumer_->Process_vkMapMemory(packet->call_info, packet->return_value, packet->device, packet->memory, packet->offset, packet->size, packet->flags, &(packet->ppData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkUnmapMemory(Packet_vkUnmapMemory* packet) +{ + vulkan_replay_consumer_->Process_vkUnmapMemory(packet->call_info, packet->device, packet->memory); + + return; +} + +void VulkanPreloadReplayer::Replay_vkFlushMappedMemoryRanges(Packet_vkFlushMappedMemoryRanges* packet) +{ + vulkan_replay_consumer_->Process_vkFlushMappedMemoryRanges(packet->call_info, packet->return_value, packet->device, packet->memoryRangeCount, &(packet->pMemoryRanges)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkInvalidateMappedMemoryRanges(Packet_vkInvalidateMappedMemoryRanges* packet) +{ + vulkan_replay_consumer_->Process_vkInvalidateMappedMemoryRanges(packet->call_info, packet->return_value, packet->device, packet->memoryRangeCount, &(packet->pMemoryRanges)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceMemoryCommitment(Packet_vkGetDeviceMemoryCommitment* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceMemoryCommitment(packet->call_info, packet->device, packet->memory, &(packet->pCommittedMemoryInBytes)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBindBufferMemory(Packet_vkBindBufferMemory* packet) +{ + vulkan_replay_consumer_->Process_vkBindBufferMemory(packet->call_info, packet->return_value, packet->device, packet->buffer, packet->memory, packet->memoryOffset); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBindImageMemory(Packet_vkBindImageMemory* packet) +{ + vulkan_replay_consumer_->Process_vkBindImageMemory(packet->call_info, packet->return_value, packet->device, packet->image, packet->memory, packet->memoryOffset); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetBufferMemoryRequirements(Packet_vkGetBufferMemoryRequirements* packet) +{ + vulkan_replay_consumer_->Process_vkGetBufferMemoryRequirements(packet->call_info, packet->device, packet->buffer, &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageMemoryRequirements(Packet_vkGetImageMemoryRequirements* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageMemoryRequirements(packet->call_info, packet->device, packet->image, &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageSparseMemoryRequirements(Packet_vkGetImageSparseMemoryRequirements* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageSparseMemoryRequirements(packet->call_info, packet->device, packet->image, &(packet->pSparseMemoryRequirementCount), &(packet->pSparseMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSparseImageFormatProperties(Packet_vkGetPhysicalDeviceSparseImageFormatProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSparseImageFormatProperties(packet->call_info, packet->physicalDevice, packet->format, packet->type, packet->samples, packet->usage, packet->tiling, &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueBindSparse(Packet_vkQueueBindSparse* packet) +{ + vulkan_replay_consumer_->Process_vkQueueBindSparse(packet->call_info, packet->return_value, packet->queue, packet->bindInfoCount, &(packet->pBindInfo), packet->fence); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateFence(Packet_vkCreateFence* packet) +{ + vulkan_replay_consumer_->Process_vkCreateFence(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pFence)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyFence(Packet_vkDestroyFence* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyFence(packet->call_info, packet->device, packet->fence, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkResetFences(Packet_vkResetFences* packet) +{ + vulkan_replay_consumer_->Process_vkResetFences(packet->call_info, packet->return_value, packet->device, packet->fenceCount, &(packet->pFences)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetFenceStatus(Packet_vkGetFenceStatus* packet) +{ + vulkan_replay_consumer_->Process_vkGetFenceStatus(packet->call_info, packet->return_value, packet->device, packet->fence); + + return; +} + +void VulkanPreloadReplayer::Replay_vkWaitForFences(Packet_vkWaitForFences* packet) +{ + vulkan_replay_consumer_->Process_vkWaitForFences(packet->call_info, packet->return_value, packet->device, packet->fenceCount, &(packet->pFences), packet->waitAll, packet->timeout); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateSemaphore(Packet_vkCreateSemaphore* packet) +{ + vulkan_replay_consumer_->Process_vkCreateSemaphore(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSemaphore)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroySemaphore(Packet_vkDestroySemaphore* packet) +{ + vulkan_replay_consumer_->Process_vkDestroySemaphore(packet->call_info, packet->device, packet->semaphore, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateEvent(Packet_vkCreateEvent* packet) +{ + vulkan_replay_consumer_->Process_vkCreateEvent(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pEvent)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyEvent(Packet_vkDestroyEvent* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyEvent(packet->call_info, packet->device, packet->event, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetEventStatus(Packet_vkGetEventStatus* packet) +{ + vulkan_replay_consumer_->Process_vkGetEventStatus(packet->call_info, packet->return_value, packet->device, packet->event); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetEvent(Packet_vkSetEvent* packet) +{ + vulkan_replay_consumer_->Process_vkSetEvent(packet->call_info, packet->return_value, packet->device, packet->event); + + return; +} + +void VulkanPreloadReplayer::Replay_vkResetEvent(Packet_vkResetEvent* packet) +{ + vulkan_replay_consumer_->Process_vkResetEvent(packet->call_info, packet->return_value, packet->device, packet->event); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateQueryPool(Packet_vkCreateQueryPool* packet) +{ + vulkan_replay_consumer_->Process_vkCreateQueryPool(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pQueryPool)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyQueryPool(Packet_vkDestroyQueryPool* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyQueryPool(packet->call_info, packet->device, packet->queryPool, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetQueryPoolResults(Packet_vkGetQueryPoolResults* packet) +{ + vulkan_replay_consumer_->Process_vkGetQueryPoolResults(packet->call_info, packet->return_value, packet->device, packet->queryPool, packet->firstQuery, packet->queryCount, packet->dataSize, &(packet->pData), packet->stride, packet->flags); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateBuffer(Packet_vkCreateBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkCreateBuffer(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pBuffer)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyBuffer(Packet_vkDestroyBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyBuffer(packet->call_info, packet->device, packet->buffer, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateBufferView(Packet_vkCreateBufferView* packet) +{ + vulkan_replay_consumer_->Process_vkCreateBufferView(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pView)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyBufferView(Packet_vkDestroyBufferView* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyBufferView(packet->call_info, packet->device, packet->bufferView, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateImage(Packet_vkCreateImage* packet) +{ + vulkan_replay_consumer_->Process_vkCreateImage(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pImage)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyImage(Packet_vkDestroyImage* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyImage(packet->call_info, packet->device, packet->image, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageSubresourceLayout(Packet_vkGetImageSubresourceLayout* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageSubresourceLayout(packet->call_info, packet->device, packet->image, &(packet->pSubresource), &(packet->pLayout)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateImageView(Packet_vkCreateImageView* packet) +{ + vulkan_replay_consumer_->Process_vkCreateImageView(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pView)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyImageView(Packet_vkDestroyImageView* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyImageView(packet->call_info, packet->device, packet->imageView, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateShaderModule(Packet_vkCreateShaderModule* packet) +{ + vulkan_replay_consumer_->Process_vkCreateShaderModule(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pShaderModule)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyShaderModule(Packet_vkDestroyShaderModule* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyShaderModule(packet->call_info, packet->device, packet->shaderModule, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreatePipelineCache(Packet_vkCreatePipelineCache* packet) +{ + vulkan_replay_consumer_->Process_vkCreatePipelineCache(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pPipelineCache)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyPipelineCache(Packet_vkDestroyPipelineCache* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyPipelineCache(packet->call_info, packet->device, packet->pipelineCache, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPipelineCacheData(Packet_vkGetPipelineCacheData* packet) +{ + vulkan_replay_consumer_->Process_vkGetPipelineCacheData(packet->call_info, packet->return_value, packet->device, packet->pipelineCache, &(packet->pDataSize), &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkMergePipelineCaches(Packet_vkMergePipelineCaches* packet) +{ + vulkan_replay_consumer_->Process_vkMergePipelineCaches(packet->call_info, packet->return_value, packet->device, packet->dstCache, packet->srcCacheCount, &(packet->pSrcCaches)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateGraphicsPipelines(Packet_vkCreateGraphicsPipelines* packet) +{ + vulkan_replay_consumer_->Process_vkCreateGraphicsPipelines(packet->call_info, packet->return_value, packet->device, packet->pipelineCache, packet->createInfoCount, &(packet->pCreateInfos), &(packet->pAllocator), &(packet->pPipelines)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateComputePipelines(Packet_vkCreateComputePipelines* packet) +{ + vulkan_replay_consumer_->Process_vkCreateComputePipelines(packet->call_info, packet->return_value, packet->device, packet->pipelineCache, packet->createInfoCount, &(packet->pCreateInfos), &(packet->pAllocator), &(packet->pPipelines)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyPipeline(Packet_vkDestroyPipeline* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyPipeline(packet->call_info, packet->device, packet->pipeline, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreatePipelineLayout(Packet_vkCreatePipelineLayout* packet) +{ + vulkan_replay_consumer_->Process_vkCreatePipelineLayout(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pPipelineLayout)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyPipelineLayout(Packet_vkDestroyPipelineLayout* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyPipelineLayout(packet->call_info, packet->device, packet->pipelineLayout, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateSampler(Packet_vkCreateSampler* packet) +{ + vulkan_replay_consumer_->Process_vkCreateSampler(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSampler)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroySampler(Packet_vkDestroySampler* packet) +{ + vulkan_replay_consumer_->Process_vkDestroySampler(packet->call_info, packet->device, packet->sampler, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDescriptorSetLayout(Packet_vkCreateDescriptorSetLayout* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDescriptorSetLayout(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSetLayout)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyDescriptorSetLayout(Packet_vkDestroyDescriptorSetLayout* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyDescriptorSetLayout(packet->call_info, packet->device, packet->descriptorSetLayout, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDescriptorPool(Packet_vkCreateDescriptorPool* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDescriptorPool(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pDescriptorPool)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyDescriptorPool(Packet_vkDestroyDescriptorPool* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyDescriptorPool(packet->call_info, packet->device, packet->descriptorPool, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkResetDescriptorPool(Packet_vkResetDescriptorPool* packet) +{ + vulkan_replay_consumer_->Process_vkResetDescriptorPool(packet->call_info, packet->return_value, packet->device, packet->descriptorPool, packet->flags); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAllocateDescriptorSets(Packet_vkAllocateDescriptorSets* packet) +{ + vulkan_replay_consumer_->Process_vkAllocateDescriptorSets(packet->call_info, packet->return_value, packet->device, &(packet->pAllocateInfo), &(packet->pDescriptorSets)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkFreeDescriptorSets(Packet_vkFreeDescriptorSets* packet) +{ + vulkan_replay_consumer_->Process_vkFreeDescriptorSets(packet->call_info, packet->return_value, packet->device, packet->descriptorPool, packet->descriptorSetCount, &(packet->pDescriptorSets)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkUpdateDescriptorSets(Packet_vkUpdateDescriptorSets* packet) +{ + vulkan_replay_consumer_->Process_vkUpdateDescriptorSets(packet->call_info, packet->device, packet->descriptorWriteCount, &(packet->pDescriptorWrites), packet->descriptorCopyCount, &(packet->pDescriptorCopies)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateFramebuffer(Packet_vkCreateFramebuffer* packet) +{ + vulkan_replay_consumer_->Process_vkCreateFramebuffer(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pFramebuffer)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyFramebuffer(Packet_vkDestroyFramebuffer* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyFramebuffer(packet->call_info, packet->device, packet->framebuffer, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateRenderPass(Packet_vkCreateRenderPass* packet) +{ + vulkan_replay_consumer_->Process_vkCreateRenderPass(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pRenderPass)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyRenderPass(Packet_vkDestroyRenderPass* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyRenderPass(packet->call_info, packet->device, packet->renderPass, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetRenderAreaGranularity(Packet_vkGetRenderAreaGranularity* packet) +{ + vulkan_replay_consumer_->Process_vkGetRenderAreaGranularity(packet->call_info, packet->device, packet->renderPass, &(packet->pGranularity)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateCommandPool(Packet_vkCreateCommandPool* packet) +{ + vulkan_replay_consumer_->Process_vkCreateCommandPool(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pCommandPool)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyCommandPool(Packet_vkDestroyCommandPool* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyCommandPool(packet->call_info, packet->device, packet->commandPool, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkResetCommandPool(Packet_vkResetCommandPool* packet) +{ + vulkan_replay_consumer_->Process_vkResetCommandPool(packet->call_info, packet->return_value, packet->device, packet->commandPool, packet->flags); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAllocateCommandBuffers(Packet_vkAllocateCommandBuffers* packet) +{ + vulkan_replay_consumer_->Process_vkAllocateCommandBuffers(packet->call_info, packet->return_value, packet->device, &(packet->pAllocateInfo), &(packet->pCommandBuffers)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkFreeCommandBuffers(Packet_vkFreeCommandBuffers* packet) +{ + vulkan_replay_consumer_->Process_vkFreeCommandBuffers(packet->call_info, packet->device, packet->commandPool, packet->commandBufferCount, &(packet->pCommandBuffers)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBeginCommandBuffer(Packet_vkBeginCommandBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkBeginCommandBuffer(packet->call_info, packet->return_value, packet->commandBuffer, &(packet->pBeginInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkEndCommandBuffer(Packet_vkEndCommandBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkEndCommandBuffer(packet->call_info, packet->return_value, packet->commandBuffer); + + return; +} + +void VulkanPreloadReplayer::Replay_vkResetCommandBuffer(Packet_vkResetCommandBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkResetCommandBuffer(packet->call_info, packet->return_value, packet->commandBuffer, packet->flags); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindPipeline(Packet_vkCmdBindPipeline* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindPipeline(packet->call_info, packet->commandBuffer, packet->pipelineBindPoint, packet->pipeline); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetViewport(Packet_vkCmdSetViewport* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetViewport(packet->call_info, packet->commandBuffer, packet->firstViewport, packet->viewportCount, &(packet->pViewports)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetScissor(Packet_vkCmdSetScissor* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetScissor(packet->call_info, packet->commandBuffer, packet->firstScissor, packet->scissorCount, &(packet->pScissors)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetLineWidth(Packet_vkCmdSetLineWidth* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetLineWidth(packet->call_info, packet->commandBuffer, packet->lineWidth); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthBias(Packet_vkCmdSetDepthBias* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthBias(packet->call_info, packet->commandBuffer, packet->depthBiasConstantFactor, packet->depthBiasClamp, packet->depthBiasSlopeFactor); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetBlendConstants(Packet_vkCmdSetBlendConstants* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetBlendConstants(packet->call_info, packet->commandBuffer, &(packet->blendConstants)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthBounds(Packet_vkCmdSetDepthBounds* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthBounds(packet->call_info, packet->commandBuffer, packet->minDepthBounds, packet->maxDepthBounds); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetStencilCompareMask(Packet_vkCmdSetStencilCompareMask* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetStencilCompareMask(packet->call_info, packet->commandBuffer, packet->faceMask, packet->compareMask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetStencilWriteMask(Packet_vkCmdSetStencilWriteMask* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetStencilWriteMask(packet->call_info, packet->commandBuffer, packet->faceMask, packet->writeMask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetStencilReference(Packet_vkCmdSetStencilReference* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetStencilReference(packet->call_info, packet->commandBuffer, packet->faceMask, packet->reference); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindDescriptorSets(Packet_vkCmdBindDescriptorSets* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindDescriptorSets(packet->call_info, packet->commandBuffer, packet->pipelineBindPoint, packet->layout, packet->firstSet, packet->descriptorSetCount, &(packet->pDescriptorSets), packet->dynamicOffsetCount, &(packet->pDynamicOffsets)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindIndexBuffer(Packet_vkCmdBindIndexBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindIndexBuffer(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->indexType); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindVertexBuffers(Packet_vkCmdBindVertexBuffers* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindVertexBuffers(packet->call_info, packet->commandBuffer, packet->firstBinding, packet->bindingCount, &(packet->pBuffers), &(packet->pOffsets)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDraw(Packet_vkCmdDraw* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDraw(packet->call_info, packet->commandBuffer, packet->vertexCount, packet->instanceCount, packet->firstVertex, packet->firstInstance); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndexed(Packet_vkCmdDrawIndexed* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndexed(packet->call_info, packet->commandBuffer, packet->indexCount, packet->instanceCount, packet->firstIndex, packet->vertexOffset, packet->firstInstance); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndirect(Packet_vkCmdDrawIndirect* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndirect(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->drawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndexedIndirect(Packet_vkCmdDrawIndexedIndirect* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndexedIndirect(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->drawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDispatch(Packet_vkCmdDispatch* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDispatch(packet->call_info, packet->commandBuffer, packet->groupCountX, packet->groupCountY, packet->groupCountZ); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDispatchIndirect(Packet_vkCmdDispatchIndirect* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDispatchIndirect(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyBuffer(Packet_vkCmdCopyBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyBuffer(packet->call_info, packet->commandBuffer, packet->srcBuffer, packet->dstBuffer, packet->regionCount, &(packet->pRegions)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyImage(Packet_vkCmdCopyImage* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyImage(packet->call_info, packet->commandBuffer, packet->srcImage, packet->srcImageLayout, packet->dstImage, packet->dstImageLayout, packet->regionCount, &(packet->pRegions)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBlitImage(Packet_vkCmdBlitImage* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBlitImage(packet->call_info, packet->commandBuffer, packet->srcImage, packet->srcImageLayout, packet->dstImage, packet->dstImageLayout, packet->regionCount, &(packet->pRegions), packet->filter); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyBufferToImage(Packet_vkCmdCopyBufferToImage* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyBufferToImage(packet->call_info, packet->commandBuffer, packet->srcBuffer, packet->dstImage, packet->dstImageLayout, packet->regionCount, &(packet->pRegions)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyImageToBuffer(Packet_vkCmdCopyImageToBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyImageToBuffer(packet->call_info, packet->commandBuffer, packet->srcImage, packet->srcImageLayout, packet->dstBuffer, packet->regionCount, &(packet->pRegions)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdUpdateBuffer(Packet_vkCmdUpdateBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkCmdUpdateBuffer(packet->call_info, packet->commandBuffer, packet->dstBuffer, packet->dstOffset, packet->dataSize, &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdFillBuffer(Packet_vkCmdFillBuffer* packet) +{ + vulkan_replay_consumer_->Process_vkCmdFillBuffer(packet->call_info, packet->commandBuffer, packet->dstBuffer, packet->dstOffset, packet->size, packet->data); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdClearColorImage(Packet_vkCmdClearColorImage* packet) +{ + vulkan_replay_consumer_->Process_vkCmdClearColorImage(packet->call_info, packet->commandBuffer, packet->image, packet->imageLayout, &(packet->pColor), packet->rangeCount, &(packet->pRanges)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdClearDepthStencilImage(Packet_vkCmdClearDepthStencilImage* packet) +{ + vulkan_replay_consumer_->Process_vkCmdClearDepthStencilImage(packet->call_info, packet->commandBuffer, packet->image, packet->imageLayout, &(packet->pDepthStencil), packet->rangeCount, &(packet->pRanges)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdClearAttachments(Packet_vkCmdClearAttachments* packet) +{ + vulkan_replay_consumer_->Process_vkCmdClearAttachments(packet->call_info, packet->commandBuffer, packet->attachmentCount, &(packet->pAttachments), packet->rectCount, &(packet->pRects)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdResolveImage(Packet_vkCmdResolveImage* packet) +{ + vulkan_replay_consumer_->Process_vkCmdResolveImage(packet->call_info, packet->commandBuffer, packet->srcImage, packet->srcImageLayout, packet->dstImage, packet->dstImageLayout, packet->regionCount, &(packet->pRegions)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetEvent(Packet_vkCmdSetEvent* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetEvent(packet->call_info, packet->commandBuffer, packet->event, packet->stageMask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdResetEvent(Packet_vkCmdResetEvent* packet) +{ + vulkan_replay_consumer_->Process_vkCmdResetEvent(packet->call_info, packet->commandBuffer, packet->event, packet->stageMask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWaitEvents(Packet_vkCmdWaitEvents* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWaitEvents(packet->call_info, packet->commandBuffer, packet->eventCount, &(packet->pEvents), packet->srcStageMask, packet->dstStageMask, packet->memoryBarrierCount, &(packet->pMemoryBarriers), packet->bufferMemoryBarrierCount, &(packet->pBufferMemoryBarriers), packet->imageMemoryBarrierCount, &(packet->pImageMemoryBarriers)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdPipelineBarrier(Packet_vkCmdPipelineBarrier* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPipelineBarrier(packet->call_info, packet->commandBuffer, packet->srcStageMask, packet->dstStageMask, packet->dependencyFlags, packet->memoryBarrierCount, &(packet->pMemoryBarriers), packet->bufferMemoryBarrierCount, &(packet->pBufferMemoryBarriers), packet->imageMemoryBarrierCount, &(packet->pImageMemoryBarriers)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginQuery(Packet_vkCmdBeginQuery* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginQuery(packet->call_info, packet->commandBuffer, packet->queryPool, packet->query, packet->flags); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndQuery(Packet_vkCmdEndQuery* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndQuery(packet->call_info, packet->commandBuffer, packet->queryPool, packet->query); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdResetQueryPool(Packet_vkCmdResetQueryPool* packet) +{ + vulkan_replay_consumer_->Process_vkCmdResetQueryPool(packet->call_info, packet->commandBuffer, packet->queryPool, packet->firstQuery, packet->queryCount); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWriteTimestamp(Packet_vkCmdWriteTimestamp* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWriteTimestamp(packet->call_info, packet->commandBuffer, packet->pipelineStage, packet->queryPool, packet->query); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyQueryPoolResults(Packet_vkCmdCopyQueryPoolResults* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyQueryPoolResults(packet->call_info, packet->commandBuffer, packet->queryPool, packet->firstQuery, packet->queryCount, packet->dstBuffer, packet->dstOffset, packet->stride, packet->flags); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdPushConstants(Packet_vkCmdPushConstants* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPushConstants(packet->call_info, packet->commandBuffer, packet->layout, packet->stageFlags, packet->offset, packet->size, &(packet->pValues)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginRenderPass(Packet_vkCmdBeginRenderPass* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginRenderPass(packet->call_info, packet->commandBuffer, &(packet->pRenderPassBegin), packet->contents); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdNextSubpass(Packet_vkCmdNextSubpass* packet) +{ + vulkan_replay_consumer_->Process_vkCmdNextSubpass(packet->call_info, packet->commandBuffer, packet->contents); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndRenderPass(Packet_vkCmdEndRenderPass* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndRenderPass(packet->call_info, packet->commandBuffer); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdExecuteCommands(Packet_vkCmdExecuteCommands* packet) +{ + vulkan_replay_consumer_->Process_vkCmdExecuteCommands(packet->call_info, packet->commandBuffer, packet->commandBufferCount, &(packet->pCommandBuffers)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBindBufferMemory2(Packet_vkBindBufferMemory2* packet) +{ + vulkan_replay_consumer_->Process_vkBindBufferMemory2(packet->call_info, packet->return_value, packet->device, packet->bindInfoCount, &(packet->pBindInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBindImageMemory2(Packet_vkBindImageMemory2* packet) +{ + vulkan_replay_consumer_->Process_vkBindImageMemory2(packet->call_info, packet->return_value, packet->device, packet->bindInfoCount, &(packet->pBindInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceGroupPeerMemoryFeatures(Packet_vkGetDeviceGroupPeerMemoryFeatures* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceGroupPeerMemoryFeatures(packet->call_info, packet->device, packet->heapIndex, packet->localDeviceIndex, packet->remoteDeviceIndex, &(packet->pPeerMemoryFeatures)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDeviceMask(Packet_vkCmdSetDeviceMask* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDeviceMask(packet->call_info, packet->commandBuffer, packet->deviceMask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDispatchBase(Packet_vkCmdDispatchBase* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDispatchBase(packet->call_info, packet->commandBuffer, packet->baseGroupX, packet->baseGroupY, packet->baseGroupZ, packet->groupCountX, packet->groupCountY, packet->groupCountZ); + + return; +} + +void VulkanPreloadReplayer::Replay_vkEnumeratePhysicalDeviceGroups(Packet_vkEnumeratePhysicalDeviceGroups* packet) +{ + vulkan_replay_consumer_->Process_vkEnumeratePhysicalDeviceGroups(packet->call_info, packet->return_value, packet->instance, &(packet->pPhysicalDeviceGroupCount), &(packet->pPhysicalDeviceGroupProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageMemoryRequirements2(Packet_vkGetImageMemoryRequirements2* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageMemoryRequirements2(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetBufferMemoryRequirements2(Packet_vkGetBufferMemoryRequirements2* packet) +{ + vulkan_replay_consumer_->Process_vkGetBufferMemoryRequirements2(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageSparseMemoryRequirements2(Packet_vkGetImageSparseMemoryRequirements2* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageSparseMemoryRequirements2(packet->call_info, packet->device, &(packet->pInfo), &(packet->pSparseMemoryRequirementCount), &(packet->pSparseMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceFeatures2(Packet_vkGetPhysicalDeviceFeatures2* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceFeatures2(packet->call_info, packet->physicalDevice, &(packet->pFeatures)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceProperties2(Packet_vkGetPhysicalDeviceProperties2* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceProperties2(packet->call_info, packet->physicalDevice, &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceFormatProperties2(Packet_vkGetPhysicalDeviceFormatProperties2* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceFormatProperties2(packet->call_info, packet->physicalDevice, packet->format, &(packet->pFormatProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceImageFormatProperties2(Packet_vkGetPhysicalDeviceImageFormatProperties2* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceImageFormatProperties2(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pImageFormatInfo), &(packet->pImageFormatProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceQueueFamilyProperties2(Packet_vkGetPhysicalDeviceQueueFamilyProperties2* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceQueueFamilyProperties2(packet->call_info, packet->physicalDevice, &(packet->pQueueFamilyPropertyCount), &(packet->pQueueFamilyProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceMemoryProperties2(Packet_vkGetPhysicalDeviceMemoryProperties2* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceMemoryProperties2(packet->call_info, packet->physicalDevice, &(packet->pMemoryProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSparseImageFormatProperties2(Packet_vkGetPhysicalDeviceSparseImageFormatProperties2* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSparseImageFormatProperties2(packet->call_info, packet->physicalDevice, &(packet->pFormatInfo), &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkTrimCommandPool(Packet_vkTrimCommandPool* packet) +{ + vulkan_replay_consumer_->Process_vkTrimCommandPool(packet->call_info, packet->device, packet->commandPool, packet->flags); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceQueue2(Packet_vkGetDeviceQueue2* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceQueue2(packet->call_info, packet->device, &(packet->pQueueInfo), &(packet->pQueue)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateSamplerYcbcrConversion(Packet_vkCreateSamplerYcbcrConversion* packet) +{ + vulkan_replay_consumer_->Process_vkCreateSamplerYcbcrConversion(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pYcbcrConversion)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroySamplerYcbcrConversion(Packet_vkDestroySamplerYcbcrConversion* packet) +{ + vulkan_replay_consumer_->Process_vkDestroySamplerYcbcrConversion(packet->call_info, packet->device, packet->ycbcrConversion, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDescriptorUpdateTemplate(Packet_vkCreateDescriptorUpdateTemplate* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDescriptorUpdateTemplate(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pDescriptorUpdateTemplate)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyDescriptorUpdateTemplate(Packet_vkDestroyDescriptorUpdateTemplate* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyDescriptorUpdateTemplate(packet->call_info, packet->device, packet->descriptorUpdateTemplate, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceExternalBufferProperties(Packet_vkGetPhysicalDeviceExternalBufferProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceExternalBufferProperties(packet->call_info, packet->physicalDevice, &(packet->pExternalBufferInfo), &(packet->pExternalBufferProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceExternalFenceProperties(Packet_vkGetPhysicalDeviceExternalFenceProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceExternalFenceProperties(packet->call_info, packet->physicalDevice, &(packet->pExternalFenceInfo), &(packet->pExternalFenceProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceExternalSemaphoreProperties(Packet_vkGetPhysicalDeviceExternalSemaphoreProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceExternalSemaphoreProperties(packet->call_info, packet->physicalDevice, &(packet->pExternalSemaphoreInfo), &(packet->pExternalSemaphoreProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDescriptorSetLayoutSupport(Packet_vkGetDescriptorSetLayoutSupport* packet) +{ + vulkan_replay_consumer_->Process_vkGetDescriptorSetLayoutSupport(packet->call_info, packet->device, &(packet->pCreateInfo), &(packet->pSupport)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndirectCount(Packet_vkCmdDrawIndirectCount* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndirectCount(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->countBuffer, packet->countBufferOffset, packet->maxDrawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndexedIndirectCount(Packet_vkCmdDrawIndexedIndirectCount* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndexedIndirectCount(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->countBuffer, packet->countBufferOffset, packet->maxDrawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateRenderPass2(Packet_vkCreateRenderPass2* packet) +{ + vulkan_replay_consumer_->Process_vkCreateRenderPass2(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pRenderPass)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginRenderPass2(Packet_vkCmdBeginRenderPass2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginRenderPass2(packet->call_info, packet->commandBuffer, &(packet->pRenderPassBegin), &(packet->pSubpassBeginInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdNextSubpass2(Packet_vkCmdNextSubpass2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdNextSubpass2(packet->call_info, packet->commandBuffer, &(packet->pSubpassBeginInfo), &(packet->pSubpassEndInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndRenderPass2(Packet_vkCmdEndRenderPass2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndRenderPass2(packet->call_info, packet->commandBuffer, &(packet->pSubpassEndInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkResetQueryPool(Packet_vkResetQueryPool* packet) +{ + vulkan_replay_consumer_->Process_vkResetQueryPool(packet->call_info, packet->device, packet->queryPool, packet->firstQuery, packet->queryCount); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetSemaphoreCounterValue(Packet_vkGetSemaphoreCounterValue* packet) +{ + vulkan_replay_consumer_->Process_vkGetSemaphoreCounterValue(packet->call_info, packet->return_value, packet->device, packet->semaphore, &(packet->pValue)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkWaitSemaphores(Packet_vkWaitSemaphores* packet) +{ + vulkan_replay_consumer_->Process_vkWaitSemaphores(packet->call_info, packet->return_value, packet->device, &(packet->pWaitInfo), packet->timeout); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSignalSemaphore(Packet_vkSignalSemaphore* packet) +{ + vulkan_replay_consumer_->Process_vkSignalSemaphore(packet->call_info, packet->return_value, packet->device, &(packet->pSignalInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetBufferDeviceAddress(Packet_vkGetBufferDeviceAddress* packet) +{ + vulkan_replay_consumer_->Process_vkGetBufferDeviceAddress(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetBufferOpaqueCaptureAddress(Packet_vkGetBufferOpaqueCaptureAddress* packet) +{ + vulkan_replay_consumer_->Process_vkGetBufferOpaqueCaptureAddress(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceMemoryOpaqueCaptureAddress(Packet_vkGetDeviceMemoryOpaqueCaptureAddress* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceMemoryOpaqueCaptureAddress(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceToolProperties(Packet_vkGetPhysicalDeviceToolProperties* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceToolProperties(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pToolCount), &(packet->pToolProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreatePrivateDataSlot(Packet_vkCreatePrivateDataSlot* packet) +{ + vulkan_replay_consumer_->Process_vkCreatePrivateDataSlot(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pPrivateDataSlot)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyPrivateDataSlot(Packet_vkDestroyPrivateDataSlot* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyPrivateDataSlot(packet->call_info, packet->device, packet->privateDataSlot, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetPrivateData(Packet_vkSetPrivateData* packet) +{ + vulkan_replay_consumer_->Process_vkSetPrivateData(packet->call_info, packet->return_value, packet->device, packet->objectType, packet->objectHandle, packet->privateDataSlot, packet->data); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPrivateData(Packet_vkGetPrivateData* packet) +{ + vulkan_replay_consumer_->Process_vkGetPrivateData(packet->call_info, packet->device, packet->objectType, packet->objectHandle, packet->privateDataSlot, &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetEvent2(Packet_vkCmdSetEvent2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetEvent2(packet->call_info, packet->commandBuffer, packet->event, &(packet->pDependencyInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdResetEvent2(Packet_vkCmdResetEvent2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdResetEvent2(packet->call_info, packet->commandBuffer, packet->event, packet->stageMask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWaitEvents2(Packet_vkCmdWaitEvents2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWaitEvents2(packet->call_info, packet->commandBuffer, packet->eventCount, &(packet->pEvents), &(packet->pDependencyInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdPipelineBarrier2(Packet_vkCmdPipelineBarrier2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPipelineBarrier2(packet->call_info, packet->commandBuffer, &(packet->pDependencyInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWriteTimestamp2(Packet_vkCmdWriteTimestamp2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWriteTimestamp2(packet->call_info, packet->commandBuffer, packet->stage, packet->queryPool, packet->query); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueSubmit2(Packet_vkQueueSubmit2* packet) +{ + vulkan_replay_consumer_->Process_vkQueueSubmit2(packet->call_info, packet->return_value, packet->queue, packet->submitCount, &(packet->pSubmits), packet->fence); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyBuffer2(Packet_vkCmdCopyBuffer2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyBuffer2(packet->call_info, packet->commandBuffer, &(packet->pCopyBufferInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyImage2(Packet_vkCmdCopyImage2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyImage2(packet->call_info, packet->commandBuffer, &(packet->pCopyImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyBufferToImage2(Packet_vkCmdCopyBufferToImage2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyBufferToImage2(packet->call_info, packet->commandBuffer, &(packet->pCopyBufferToImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyImageToBuffer2(Packet_vkCmdCopyImageToBuffer2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyImageToBuffer2(packet->call_info, packet->commandBuffer, &(packet->pCopyImageToBufferInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBlitImage2(Packet_vkCmdBlitImage2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBlitImage2(packet->call_info, packet->commandBuffer, &(packet->pBlitImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdResolveImage2(Packet_vkCmdResolveImage2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdResolveImage2(packet->call_info, packet->commandBuffer, &(packet->pResolveImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginRendering(Packet_vkCmdBeginRendering* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginRendering(packet->call_info, packet->commandBuffer, &(packet->pRenderingInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndRendering(Packet_vkCmdEndRendering* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndRendering(packet->call_info, packet->commandBuffer); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCullMode(Packet_vkCmdSetCullMode* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCullMode(packet->call_info, packet->commandBuffer, packet->cullMode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetFrontFace(Packet_vkCmdSetFrontFace* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetFrontFace(packet->call_info, packet->commandBuffer, packet->frontFace); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetPrimitiveTopology(Packet_vkCmdSetPrimitiveTopology* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetPrimitiveTopology(packet->call_info, packet->commandBuffer, packet->primitiveTopology); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetViewportWithCount(Packet_vkCmdSetViewportWithCount* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetViewportWithCount(packet->call_info, packet->commandBuffer, packet->viewportCount, &(packet->pViewports)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetScissorWithCount(Packet_vkCmdSetScissorWithCount* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetScissorWithCount(packet->call_info, packet->commandBuffer, packet->scissorCount, &(packet->pScissors)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindVertexBuffers2(Packet_vkCmdBindVertexBuffers2* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindVertexBuffers2(packet->call_info, packet->commandBuffer, packet->firstBinding, packet->bindingCount, &(packet->pBuffers), &(packet->pOffsets), &(packet->pSizes), &(packet->pStrides)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthTestEnable(Packet_vkCmdSetDepthTestEnable* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthTestEnable(packet->call_info, packet->commandBuffer, packet->depthTestEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthWriteEnable(Packet_vkCmdSetDepthWriteEnable* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthWriteEnable(packet->call_info, packet->commandBuffer, packet->depthWriteEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthCompareOp(Packet_vkCmdSetDepthCompareOp* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthCompareOp(packet->call_info, packet->commandBuffer, packet->depthCompareOp); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthBoundsTestEnable(Packet_vkCmdSetDepthBoundsTestEnable* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthBoundsTestEnable(packet->call_info, packet->commandBuffer, packet->depthBoundsTestEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetStencilTestEnable(Packet_vkCmdSetStencilTestEnable* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetStencilTestEnable(packet->call_info, packet->commandBuffer, packet->stencilTestEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetStencilOp(Packet_vkCmdSetStencilOp* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetStencilOp(packet->call_info, packet->commandBuffer, packet->faceMask, packet->failOp, packet->passOp, packet->depthFailOp, packet->compareOp); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetRasterizerDiscardEnable(Packet_vkCmdSetRasterizerDiscardEnable* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetRasterizerDiscardEnable(packet->call_info, packet->commandBuffer, packet->rasterizerDiscardEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthBiasEnable(Packet_vkCmdSetDepthBiasEnable* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthBiasEnable(packet->call_info, packet->commandBuffer, packet->depthBiasEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetPrimitiveRestartEnable(Packet_vkCmdSetPrimitiveRestartEnable* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetPrimitiveRestartEnable(packet->call_info, packet->commandBuffer, packet->primitiveRestartEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceBufferMemoryRequirements(Packet_vkGetDeviceBufferMemoryRequirements* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceBufferMemoryRequirements(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceImageMemoryRequirements(Packet_vkGetDeviceImageMemoryRequirements* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceImageMemoryRequirements(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceImageSparseMemoryRequirements(Packet_vkGetDeviceImageSparseMemoryRequirements* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceImageSparseMemoryRequirements(packet->call_info, packet->device, &(packet->pInfo), &(packet->pSparseMemoryRequirementCount), &(packet->pSparseMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroySurfaceKHR(Packet_vkDestroySurfaceKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDestroySurfaceKHR(packet->call_info, packet->instance, packet->surface, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSurfaceSupportKHR(Packet_vkGetPhysicalDeviceSurfaceSupportKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSurfaceSupportKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->queueFamilyIndex, packet->surface, &(packet->pSupported)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(Packet_vkGetPhysicalDeviceSurfaceCapabilitiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->surface, &(packet->pSurfaceCapabilities)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSurfaceFormatsKHR(Packet_vkGetPhysicalDeviceSurfaceFormatsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSurfaceFormatsKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->surface, &(packet->pSurfaceFormatCount), &(packet->pSurfaceFormats)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSurfacePresentModesKHR(Packet_vkGetPhysicalDeviceSurfacePresentModesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSurfacePresentModesKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->surface, &(packet->pPresentModeCount), &(packet->pPresentModes)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateSwapchainKHR(Packet_vkCreateSwapchainKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateSwapchainKHR(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSwapchain)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroySwapchainKHR(Packet_vkDestroySwapchainKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDestroySwapchainKHR(packet->call_info, packet->device, packet->swapchain, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetSwapchainImagesKHR(Packet_vkGetSwapchainImagesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetSwapchainImagesKHR(packet->call_info, packet->return_value, packet->device, packet->swapchain, &(packet->pSwapchainImageCount), &(packet->pSwapchainImages)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAcquireNextImageKHR(Packet_vkAcquireNextImageKHR* packet) +{ + vulkan_replay_consumer_->Process_vkAcquireNextImageKHR(packet->call_info, packet->return_value, packet->device, packet->swapchain, packet->timeout, packet->semaphore, packet->fence, &(packet->pImageIndex)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueuePresentKHR(Packet_vkQueuePresentKHR* packet) +{ + vulkan_replay_consumer_->Process_vkQueuePresentKHR(packet->call_info, packet->return_value, packet->queue, &(packet->pPresentInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceGroupPresentCapabilitiesKHR(Packet_vkGetDeviceGroupPresentCapabilitiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceGroupPresentCapabilitiesKHR(packet->call_info, packet->return_value, packet->device, &(packet->pDeviceGroupPresentCapabilities)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceGroupSurfacePresentModesKHR(Packet_vkGetDeviceGroupSurfacePresentModesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceGroupSurfacePresentModesKHR(packet->call_info, packet->return_value, packet->device, packet->surface, &(packet->pModes)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDevicePresentRectanglesKHR(Packet_vkGetPhysicalDevicePresentRectanglesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDevicePresentRectanglesKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->surface, &(packet->pRectCount), &(packet->pRects)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAcquireNextImage2KHR(Packet_vkAcquireNextImage2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkAcquireNextImage2KHR(packet->call_info, packet->return_value, packet->device, &(packet->pAcquireInfo), &(packet->pImageIndex)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceDisplayPropertiesKHR(Packet_vkGetPhysicalDeviceDisplayPropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceDisplayPropertiesKHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(Packet_vkGetPhysicalDeviceDisplayPlanePropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDisplayPlaneSupportedDisplaysKHR(Packet_vkGetDisplayPlaneSupportedDisplaysKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDisplayPlaneSupportedDisplaysKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->planeIndex, &(packet->pDisplayCount), &(packet->pDisplays)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDisplayModePropertiesKHR(Packet_vkGetDisplayModePropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDisplayModePropertiesKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->display, &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDisplayModeKHR(Packet_vkCreateDisplayModeKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDisplayModeKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->display, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pMode)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDisplayPlaneCapabilitiesKHR(Packet_vkGetDisplayPlaneCapabilitiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDisplayPlaneCapabilitiesKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->mode, packet->planeIndex, &(packet->pCapabilities)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDisplayPlaneSurfaceKHR(Packet_vkCreateDisplayPlaneSurfaceKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDisplayPlaneSurfaceKHR(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateSharedSwapchainsKHR(Packet_vkCreateSharedSwapchainsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateSharedSwapchainsKHR(packet->call_info, packet->return_value, packet->device, packet->swapchainCount, &(packet->pCreateInfos), &(packet->pAllocator), &(packet->pSwapchains)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateXlibSurfaceKHR(Packet_vkCreateXlibSurfaceKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateXlibSurfaceKHR(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceXlibPresentationSupportKHR(Packet_vkGetPhysicalDeviceXlibPresentationSupportKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceXlibPresentationSupportKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->queueFamilyIndex, packet->dpy, packet->visualID); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateXcbSurfaceKHR(Packet_vkCreateXcbSurfaceKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateXcbSurfaceKHR(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceXcbPresentationSupportKHR(Packet_vkGetPhysicalDeviceXcbPresentationSupportKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceXcbPresentationSupportKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->queueFamilyIndex, packet->connection, packet->visual_id); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateWaylandSurfaceKHR(Packet_vkCreateWaylandSurfaceKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateWaylandSurfaceKHR(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceWaylandPresentationSupportKHR(Packet_vkGetPhysicalDeviceWaylandPresentationSupportKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceWaylandPresentationSupportKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->queueFamilyIndex, packet->display); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateAndroidSurfaceKHR(Packet_vkCreateAndroidSurfaceKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateAndroidSurfaceKHR(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateWin32SurfaceKHR(Packet_vkCreateWin32SurfaceKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateWin32SurfaceKHR(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceWin32PresentationSupportKHR(Packet_vkGetPhysicalDeviceWin32PresentationSupportKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceWin32PresentationSupportKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->queueFamilyIndex); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceVideoCapabilitiesKHR(Packet_vkGetPhysicalDeviceVideoCapabilitiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceVideoCapabilitiesKHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pVideoProfile), &(packet->pCapabilities)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceVideoFormatPropertiesKHR(Packet_vkGetPhysicalDeviceVideoFormatPropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceVideoFormatPropertiesKHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pVideoFormatInfo), &(packet->pVideoFormatPropertyCount), &(packet->pVideoFormatProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateVideoSessionKHR(Packet_vkCreateVideoSessionKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateVideoSessionKHR(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pVideoSession)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyVideoSessionKHR(Packet_vkDestroyVideoSessionKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyVideoSessionKHR(packet->call_info, packet->device, packet->videoSession, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetVideoSessionMemoryRequirementsKHR(Packet_vkGetVideoSessionMemoryRequirementsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetVideoSessionMemoryRequirementsKHR(packet->call_info, packet->return_value, packet->device, packet->videoSession, &(packet->pMemoryRequirementsCount), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBindVideoSessionMemoryKHR(Packet_vkBindVideoSessionMemoryKHR* packet) +{ + vulkan_replay_consumer_->Process_vkBindVideoSessionMemoryKHR(packet->call_info, packet->return_value, packet->device, packet->videoSession, packet->bindSessionMemoryInfoCount, &(packet->pBindSessionMemoryInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateVideoSessionParametersKHR(Packet_vkCreateVideoSessionParametersKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateVideoSessionParametersKHR(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pVideoSessionParameters)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkUpdateVideoSessionParametersKHR(Packet_vkUpdateVideoSessionParametersKHR* packet) +{ + vulkan_replay_consumer_->Process_vkUpdateVideoSessionParametersKHR(packet->call_info, packet->return_value, packet->device, packet->videoSessionParameters, &(packet->pUpdateInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyVideoSessionParametersKHR(Packet_vkDestroyVideoSessionParametersKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyVideoSessionParametersKHR(packet->call_info, packet->device, packet->videoSessionParameters, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginVideoCodingKHR(Packet_vkCmdBeginVideoCodingKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginVideoCodingKHR(packet->call_info, packet->commandBuffer, &(packet->pBeginInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndVideoCodingKHR(Packet_vkCmdEndVideoCodingKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndVideoCodingKHR(packet->call_info, packet->commandBuffer, &(packet->pEndCodingInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdControlVideoCodingKHR(Packet_vkCmdControlVideoCodingKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdControlVideoCodingKHR(packet->call_info, packet->commandBuffer, &(packet->pCodingControlInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDecodeVideoKHR(Packet_vkCmdDecodeVideoKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDecodeVideoKHR(packet->call_info, packet->commandBuffer, &(packet->pDecodeInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginRenderingKHR(Packet_vkCmdBeginRenderingKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginRenderingKHR(packet->call_info, packet->commandBuffer, &(packet->pRenderingInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndRenderingKHR(Packet_vkCmdEndRenderingKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndRenderingKHR(packet->call_info, packet->commandBuffer); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceFeatures2KHR(Packet_vkGetPhysicalDeviceFeatures2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceFeatures2KHR(packet->call_info, packet->physicalDevice, &(packet->pFeatures)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceProperties2KHR(Packet_vkGetPhysicalDeviceProperties2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceProperties2KHR(packet->call_info, packet->physicalDevice, &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceFormatProperties2KHR(Packet_vkGetPhysicalDeviceFormatProperties2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceFormatProperties2KHR(packet->call_info, packet->physicalDevice, packet->format, &(packet->pFormatProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceImageFormatProperties2KHR(Packet_vkGetPhysicalDeviceImageFormatProperties2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceImageFormatProperties2KHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pImageFormatInfo), &(packet->pImageFormatProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceQueueFamilyProperties2KHR(Packet_vkGetPhysicalDeviceQueueFamilyProperties2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceQueueFamilyProperties2KHR(packet->call_info, packet->physicalDevice, &(packet->pQueueFamilyPropertyCount), &(packet->pQueueFamilyProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceMemoryProperties2KHR(Packet_vkGetPhysicalDeviceMemoryProperties2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceMemoryProperties2KHR(packet->call_info, packet->physicalDevice, &(packet->pMemoryProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(Packet_vkGetPhysicalDeviceSparseImageFormatProperties2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(packet->call_info, packet->physicalDevice, &(packet->pFormatInfo), &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceGroupPeerMemoryFeaturesKHR(Packet_vkGetDeviceGroupPeerMemoryFeaturesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceGroupPeerMemoryFeaturesKHR(packet->call_info, packet->device, packet->heapIndex, packet->localDeviceIndex, packet->remoteDeviceIndex, &(packet->pPeerMemoryFeatures)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDeviceMaskKHR(Packet_vkCmdSetDeviceMaskKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDeviceMaskKHR(packet->call_info, packet->commandBuffer, packet->deviceMask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDispatchBaseKHR(Packet_vkCmdDispatchBaseKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDispatchBaseKHR(packet->call_info, packet->commandBuffer, packet->baseGroupX, packet->baseGroupY, packet->baseGroupZ, packet->groupCountX, packet->groupCountY, packet->groupCountZ); + + return; +} + +void VulkanPreloadReplayer::Replay_vkTrimCommandPoolKHR(Packet_vkTrimCommandPoolKHR* packet) +{ + vulkan_replay_consumer_->Process_vkTrimCommandPoolKHR(packet->call_info, packet->device, packet->commandPool, packet->flags); + + return; +} + +void VulkanPreloadReplayer::Replay_vkEnumeratePhysicalDeviceGroupsKHR(Packet_vkEnumeratePhysicalDeviceGroupsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkEnumeratePhysicalDeviceGroupsKHR(packet->call_info, packet->return_value, packet->instance, &(packet->pPhysicalDeviceGroupCount), &(packet->pPhysicalDeviceGroupProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceExternalBufferPropertiesKHR(Packet_vkGetPhysicalDeviceExternalBufferPropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceExternalBufferPropertiesKHR(packet->call_info, packet->physicalDevice, &(packet->pExternalBufferInfo), &(packet->pExternalBufferProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryWin32HandleKHR(Packet_vkGetMemoryWin32HandleKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryWin32HandleKHR(packet->call_info, packet->return_value, packet->device, &(packet->pGetWin32HandleInfo), &(packet->pHandle)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryWin32HandlePropertiesKHR(Packet_vkGetMemoryWin32HandlePropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryWin32HandlePropertiesKHR(packet->call_info, packet->return_value, packet->device, packet->handleType, packet->handle, &(packet->pMemoryWin32HandleProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryFdKHR(Packet_vkGetMemoryFdKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryFdKHR(packet->call_info, packet->return_value, packet->device, &(packet->pGetFdInfo), &(packet->pFd)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryFdPropertiesKHR(Packet_vkGetMemoryFdPropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryFdPropertiesKHR(packet->call_info, packet->return_value, packet->device, packet->handleType, packet->fd, &(packet->pMemoryFdProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(Packet_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(packet->call_info, packet->physicalDevice, &(packet->pExternalSemaphoreInfo), &(packet->pExternalSemaphoreProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkImportSemaphoreWin32HandleKHR(Packet_vkImportSemaphoreWin32HandleKHR* packet) +{ + vulkan_replay_consumer_->Process_vkImportSemaphoreWin32HandleKHR(packet->call_info, packet->return_value, packet->device, &(packet->pImportSemaphoreWin32HandleInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetSemaphoreWin32HandleKHR(Packet_vkGetSemaphoreWin32HandleKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetSemaphoreWin32HandleKHR(packet->call_info, packet->return_value, packet->device, &(packet->pGetWin32HandleInfo), &(packet->pHandle)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkImportSemaphoreFdKHR(Packet_vkImportSemaphoreFdKHR* packet) +{ + vulkan_replay_consumer_->Process_vkImportSemaphoreFdKHR(packet->call_info, packet->return_value, packet->device, &(packet->pImportSemaphoreFdInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetSemaphoreFdKHR(Packet_vkGetSemaphoreFdKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetSemaphoreFdKHR(packet->call_info, packet->return_value, packet->device, &(packet->pGetFdInfo), &(packet->pFd)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdPushDescriptorSetKHR(Packet_vkCmdPushDescriptorSetKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPushDescriptorSetKHR(packet->call_info, packet->commandBuffer, packet->pipelineBindPoint, packet->layout, packet->set, packet->descriptorWriteCount, &(packet->pDescriptorWrites)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDescriptorUpdateTemplateKHR(Packet_vkCreateDescriptorUpdateTemplateKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDescriptorUpdateTemplateKHR(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pDescriptorUpdateTemplate)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyDescriptorUpdateTemplateKHR(Packet_vkDestroyDescriptorUpdateTemplateKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyDescriptorUpdateTemplateKHR(packet->call_info, packet->device, packet->descriptorUpdateTemplate, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateRenderPass2KHR(Packet_vkCreateRenderPass2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateRenderPass2KHR(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pRenderPass)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginRenderPass2KHR(Packet_vkCmdBeginRenderPass2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginRenderPass2KHR(packet->call_info, packet->commandBuffer, &(packet->pRenderPassBegin), &(packet->pSubpassBeginInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdNextSubpass2KHR(Packet_vkCmdNextSubpass2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdNextSubpass2KHR(packet->call_info, packet->commandBuffer, &(packet->pSubpassBeginInfo), &(packet->pSubpassEndInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndRenderPass2KHR(Packet_vkCmdEndRenderPass2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndRenderPass2KHR(packet->call_info, packet->commandBuffer, &(packet->pSubpassEndInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetSwapchainStatusKHR(Packet_vkGetSwapchainStatusKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetSwapchainStatusKHR(packet->call_info, packet->return_value, packet->device, packet->swapchain); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceExternalFencePropertiesKHR(Packet_vkGetPhysicalDeviceExternalFencePropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceExternalFencePropertiesKHR(packet->call_info, packet->physicalDevice, &(packet->pExternalFenceInfo), &(packet->pExternalFenceProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkImportFenceWin32HandleKHR(Packet_vkImportFenceWin32HandleKHR* packet) +{ + vulkan_replay_consumer_->Process_vkImportFenceWin32HandleKHR(packet->call_info, packet->return_value, packet->device, &(packet->pImportFenceWin32HandleInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetFenceWin32HandleKHR(Packet_vkGetFenceWin32HandleKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetFenceWin32HandleKHR(packet->call_info, packet->return_value, packet->device, &(packet->pGetWin32HandleInfo), &(packet->pHandle)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkImportFenceFdKHR(Packet_vkImportFenceFdKHR* packet) +{ + vulkan_replay_consumer_->Process_vkImportFenceFdKHR(packet->call_info, packet->return_value, packet->device, &(packet->pImportFenceFdInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetFenceFdKHR(Packet_vkGetFenceFdKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetFenceFdKHR(packet->call_info, packet->return_value, packet->device, &(packet->pGetFdInfo), &(packet->pFd)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(Packet_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR* packet) +{ + vulkan_replay_consumer_->Process_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->queueFamilyIndex, &(packet->pCounterCount), &(packet->pCounters), &(packet->pCounterDescriptions)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(Packet_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(packet->call_info, packet->physicalDevice, &(packet->pPerformanceQueryCreateInfo), &(packet->pNumPasses)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAcquireProfilingLockKHR(Packet_vkAcquireProfilingLockKHR* packet) +{ + vulkan_replay_consumer_->Process_vkAcquireProfilingLockKHR(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkReleaseProfilingLockKHR(Packet_vkReleaseProfilingLockKHR* packet) +{ + vulkan_replay_consumer_->Process_vkReleaseProfilingLockKHR(packet->call_info, packet->device); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSurfaceCapabilities2KHR(Packet_vkGetPhysicalDeviceSurfaceCapabilities2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSurfaceCapabilities2KHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pSurfaceInfo), &(packet->pSurfaceCapabilities)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSurfaceFormats2KHR(Packet_vkGetPhysicalDeviceSurfaceFormats2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSurfaceFormats2KHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pSurfaceInfo), &(packet->pSurfaceFormatCount), &(packet->pSurfaceFormats)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceDisplayProperties2KHR(Packet_vkGetPhysicalDeviceDisplayProperties2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceDisplayProperties2KHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(Packet_vkGetPhysicalDeviceDisplayPlaneProperties2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDisplayModeProperties2KHR(Packet_vkGetDisplayModeProperties2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDisplayModeProperties2KHR(packet->call_info, packet->return_value, packet->physicalDevice, packet->display, &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDisplayPlaneCapabilities2KHR(Packet_vkGetDisplayPlaneCapabilities2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDisplayPlaneCapabilities2KHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pDisplayPlaneInfo), &(packet->pCapabilities)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageMemoryRequirements2KHR(Packet_vkGetImageMemoryRequirements2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageMemoryRequirements2KHR(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetBufferMemoryRequirements2KHR(Packet_vkGetBufferMemoryRequirements2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetBufferMemoryRequirements2KHR(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageSparseMemoryRequirements2KHR(Packet_vkGetImageSparseMemoryRequirements2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageSparseMemoryRequirements2KHR(packet->call_info, packet->device, &(packet->pInfo), &(packet->pSparseMemoryRequirementCount), &(packet->pSparseMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateSamplerYcbcrConversionKHR(Packet_vkCreateSamplerYcbcrConversionKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateSamplerYcbcrConversionKHR(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pYcbcrConversion)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroySamplerYcbcrConversionKHR(Packet_vkDestroySamplerYcbcrConversionKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDestroySamplerYcbcrConversionKHR(packet->call_info, packet->device, packet->ycbcrConversion, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBindBufferMemory2KHR(Packet_vkBindBufferMemory2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkBindBufferMemory2KHR(packet->call_info, packet->return_value, packet->device, packet->bindInfoCount, &(packet->pBindInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBindImageMemory2KHR(Packet_vkBindImageMemory2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkBindImageMemory2KHR(packet->call_info, packet->return_value, packet->device, packet->bindInfoCount, &(packet->pBindInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDescriptorSetLayoutSupportKHR(Packet_vkGetDescriptorSetLayoutSupportKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDescriptorSetLayoutSupportKHR(packet->call_info, packet->device, &(packet->pCreateInfo), &(packet->pSupport)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndirectCountKHR(Packet_vkCmdDrawIndirectCountKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndirectCountKHR(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->countBuffer, packet->countBufferOffset, packet->maxDrawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndexedIndirectCountKHR(Packet_vkCmdDrawIndexedIndirectCountKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndexedIndirectCountKHR(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->countBuffer, packet->countBufferOffset, packet->maxDrawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetSemaphoreCounterValueKHR(Packet_vkGetSemaphoreCounterValueKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetSemaphoreCounterValueKHR(packet->call_info, packet->return_value, packet->device, packet->semaphore, &(packet->pValue)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkWaitSemaphoresKHR(Packet_vkWaitSemaphoresKHR* packet) +{ + vulkan_replay_consumer_->Process_vkWaitSemaphoresKHR(packet->call_info, packet->return_value, packet->device, &(packet->pWaitInfo), packet->timeout); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSignalSemaphoreKHR(Packet_vkSignalSemaphoreKHR* packet) +{ + vulkan_replay_consumer_->Process_vkSignalSemaphoreKHR(packet->call_info, packet->return_value, packet->device, &(packet->pSignalInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceFragmentShadingRatesKHR(Packet_vkGetPhysicalDeviceFragmentShadingRatesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceFragmentShadingRatesKHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pFragmentShadingRateCount), &(packet->pFragmentShadingRates)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetFragmentShadingRateKHR(Packet_vkCmdSetFragmentShadingRateKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetFragmentShadingRateKHR(packet->call_info, packet->commandBuffer, &(packet->pFragmentSize), &(packet->combinerOps)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetRenderingAttachmentLocationsKHR(Packet_vkCmdSetRenderingAttachmentLocationsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetRenderingAttachmentLocationsKHR(packet->call_info, packet->commandBuffer, &(packet->pLocationInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetRenderingInputAttachmentIndicesKHR(Packet_vkCmdSetRenderingInputAttachmentIndicesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetRenderingInputAttachmentIndicesKHR(packet->call_info, packet->commandBuffer, &(packet->pInputAttachmentIndexInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkWaitForPresentKHR(Packet_vkWaitForPresentKHR* packet) +{ + vulkan_replay_consumer_->Process_vkWaitForPresentKHR(packet->call_info, packet->return_value, packet->device, packet->swapchain, packet->presentId, packet->timeout); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetBufferDeviceAddressKHR(Packet_vkGetBufferDeviceAddressKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetBufferDeviceAddressKHR(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetBufferOpaqueCaptureAddressKHR(Packet_vkGetBufferOpaqueCaptureAddressKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetBufferOpaqueCaptureAddressKHR(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceMemoryOpaqueCaptureAddressKHR(Packet_vkGetDeviceMemoryOpaqueCaptureAddressKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceMemoryOpaqueCaptureAddressKHR(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDeferredOperationKHR(Packet_vkCreateDeferredOperationKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDeferredOperationKHR(packet->call_info, packet->return_value, packet->device, &(packet->pAllocator), &(packet->pDeferredOperation)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyDeferredOperationKHR(Packet_vkDestroyDeferredOperationKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyDeferredOperationKHR(packet->call_info, packet->device, packet->operation, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeferredOperationMaxConcurrencyKHR(Packet_vkGetDeferredOperationMaxConcurrencyKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeferredOperationMaxConcurrencyKHR(packet->call_info, packet->return_value, packet->device, packet->operation); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeferredOperationResultKHR(Packet_vkGetDeferredOperationResultKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeferredOperationResultKHR(packet->call_info, packet->return_value, packet->device, packet->operation); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDeferredOperationJoinKHR(Packet_vkDeferredOperationJoinKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDeferredOperationJoinKHR(packet->call_info, packet->return_value, packet->device, packet->operation); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPipelineExecutablePropertiesKHR(Packet_vkGetPipelineExecutablePropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPipelineExecutablePropertiesKHR(packet->call_info, packet->return_value, packet->device, &(packet->pPipelineInfo), &(packet->pExecutableCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPipelineExecutableStatisticsKHR(Packet_vkGetPipelineExecutableStatisticsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPipelineExecutableStatisticsKHR(packet->call_info, packet->return_value, packet->device, &(packet->pExecutableInfo), &(packet->pStatisticCount), &(packet->pStatistics)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPipelineExecutableInternalRepresentationsKHR(Packet_vkGetPipelineExecutableInternalRepresentationsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPipelineExecutableInternalRepresentationsKHR(packet->call_info, packet->return_value, packet->device, &(packet->pExecutableInfo), &(packet->pInternalRepresentationCount), &(packet->pInternalRepresentations)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkMapMemory2KHR(Packet_vkMapMemory2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkMapMemory2KHR(packet->call_info, packet->return_value, packet->device, &(packet->pMemoryMapInfo), &(packet->ppData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkUnmapMemory2KHR(Packet_vkUnmapMemory2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkUnmapMemory2KHR(packet->call_info, packet->return_value, packet->device, &(packet->pMemoryUnmapInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(Packet_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pQualityLevelInfo), &(packet->pQualityLevelProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetEncodedVideoSessionParametersKHR(Packet_vkGetEncodedVideoSessionParametersKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetEncodedVideoSessionParametersKHR(packet->call_info, packet->return_value, packet->device, &(packet->pVideoSessionParametersInfo), &(packet->pFeedbackInfo), &(packet->pDataSize), &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEncodeVideoKHR(Packet_vkCmdEncodeVideoKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEncodeVideoKHR(packet->call_info, packet->commandBuffer, &(packet->pEncodeInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetEvent2KHR(Packet_vkCmdSetEvent2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetEvent2KHR(packet->call_info, packet->commandBuffer, packet->event, &(packet->pDependencyInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdResetEvent2KHR(Packet_vkCmdResetEvent2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdResetEvent2KHR(packet->call_info, packet->commandBuffer, packet->event, packet->stageMask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWaitEvents2KHR(Packet_vkCmdWaitEvents2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWaitEvents2KHR(packet->call_info, packet->commandBuffer, packet->eventCount, &(packet->pEvents), &(packet->pDependencyInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdPipelineBarrier2KHR(Packet_vkCmdPipelineBarrier2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPipelineBarrier2KHR(packet->call_info, packet->commandBuffer, &(packet->pDependencyInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWriteTimestamp2KHR(Packet_vkCmdWriteTimestamp2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWriteTimestamp2KHR(packet->call_info, packet->commandBuffer, packet->stage, packet->queryPool, packet->query); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueSubmit2KHR(Packet_vkQueueSubmit2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkQueueSubmit2KHR(packet->call_info, packet->return_value, packet->queue, packet->submitCount, &(packet->pSubmits), packet->fence); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWriteBufferMarker2AMD(Packet_vkCmdWriteBufferMarker2AMD* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWriteBufferMarker2AMD(packet->call_info, packet->commandBuffer, packet->stage, packet->dstBuffer, packet->dstOffset, packet->marker); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetQueueCheckpointData2NV(Packet_vkGetQueueCheckpointData2NV* packet) +{ + vulkan_replay_consumer_->Process_vkGetQueueCheckpointData2NV(packet->call_info, packet->queue, &(packet->pCheckpointDataCount), &(packet->pCheckpointData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyBuffer2KHR(Packet_vkCmdCopyBuffer2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyBuffer2KHR(packet->call_info, packet->commandBuffer, &(packet->pCopyBufferInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyImage2KHR(Packet_vkCmdCopyImage2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyImage2KHR(packet->call_info, packet->commandBuffer, &(packet->pCopyImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyBufferToImage2KHR(Packet_vkCmdCopyBufferToImage2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyBufferToImage2KHR(packet->call_info, packet->commandBuffer, &(packet->pCopyBufferToImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyImageToBuffer2KHR(Packet_vkCmdCopyImageToBuffer2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyImageToBuffer2KHR(packet->call_info, packet->commandBuffer, &(packet->pCopyImageToBufferInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBlitImage2KHR(Packet_vkCmdBlitImage2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBlitImage2KHR(packet->call_info, packet->commandBuffer, &(packet->pBlitImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdResolveImage2KHR(Packet_vkCmdResolveImage2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdResolveImage2KHR(packet->call_info, packet->commandBuffer, &(packet->pResolveImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdTraceRaysIndirect2KHR(Packet_vkCmdTraceRaysIndirect2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdTraceRaysIndirect2KHR(packet->call_info, packet->commandBuffer, packet->indirectDeviceAddress); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceBufferMemoryRequirementsKHR(Packet_vkGetDeviceBufferMemoryRequirementsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceBufferMemoryRequirementsKHR(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceImageMemoryRequirementsKHR(Packet_vkGetDeviceImageMemoryRequirementsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceImageMemoryRequirementsKHR(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceImageSparseMemoryRequirementsKHR(Packet_vkGetDeviceImageSparseMemoryRequirementsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceImageSparseMemoryRequirementsKHR(packet->call_info, packet->device, &(packet->pInfo), &(packet->pSparseMemoryRequirementCount), &(packet->pSparseMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindIndexBuffer2KHR(Packet_vkCmdBindIndexBuffer2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindIndexBuffer2KHR(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->size, packet->indexType); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetRenderingAreaGranularityKHR(Packet_vkGetRenderingAreaGranularityKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetRenderingAreaGranularityKHR(packet->call_info, packet->device, &(packet->pRenderingAreaInfo), &(packet->pGranularity)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceImageSubresourceLayoutKHR(Packet_vkGetDeviceImageSubresourceLayoutKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceImageSubresourceLayoutKHR(packet->call_info, packet->device, &(packet->pInfo), &(packet->pLayout)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageSubresourceLayout2KHR(Packet_vkGetImageSubresourceLayout2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageSubresourceLayout2KHR(packet->call_info, packet->device, packet->image, &(packet->pSubresource), &(packet->pLayout)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(Packet_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetLineStippleKHR(Packet_vkCmdSetLineStippleKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetLineStippleKHR(packet->call_info, packet->commandBuffer, packet->lineStippleFactor, packet->lineStipplePattern); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(Packet_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pTimeDomainCount), &(packet->pTimeDomains)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetCalibratedTimestampsKHR(Packet_vkGetCalibratedTimestampsKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetCalibratedTimestampsKHR(packet->call_info, packet->return_value, packet->device, packet->timestampCount, &(packet->pTimestampInfos), &(packet->pTimestamps), &(packet->pMaxDeviation)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindDescriptorSets2KHR(Packet_vkCmdBindDescriptorSets2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindDescriptorSets2KHR(packet->call_info, packet->commandBuffer, &(packet->pBindDescriptorSetsInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdPushConstants2KHR(Packet_vkCmdPushConstants2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPushConstants2KHR(packet->call_info, packet->commandBuffer, &(packet->pPushConstantsInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdPushDescriptorSet2KHR(Packet_vkCmdPushDescriptorSet2KHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPushDescriptorSet2KHR(packet->call_info, packet->commandBuffer, &(packet->pPushDescriptorSetInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDescriptorBufferOffsets2EXT(Packet_vkCmdSetDescriptorBufferOffsets2EXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDescriptorBufferOffsets2EXT(packet->call_info, packet->commandBuffer, &(packet->pSetDescriptorBufferOffsetsInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(Packet_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(packet->call_info, packet->commandBuffer, &(packet->pBindDescriptorBufferEmbeddedSamplersInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkFrameBoundaryANDROID(Packet_vkFrameBoundaryANDROID* packet) +{ + vulkan_replay_consumer_->Process_vkFrameBoundaryANDROID(packet->call_info, packet->device, packet->semaphore, packet->image); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDebugReportCallbackEXT(Packet_vkCreateDebugReportCallbackEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDebugReportCallbackEXT(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pCallback)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyDebugReportCallbackEXT(Packet_vkDestroyDebugReportCallbackEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyDebugReportCallbackEXT(packet->call_info, packet->instance, packet->callback, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDebugReportMessageEXT(Packet_vkDebugReportMessageEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDebugReportMessageEXT(packet->call_info, packet->instance, packet->flags, packet->objectType, packet->object, packet->location, packet->messageCode, &(packet->pLayerPrefix), &(packet->pMessage)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDebugMarkerSetObjectTagEXT(Packet_vkDebugMarkerSetObjectTagEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDebugMarkerSetObjectTagEXT(packet->call_info, packet->return_value, packet->device, &(packet->pTagInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDebugMarkerSetObjectNameEXT(Packet_vkDebugMarkerSetObjectNameEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDebugMarkerSetObjectNameEXT(packet->call_info, packet->return_value, packet->device, &(packet->pNameInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDebugMarkerBeginEXT(Packet_vkCmdDebugMarkerBeginEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDebugMarkerBeginEXT(packet->call_info, packet->commandBuffer, &(packet->pMarkerInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDebugMarkerEndEXT(Packet_vkCmdDebugMarkerEndEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDebugMarkerEndEXT(packet->call_info, packet->commandBuffer); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDebugMarkerInsertEXT(Packet_vkCmdDebugMarkerInsertEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDebugMarkerInsertEXT(packet->call_info, packet->commandBuffer, &(packet->pMarkerInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindTransformFeedbackBuffersEXT(Packet_vkCmdBindTransformFeedbackBuffersEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindTransformFeedbackBuffersEXT(packet->call_info, packet->commandBuffer, packet->firstBinding, packet->bindingCount, &(packet->pBuffers), &(packet->pOffsets), &(packet->pSizes)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginTransformFeedbackEXT(Packet_vkCmdBeginTransformFeedbackEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginTransformFeedbackEXT(packet->call_info, packet->commandBuffer, packet->firstCounterBuffer, packet->counterBufferCount, &(packet->pCounterBuffers), &(packet->pCounterBufferOffsets)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndTransformFeedbackEXT(Packet_vkCmdEndTransformFeedbackEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndTransformFeedbackEXT(packet->call_info, packet->commandBuffer, packet->firstCounterBuffer, packet->counterBufferCount, &(packet->pCounterBuffers), &(packet->pCounterBufferOffsets)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginQueryIndexedEXT(Packet_vkCmdBeginQueryIndexedEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginQueryIndexedEXT(packet->call_info, packet->commandBuffer, packet->queryPool, packet->query, packet->flags, packet->index); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndQueryIndexedEXT(Packet_vkCmdEndQueryIndexedEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndQueryIndexedEXT(packet->call_info, packet->commandBuffer, packet->queryPool, packet->query, packet->index); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndirectByteCountEXT(Packet_vkCmdDrawIndirectByteCountEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndirectByteCountEXT(packet->call_info, packet->commandBuffer, packet->instanceCount, packet->firstInstance, packet->counterBuffer, packet->counterBufferOffset, packet->counterOffset, packet->vertexStride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageViewHandleNVX(Packet_vkGetImageViewHandleNVX* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageViewHandleNVX(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageViewAddressNVX(Packet_vkGetImageViewAddressNVX* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageViewAddressNVX(packet->call_info, packet->return_value, packet->device, packet->imageView, &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndirectCountAMD(Packet_vkCmdDrawIndirectCountAMD* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndirectCountAMD(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->countBuffer, packet->countBufferOffset, packet->maxDrawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawIndexedIndirectCountAMD(Packet_vkCmdDrawIndexedIndirectCountAMD* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawIndexedIndirectCountAMD(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->countBuffer, packet->countBufferOffset, packet->maxDrawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetShaderInfoAMD(Packet_vkGetShaderInfoAMD* packet) +{ + vulkan_replay_consumer_->Process_vkGetShaderInfoAMD(packet->call_info, packet->return_value, packet->device, packet->pipeline, packet->shaderStage, packet->infoType, &(packet->pInfoSize), &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateStreamDescriptorSurfaceGGP(Packet_vkCreateStreamDescriptorSurfaceGGP* packet) +{ + vulkan_replay_consumer_->Process_vkCreateStreamDescriptorSurfaceGGP(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(Packet_vkGetPhysicalDeviceExternalImageFormatPropertiesNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(packet->call_info, packet->return_value, packet->physicalDevice, packet->format, packet->type, packet->tiling, packet->usage, packet->flags, packet->externalHandleType, &(packet->pExternalImageFormatProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryWin32HandleNV(Packet_vkGetMemoryWin32HandleNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryWin32HandleNV(packet->call_info, packet->return_value, packet->device, packet->memory, packet->handleType, &(packet->pHandle)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateViSurfaceNN(Packet_vkCreateViSurfaceNN* packet) +{ + vulkan_replay_consumer_->Process_vkCreateViSurfaceNN(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginConditionalRenderingEXT(Packet_vkCmdBeginConditionalRenderingEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginConditionalRenderingEXT(packet->call_info, packet->commandBuffer, &(packet->pConditionalRenderingBegin)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndConditionalRenderingEXT(Packet_vkCmdEndConditionalRenderingEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndConditionalRenderingEXT(packet->call_info, packet->commandBuffer); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetViewportWScalingNV(Packet_vkCmdSetViewportWScalingNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetViewportWScalingNV(packet->call_info, packet->commandBuffer, packet->firstViewport, packet->viewportCount, &(packet->pViewportWScalings)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkReleaseDisplayEXT(Packet_vkReleaseDisplayEXT* packet) +{ + vulkan_replay_consumer_->Process_vkReleaseDisplayEXT(packet->call_info, packet->return_value, packet->physicalDevice, packet->display); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAcquireXlibDisplayEXT(Packet_vkAcquireXlibDisplayEXT* packet) +{ + vulkan_replay_consumer_->Process_vkAcquireXlibDisplayEXT(packet->call_info, packet->return_value, packet->physicalDevice, packet->dpy, packet->display); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetRandROutputDisplayEXT(Packet_vkGetRandROutputDisplayEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetRandROutputDisplayEXT(packet->call_info, packet->return_value, packet->physicalDevice, packet->dpy, packet->rrOutput, &(packet->pDisplay)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSurfaceCapabilities2EXT(Packet_vkGetPhysicalDeviceSurfaceCapabilities2EXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSurfaceCapabilities2EXT(packet->call_info, packet->return_value, packet->physicalDevice, packet->surface, &(packet->pSurfaceCapabilities)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDisplayPowerControlEXT(Packet_vkDisplayPowerControlEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDisplayPowerControlEXT(packet->call_info, packet->return_value, packet->device, packet->display, &(packet->pDisplayPowerInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkRegisterDeviceEventEXT(Packet_vkRegisterDeviceEventEXT* packet) +{ + vulkan_replay_consumer_->Process_vkRegisterDeviceEventEXT(packet->call_info, packet->return_value, packet->device, &(packet->pDeviceEventInfo), &(packet->pAllocator), &(packet->pFence)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkRegisterDisplayEventEXT(Packet_vkRegisterDisplayEventEXT* packet) +{ + vulkan_replay_consumer_->Process_vkRegisterDisplayEventEXT(packet->call_info, packet->return_value, packet->device, packet->display, &(packet->pDisplayEventInfo), &(packet->pAllocator), &(packet->pFence)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetSwapchainCounterEXT(Packet_vkGetSwapchainCounterEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetSwapchainCounterEXT(packet->call_info, packet->return_value, packet->device, packet->swapchain, packet->counter, &(packet->pCounterValue)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetRefreshCycleDurationGOOGLE(Packet_vkGetRefreshCycleDurationGOOGLE* packet) +{ + vulkan_replay_consumer_->Process_vkGetRefreshCycleDurationGOOGLE(packet->call_info, packet->return_value, packet->device, packet->swapchain, &(packet->pDisplayTimingProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPastPresentationTimingGOOGLE(Packet_vkGetPastPresentationTimingGOOGLE* packet) +{ + vulkan_replay_consumer_->Process_vkGetPastPresentationTimingGOOGLE(packet->call_info, packet->return_value, packet->device, packet->swapchain, &(packet->pPresentationTimingCount), &(packet->pPresentationTimings)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDiscardRectangleEXT(Packet_vkCmdSetDiscardRectangleEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDiscardRectangleEXT(packet->call_info, packet->commandBuffer, packet->firstDiscardRectangle, packet->discardRectangleCount, &(packet->pDiscardRectangles)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDiscardRectangleEnableEXT(Packet_vkCmdSetDiscardRectangleEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDiscardRectangleEnableEXT(packet->call_info, packet->commandBuffer, packet->discardRectangleEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDiscardRectangleModeEXT(Packet_vkCmdSetDiscardRectangleModeEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDiscardRectangleModeEXT(packet->call_info, packet->commandBuffer, packet->discardRectangleMode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetHdrMetadataEXT(Packet_vkSetHdrMetadataEXT* packet) +{ + vulkan_replay_consumer_->Process_vkSetHdrMetadataEXT(packet->call_info, packet->device, packet->swapchainCount, &(packet->pSwapchains), &(packet->pMetadata)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateIOSSurfaceMVK(Packet_vkCreateIOSSurfaceMVK* packet) +{ + vulkan_replay_consumer_->Process_vkCreateIOSSurfaceMVK(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateMacOSSurfaceMVK(Packet_vkCreateMacOSSurfaceMVK* packet) +{ + vulkan_replay_consumer_->Process_vkCreateMacOSSurfaceMVK(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetDebugUtilsObjectNameEXT(Packet_vkSetDebugUtilsObjectNameEXT* packet) +{ + vulkan_replay_consumer_->Process_vkSetDebugUtilsObjectNameEXT(packet->call_info, packet->return_value, packet->device, &(packet->pNameInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetDebugUtilsObjectTagEXT(Packet_vkSetDebugUtilsObjectTagEXT* packet) +{ + vulkan_replay_consumer_->Process_vkSetDebugUtilsObjectTagEXT(packet->call_info, packet->return_value, packet->device, &(packet->pTagInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueBeginDebugUtilsLabelEXT(Packet_vkQueueBeginDebugUtilsLabelEXT* packet) +{ + vulkan_replay_consumer_->Process_vkQueueBeginDebugUtilsLabelEXT(packet->call_info, packet->queue, &(packet->pLabelInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueEndDebugUtilsLabelEXT(Packet_vkQueueEndDebugUtilsLabelEXT* packet) +{ + vulkan_replay_consumer_->Process_vkQueueEndDebugUtilsLabelEXT(packet->call_info, packet->queue); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueInsertDebugUtilsLabelEXT(Packet_vkQueueInsertDebugUtilsLabelEXT* packet) +{ + vulkan_replay_consumer_->Process_vkQueueInsertDebugUtilsLabelEXT(packet->call_info, packet->queue, &(packet->pLabelInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBeginDebugUtilsLabelEXT(Packet_vkCmdBeginDebugUtilsLabelEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBeginDebugUtilsLabelEXT(packet->call_info, packet->commandBuffer, &(packet->pLabelInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdEndDebugUtilsLabelEXT(Packet_vkCmdEndDebugUtilsLabelEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdEndDebugUtilsLabelEXT(packet->call_info, packet->commandBuffer); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdInsertDebugUtilsLabelEXT(Packet_vkCmdInsertDebugUtilsLabelEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdInsertDebugUtilsLabelEXT(packet->call_info, packet->commandBuffer, &(packet->pLabelInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDebugUtilsMessengerEXT(Packet_vkCreateDebugUtilsMessengerEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDebugUtilsMessengerEXT(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pMessenger)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyDebugUtilsMessengerEXT(Packet_vkDestroyDebugUtilsMessengerEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyDebugUtilsMessengerEXT(packet->call_info, packet->instance, packet->messenger, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSubmitDebugUtilsMessageEXT(Packet_vkSubmitDebugUtilsMessageEXT* packet) +{ + vulkan_replay_consumer_->Process_vkSubmitDebugUtilsMessageEXT(packet->call_info, packet->instance, packet->messageSeverity, packet->messageTypes, &(packet->pCallbackData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetAndroidHardwareBufferPropertiesANDROID(Packet_vkGetAndroidHardwareBufferPropertiesANDROID* packet) +{ + vulkan_replay_consumer_->Process_vkGetAndroidHardwareBufferPropertiesANDROID(packet->call_info, packet->return_value, packet->device, packet->buffer, &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryAndroidHardwareBufferANDROID(Packet_vkGetMemoryAndroidHardwareBufferANDROID* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryAndroidHardwareBufferANDROID(packet->call_info, packet->return_value, packet->device, &(packet->pInfo), &(packet->pBuffer)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetSampleLocationsEXT(Packet_vkCmdSetSampleLocationsEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetSampleLocationsEXT(packet->call_info, packet->commandBuffer, &(packet->pSampleLocationsInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceMultisamplePropertiesEXT(Packet_vkGetPhysicalDeviceMultisamplePropertiesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceMultisamplePropertiesEXT(packet->call_info, packet->physicalDevice, packet->samples, &(packet->pMultisampleProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageDrmFormatModifierPropertiesEXT(Packet_vkGetImageDrmFormatModifierPropertiesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageDrmFormatModifierPropertiesEXT(packet->call_info, packet->return_value, packet->device, packet->image, &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateValidationCacheEXT(Packet_vkCreateValidationCacheEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCreateValidationCacheEXT(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pValidationCache)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyValidationCacheEXT(Packet_vkDestroyValidationCacheEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyValidationCacheEXT(packet->call_info, packet->device, packet->validationCache, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkMergeValidationCachesEXT(Packet_vkMergeValidationCachesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkMergeValidationCachesEXT(packet->call_info, packet->return_value, packet->device, packet->dstCache, packet->srcCacheCount, &(packet->pSrcCaches)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetValidationCacheDataEXT(Packet_vkGetValidationCacheDataEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetValidationCacheDataEXT(packet->call_info, packet->return_value, packet->device, packet->validationCache, &(packet->pDataSize), &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindShadingRateImageNV(Packet_vkCmdBindShadingRateImageNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindShadingRateImageNV(packet->call_info, packet->commandBuffer, packet->imageView, packet->imageLayout); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetViewportShadingRatePaletteNV(Packet_vkCmdSetViewportShadingRatePaletteNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetViewportShadingRatePaletteNV(packet->call_info, packet->commandBuffer, packet->firstViewport, packet->viewportCount, &(packet->pShadingRatePalettes)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCoarseSampleOrderNV(Packet_vkCmdSetCoarseSampleOrderNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCoarseSampleOrderNV(packet->call_info, packet->commandBuffer, packet->sampleOrderType, packet->customSampleOrderCount, &(packet->pCustomSampleOrders)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateAccelerationStructureNV(Packet_vkCreateAccelerationStructureNV* packet) +{ + vulkan_replay_consumer_->Process_vkCreateAccelerationStructureNV(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pAccelerationStructure)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyAccelerationStructureNV(Packet_vkDestroyAccelerationStructureNV* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyAccelerationStructureNV(packet->call_info, packet->device, packet->accelerationStructure, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetAccelerationStructureMemoryRequirementsNV(Packet_vkGetAccelerationStructureMemoryRequirementsNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetAccelerationStructureMemoryRequirementsNV(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBindAccelerationStructureMemoryNV(Packet_vkBindAccelerationStructureMemoryNV* packet) +{ + vulkan_replay_consumer_->Process_vkBindAccelerationStructureMemoryNV(packet->call_info, packet->return_value, packet->device, packet->bindInfoCount, &(packet->pBindInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBuildAccelerationStructureNV(Packet_vkCmdBuildAccelerationStructureNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBuildAccelerationStructureNV(packet->call_info, packet->commandBuffer, &(packet->pInfo), packet->instanceData, packet->instanceOffset, packet->update, packet->dst, packet->src, packet->scratch, packet->scratchOffset); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyAccelerationStructureNV(Packet_vkCmdCopyAccelerationStructureNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyAccelerationStructureNV(packet->call_info, packet->commandBuffer, packet->dst, packet->src, packet->mode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdTraceRaysNV(Packet_vkCmdTraceRaysNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdTraceRaysNV(packet->call_info, packet->commandBuffer, packet->raygenShaderBindingTableBuffer, packet->raygenShaderBindingOffset, packet->missShaderBindingTableBuffer, packet->missShaderBindingOffset, packet->missShaderBindingStride, packet->hitShaderBindingTableBuffer, packet->hitShaderBindingOffset, packet->hitShaderBindingStride, packet->callableShaderBindingTableBuffer, packet->callableShaderBindingOffset, packet->callableShaderBindingStride, packet->width, packet->height, packet->depth); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateRayTracingPipelinesNV(Packet_vkCreateRayTracingPipelinesNV* packet) +{ + vulkan_replay_consumer_->Process_vkCreateRayTracingPipelinesNV(packet->call_info, packet->return_value, packet->device, packet->pipelineCache, packet->createInfoCount, &(packet->pCreateInfos), &(packet->pAllocator), &(packet->pPipelines)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetRayTracingShaderGroupHandlesKHR(Packet_vkGetRayTracingShaderGroupHandlesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetRayTracingShaderGroupHandlesKHR(packet->call_info, packet->return_value, packet->device, packet->pipeline, packet->firstGroup, packet->groupCount, packet->dataSize, &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetRayTracingShaderGroupHandlesNV(Packet_vkGetRayTracingShaderGroupHandlesNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetRayTracingShaderGroupHandlesNV(packet->call_info, packet->return_value, packet->device, packet->pipeline, packet->firstGroup, packet->groupCount, packet->dataSize, &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetAccelerationStructureHandleNV(Packet_vkGetAccelerationStructureHandleNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetAccelerationStructureHandleNV(packet->call_info, packet->return_value, packet->device, packet->accelerationStructure, packet->dataSize, &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWriteAccelerationStructuresPropertiesNV(Packet_vkCmdWriteAccelerationStructuresPropertiesNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWriteAccelerationStructuresPropertiesNV(packet->call_info, packet->commandBuffer, packet->accelerationStructureCount, &(packet->pAccelerationStructures), packet->queryType, packet->queryPool, packet->firstQuery); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCompileDeferredNV(Packet_vkCompileDeferredNV* packet) +{ + vulkan_replay_consumer_->Process_vkCompileDeferredNV(packet->call_info, packet->return_value, packet->device, packet->pipeline, packet->shader); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryHostPointerPropertiesEXT(Packet_vkGetMemoryHostPointerPropertiesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryHostPointerPropertiesEXT(packet->call_info, packet->return_value, packet->device, packet->handleType, packet->pHostPointer, &(packet->pMemoryHostPointerProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWriteBufferMarkerAMD(Packet_vkCmdWriteBufferMarkerAMD* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWriteBufferMarkerAMD(packet->call_info, packet->commandBuffer, packet->pipelineStage, packet->dstBuffer, packet->dstOffset, packet->marker); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(Packet_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pTimeDomainCount), &(packet->pTimeDomains)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetCalibratedTimestampsEXT(Packet_vkGetCalibratedTimestampsEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetCalibratedTimestampsEXT(packet->call_info, packet->return_value, packet->device, packet->timestampCount, &(packet->pTimestampInfos), &(packet->pTimestamps), &(packet->pMaxDeviation)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawMeshTasksNV(Packet_vkCmdDrawMeshTasksNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawMeshTasksNV(packet->call_info, packet->commandBuffer, packet->taskCount, packet->firstTask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawMeshTasksIndirectNV(Packet_vkCmdDrawMeshTasksIndirectNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawMeshTasksIndirectNV(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->drawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawMeshTasksIndirectCountNV(Packet_vkCmdDrawMeshTasksIndirectCountNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawMeshTasksIndirectCountNV(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->countBuffer, packet->countBufferOffset, packet->maxDrawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetExclusiveScissorEnableNV(Packet_vkCmdSetExclusiveScissorEnableNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetExclusiveScissorEnableNV(packet->call_info, packet->commandBuffer, packet->firstExclusiveScissor, packet->exclusiveScissorCount, &(packet->pExclusiveScissorEnables)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetExclusiveScissorNV(Packet_vkCmdSetExclusiveScissorNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetExclusiveScissorNV(packet->call_info, packet->commandBuffer, packet->firstExclusiveScissor, packet->exclusiveScissorCount, &(packet->pExclusiveScissors)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCheckpointNV(Packet_vkCmdSetCheckpointNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCheckpointNV(packet->call_info, packet->commandBuffer, packet->pCheckpointMarker); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetQueueCheckpointDataNV(Packet_vkGetQueueCheckpointDataNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetQueueCheckpointDataNV(packet->call_info, packet->queue, &(packet->pCheckpointDataCount), &(packet->pCheckpointData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkInitializePerformanceApiINTEL(Packet_vkInitializePerformanceApiINTEL* packet) +{ + vulkan_replay_consumer_->Process_vkInitializePerformanceApiINTEL(packet->call_info, packet->return_value, packet->device, &(packet->pInitializeInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkUninitializePerformanceApiINTEL(Packet_vkUninitializePerformanceApiINTEL* packet) +{ + vulkan_replay_consumer_->Process_vkUninitializePerformanceApiINTEL(packet->call_info, packet->device); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetPerformanceMarkerINTEL(Packet_vkCmdSetPerformanceMarkerINTEL* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetPerformanceMarkerINTEL(packet->call_info, packet->return_value, packet->commandBuffer, &(packet->pMarkerInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetPerformanceStreamMarkerINTEL(Packet_vkCmdSetPerformanceStreamMarkerINTEL* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetPerformanceStreamMarkerINTEL(packet->call_info, packet->return_value, packet->commandBuffer, &(packet->pMarkerInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetPerformanceOverrideINTEL(Packet_vkCmdSetPerformanceOverrideINTEL* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetPerformanceOverrideINTEL(packet->call_info, packet->return_value, packet->commandBuffer, &(packet->pOverrideInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAcquirePerformanceConfigurationINTEL(Packet_vkAcquirePerformanceConfigurationINTEL* packet) +{ + vulkan_replay_consumer_->Process_vkAcquirePerformanceConfigurationINTEL(packet->call_info, packet->return_value, packet->device, &(packet->pAcquireInfo), &(packet->pConfiguration)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkReleasePerformanceConfigurationINTEL(Packet_vkReleasePerformanceConfigurationINTEL* packet) +{ + vulkan_replay_consumer_->Process_vkReleasePerformanceConfigurationINTEL(packet->call_info, packet->return_value, packet->device, packet->configuration); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueSetPerformanceConfigurationINTEL(Packet_vkQueueSetPerformanceConfigurationINTEL* packet) +{ + vulkan_replay_consumer_->Process_vkQueueSetPerformanceConfigurationINTEL(packet->call_info, packet->return_value, packet->queue, packet->configuration); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPerformanceParameterINTEL(Packet_vkGetPerformanceParameterINTEL* packet) +{ + vulkan_replay_consumer_->Process_vkGetPerformanceParameterINTEL(packet->call_info, packet->return_value, packet->device, packet->parameter, &(packet->pValue)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetLocalDimmingAMD(Packet_vkSetLocalDimmingAMD* packet) +{ + vulkan_replay_consumer_->Process_vkSetLocalDimmingAMD(packet->call_info, packet->device, packet->swapChain, packet->localDimmingEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateImagePipeSurfaceFUCHSIA(Packet_vkCreateImagePipeSurfaceFUCHSIA* packet) +{ + vulkan_replay_consumer_->Process_vkCreateImagePipeSurfaceFUCHSIA(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateMetalSurfaceEXT(Packet_vkCreateMetalSurfaceEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCreateMetalSurfaceEXT(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetBufferDeviceAddressEXT(Packet_vkGetBufferDeviceAddressEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetBufferDeviceAddressEXT(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceToolPropertiesEXT(Packet_vkGetPhysicalDeviceToolPropertiesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceToolPropertiesEXT(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pToolCount), &(packet->pToolProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(Packet_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pPropertyCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(Packet_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pCombinationCount), &(packet->pCombinations)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceSurfacePresentModes2EXT(Packet_vkGetPhysicalDeviceSurfacePresentModes2EXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceSurfacePresentModes2EXT(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pSurfaceInfo), &(packet->pPresentModeCount), &(packet->pPresentModes)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAcquireFullScreenExclusiveModeEXT(Packet_vkAcquireFullScreenExclusiveModeEXT* packet) +{ + vulkan_replay_consumer_->Process_vkAcquireFullScreenExclusiveModeEXT(packet->call_info, packet->return_value, packet->device, packet->swapchain); + + return; +} + +void VulkanPreloadReplayer::Replay_vkReleaseFullScreenExclusiveModeEXT(Packet_vkReleaseFullScreenExclusiveModeEXT* packet) +{ + vulkan_replay_consumer_->Process_vkReleaseFullScreenExclusiveModeEXT(packet->call_info, packet->return_value, packet->device, packet->swapchain); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceGroupSurfacePresentModes2EXT(Packet_vkGetDeviceGroupSurfacePresentModes2EXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceGroupSurfacePresentModes2EXT(packet->call_info, packet->return_value, packet->device, &(packet->pSurfaceInfo), &(packet->pModes)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateHeadlessSurfaceEXT(Packet_vkCreateHeadlessSurfaceEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCreateHeadlessSurfaceEXT(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetLineStippleEXT(Packet_vkCmdSetLineStippleEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetLineStippleEXT(packet->call_info, packet->commandBuffer, packet->lineStippleFactor, packet->lineStipplePattern); + + return; +} + +void VulkanPreloadReplayer::Replay_vkResetQueryPoolEXT(Packet_vkResetQueryPoolEXT* packet) +{ + vulkan_replay_consumer_->Process_vkResetQueryPoolEXT(packet->call_info, packet->device, packet->queryPool, packet->firstQuery, packet->queryCount); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCullModeEXT(Packet_vkCmdSetCullModeEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCullModeEXT(packet->call_info, packet->commandBuffer, packet->cullMode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetFrontFaceEXT(Packet_vkCmdSetFrontFaceEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetFrontFaceEXT(packet->call_info, packet->commandBuffer, packet->frontFace); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetPrimitiveTopologyEXT(Packet_vkCmdSetPrimitiveTopologyEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetPrimitiveTopologyEXT(packet->call_info, packet->commandBuffer, packet->primitiveTopology); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetViewportWithCountEXT(Packet_vkCmdSetViewportWithCountEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetViewportWithCountEXT(packet->call_info, packet->commandBuffer, packet->viewportCount, &(packet->pViewports)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetScissorWithCountEXT(Packet_vkCmdSetScissorWithCountEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetScissorWithCountEXT(packet->call_info, packet->commandBuffer, packet->scissorCount, &(packet->pScissors)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindVertexBuffers2EXT(Packet_vkCmdBindVertexBuffers2EXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindVertexBuffers2EXT(packet->call_info, packet->commandBuffer, packet->firstBinding, packet->bindingCount, &(packet->pBuffers), &(packet->pOffsets), &(packet->pSizes), &(packet->pStrides)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthTestEnableEXT(Packet_vkCmdSetDepthTestEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthTestEnableEXT(packet->call_info, packet->commandBuffer, packet->depthTestEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthWriteEnableEXT(Packet_vkCmdSetDepthWriteEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthWriteEnableEXT(packet->call_info, packet->commandBuffer, packet->depthWriteEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthCompareOpEXT(Packet_vkCmdSetDepthCompareOpEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthCompareOpEXT(packet->call_info, packet->commandBuffer, packet->depthCompareOp); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthBoundsTestEnableEXT(Packet_vkCmdSetDepthBoundsTestEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthBoundsTestEnableEXT(packet->call_info, packet->commandBuffer, packet->depthBoundsTestEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetStencilTestEnableEXT(Packet_vkCmdSetStencilTestEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetStencilTestEnableEXT(packet->call_info, packet->commandBuffer, packet->stencilTestEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetStencilOpEXT(Packet_vkCmdSetStencilOpEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetStencilOpEXT(packet->call_info, packet->commandBuffer, packet->faceMask, packet->failOp, packet->passOp, packet->depthFailOp, packet->compareOp); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCopyMemoryToImageEXT(Packet_vkCopyMemoryToImageEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCopyMemoryToImageEXT(packet->call_info, packet->return_value, packet->device, &(packet->pCopyMemoryToImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCopyImageToMemoryEXT(Packet_vkCopyImageToMemoryEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCopyImageToMemoryEXT(packet->call_info, packet->return_value, packet->device, &(packet->pCopyImageToMemoryInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCopyImageToImageEXT(Packet_vkCopyImageToImageEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCopyImageToImageEXT(packet->call_info, packet->return_value, packet->device, &(packet->pCopyImageToImageInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkTransitionImageLayoutEXT(Packet_vkTransitionImageLayoutEXT* packet) +{ + vulkan_replay_consumer_->Process_vkTransitionImageLayoutEXT(packet->call_info, packet->return_value, packet->device, packet->transitionCount, &(packet->pTransitions)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetImageSubresourceLayout2EXT(Packet_vkGetImageSubresourceLayout2EXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetImageSubresourceLayout2EXT(packet->call_info, packet->device, packet->image, &(packet->pSubresource), &(packet->pLayout)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkReleaseSwapchainImagesEXT(Packet_vkReleaseSwapchainImagesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkReleaseSwapchainImagesEXT(packet->call_info, packet->return_value, packet->device, &(packet->pReleaseInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetGeneratedCommandsMemoryRequirementsNV(Packet_vkGetGeneratedCommandsMemoryRequirementsNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetGeneratedCommandsMemoryRequirementsNV(packet->call_info, packet->device, &(packet->pInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdPreprocessGeneratedCommandsNV(Packet_vkCmdPreprocessGeneratedCommandsNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdPreprocessGeneratedCommandsNV(packet->call_info, packet->commandBuffer, &(packet->pGeneratedCommandsInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdExecuteGeneratedCommandsNV(Packet_vkCmdExecuteGeneratedCommandsNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdExecuteGeneratedCommandsNV(packet->call_info, packet->commandBuffer, packet->isPreprocessed, &(packet->pGeneratedCommandsInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindPipelineShaderGroupNV(Packet_vkCmdBindPipelineShaderGroupNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindPipelineShaderGroupNV(packet->call_info, packet->commandBuffer, packet->pipelineBindPoint, packet->pipeline, packet->groupIndex); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateIndirectCommandsLayoutNV(Packet_vkCreateIndirectCommandsLayoutNV* packet) +{ + vulkan_replay_consumer_->Process_vkCreateIndirectCommandsLayoutNV(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pIndirectCommandsLayout)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyIndirectCommandsLayoutNV(Packet_vkDestroyIndirectCommandsLayoutNV* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyIndirectCommandsLayoutNV(packet->call_info, packet->device, packet->indirectCommandsLayout, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthBias2EXT(Packet_vkCmdSetDepthBias2EXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthBias2EXT(packet->call_info, packet->commandBuffer, &(packet->pDepthBiasInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAcquireDrmDisplayEXT(Packet_vkAcquireDrmDisplayEXT* packet) +{ + vulkan_replay_consumer_->Process_vkAcquireDrmDisplayEXT(packet->call_info, packet->return_value, packet->physicalDevice, packet->drmFd, packet->display); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDrmDisplayEXT(Packet_vkGetDrmDisplayEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetDrmDisplayEXT(packet->call_info, packet->return_value, packet->physicalDevice, packet->drmFd, packet->connectorId, &(packet->display)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreatePrivateDataSlotEXT(Packet_vkCreatePrivateDataSlotEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCreatePrivateDataSlotEXT(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pPrivateDataSlot)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyPrivateDataSlotEXT(Packet_vkDestroyPrivateDataSlotEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyPrivateDataSlotEXT(packet->call_info, packet->device, packet->privateDataSlot, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetPrivateDataEXT(Packet_vkSetPrivateDataEXT* packet) +{ + vulkan_replay_consumer_->Process_vkSetPrivateDataEXT(packet->call_info, packet->return_value, packet->device, packet->objectType, packet->objectHandle, packet->privateDataSlot, packet->data); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPrivateDataEXT(Packet_vkGetPrivateDataEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetPrivateDataEXT(packet->call_info, packet->device, packet->objectType, packet->objectHandle, packet->privateDataSlot, &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetFragmentShadingRateEnumNV(Packet_vkCmdSetFragmentShadingRateEnumNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetFragmentShadingRateEnumNV(packet->call_info, packet->commandBuffer, packet->shadingRate, &(packet->combinerOps)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceFaultInfoEXT(Packet_vkGetDeviceFaultInfoEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceFaultInfoEXT(packet->call_info, packet->return_value, packet->device, &(packet->pFaultCounts), &(packet->pFaultInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkAcquireWinrtDisplayNV(Packet_vkAcquireWinrtDisplayNV* packet) +{ + vulkan_replay_consumer_->Process_vkAcquireWinrtDisplayNV(packet->call_info, packet->return_value, packet->physicalDevice, packet->display); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetWinrtDisplayNV(Packet_vkGetWinrtDisplayNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetWinrtDisplayNV(packet->call_info, packet->return_value, packet->physicalDevice, packet->deviceRelativeId, &(packet->pDisplay)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateDirectFBSurfaceEXT(Packet_vkCreateDirectFBSurfaceEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCreateDirectFBSurfaceEXT(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(Packet_vkGetPhysicalDeviceDirectFBPresentationSupportEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(packet->call_info, packet->return_value, packet->physicalDevice, packet->queueFamilyIndex, packet->dfb); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetVertexInputEXT(Packet_vkCmdSetVertexInputEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetVertexInputEXT(packet->call_info, packet->commandBuffer, packet->vertexBindingDescriptionCount, &(packet->pVertexBindingDescriptions), packet->vertexAttributeDescriptionCount, &(packet->pVertexAttributeDescriptions)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryZirconHandleFUCHSIA(Packet_vkGetMemoryZirconHandleFUCHSIA* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryZirconHandleFUCHSIA(packet->call_info, packet->return_value, packet->device, &(packet->pGetZirconHandleInfo), &(packet->pZirconHandle)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryZirconHandlePropertiesFUCHSIA(Packet_vkGetMemoryZirconHandlePropertiesFUCHSIA* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryZirconHandlePropertiesFUCHSIA(packet->call_info, packet->return_value, packet->device, packet->handleType, packet->zirconHandle, &(packet->pMemoryZirconHandleProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkImportSemaphoreZirconHandleFUCHSIA(Packet_vkImportSemaphoreZirconHandleFUCHSIA* packet) +{ + vulkan_replay_consumer_->Process_vkImportSemaphoreZirconHandleFUCHSIA(packet->call_info, packet->return_value, packet->device, &(packet->pImportSemaphoreZirconHandleInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetSemaphoreZirconHandleFUCHSIA(Packet_vkGetSemaphoreZirconHandleFUCHSIA* packet) +{ + vulkan_replay_consumer_->Process_vkGetSemaphoreZirconHandleFUCHSIA(packet->call_info, packet->return_value, packet->device, &(packet->pGetZirconHandleInfo), &(packet->pZirconHandle)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindInvocationMaskHUAWEI(Packet_vkCmdBindInvocationMaskHUAWEI* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindInvocationMaskHUAWEI(packet->call_info, packet->commandBuffer, packet->imageView, packet->imageLayout); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMemoryRemoteAddressNV(Packet_vkGetMemoryRemoteAddressNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetMemoryRemoteAddressNV(packet->call_info, packet->return_value, packet->device, &(packet->pMemoryGetRemoteAddressInfo), &(packet->pAddress)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetPatchControlPointsEXT(Packet_vkCmdSetPatchControlPointsEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetPatchControlPointsEXT(packet->call_info, packet->commandBuffer, packet->patchControlPoints); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetRasterizerDiscardEnableEXT(Packet_vkCmdSetRasterizerDiscardEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetRasterizerDiscardEnableEXT(packet->call_info, packet->commandBuffer, packet->rasterizerDiscardEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthBiasEnableEXT(Packet_vkCmdSetDepthBiasEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthBiasEnableEXT(packet->call_info, packet->commandBuffer, packet->depthBiasEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetLogicOpEXT(Packet_vkCmdSetLogicOpEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetLogicOpEXT(packet->call_info, packet->commandBuffer, packet->logicOp); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetPrimitiveRestartEnableEXT(Packet_vkCmdSetPrimitiveRestartEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetPrimitiveRestartEnableEXT(packet->call_info, packet->commandBuffer, packet->primitiveRestartEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateScreenSurfaceQNX(Packet_vkCreateScreenSurfaceQNX* packet) +{ + vulkan_replay_consumer_->Process_vkCreateScreenSurfaceQNX(packet->call_info, packet->return_value, packet->instance, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSurface)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceScreenPresentationSupportQNX(Packet_vkGetPhysicalDeviceScreenPresentationSupportQNX* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceScreenPresentationSupportQNX(packet->call_info, packet->return_value, packet->physicalDevice, packet->queueFamilyIndex, packet->window); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetColorWriteEnableEXT(Packet_vkCmdSetColorWriteEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetColorWriteEnableEXT(packet->call_info, packet->commandBuffer, packet->attachmentCount, &(packet->pColorWriteEnables)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawMultiEXT(Packet_vkCmdDrawMultiEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawMultiEXT(packet->call_info, packet->commandBuffer, packet->drawCount, &(packet->pVertexInfo), packet->instanceCount, packet->firstInstance, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawMultiIndexedEXT(Packet_vkCmdDrawMultiIndexedEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawMultiIndexedEXT(packet->call_info, packet->commandBuffer, packet->drawCount, &(packet->pIndexInfo), packet->instanceCount, packet->firstInstance, packet->stride, &(packet->pVertexOffset)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateMicromapEXT(Packet_vkCreateMicromapEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCreateMicromapEXT(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pMicromap)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyMicromapEXT(Packet_vkDestroyMicromapEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyMicromapEXT(packet->call_info, packet->device, packet->micromap, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBuildMicromapsEXT(Packet_vkCmdBuildMicromapsEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBuildMicromapsEXT(packet->call_info, packet->commandBuffer, packet->infoCount, &(packet->pInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBuildMicromapsEXT(Packet_vkBuildMicromapsEXT* packet) +{ + vulkan_replay_consumer_->Process_vkBuildMicromapsEXT(packet->call_info, packet->return_value, packet->device, packet->deferredOperation, packet->infoCount, &(packet->pInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCopyMicromapEXT(Packet_vkCopyMicromapEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCopyMicromapEXT(packet->call_info, packet->return_value, packet->device, packet->deferredOperation, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCopyMicromapToMemoryEXT(Packet_vkCopyMicromapToMemoryEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCopyMicromapToMemoryEXT(packet->call_info, packet->return_value, packet->device, packet->deferredOperation, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCopyMemoryToMicromapEXT(Packet_vkCopyMemoryToMicromapEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCopyMemoryToMicromapEXT(packet->call_info, packet->return_value, packet->device, packet->deferredOperation, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkWriteMicromapsPropertiesEXT(Packet_vkWriteMicromapsPropertiesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkWriteMicromapsPropertiesEXT(packet->call_info, packet->return_value, packet->device, packet->micromapCount, &(packet->pMicromaps), packet->queryType, packet->dataSize, &(packet->pData), packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyMicromapEXT(Packet_vkCmdCopyMicromapEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyMicromapEXT(packet->call_info, packet->commandBuffer, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyMicromapToMemoryEXT(Packet_vkCmdCopyMicromapToMemoryEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyMicromapToMemoryEXT(packet->call_info, packet->commandBuffer, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyMemoryToMicromapEXT(Packet_vkCmdCopyMemoryToMicromapEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyMemoryToMicromapEXT(packet->call_info, packet->commandBuffer, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWriteMicromapsPropertiesEXT(Packet_vkCmdWriteMicromapsPropertiesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWriteMicromapsPropertiesEXT(packet->call_info, packet->commandBuffer, packet->micromapCount, &(packet->pMicromaps), packet->queryType, packet->queryPool, packet->firstQuery); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceMicromapCompatibilityEXT(Packet_vkGetDeviceMicromapCompatibilityEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceMicromapCompatibilityEXT(packet->call_info, packet->device, &(packet->pVersionInfo), &(packet->pCompatibility)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetMicromapBuildSizesEXT(Packet_vkGetMicromapBuildSizesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetMicromapBuildSizesEXT(packet->call_info, packet->device, packet->buildType, &(packet->pBuildInfo), &(packet->pSizeInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawClusterHUAWEI(Packet_vkCmdDrawClusterHUAWEI* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawClusterHUAWEI(packet->call_info, packet->commandBuffer, packet->groupCountX, packet->groupCountY, packet->groupCountZ); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawClusterIndirectHUAWEI(Packet_vkCmdDrawClusterIndirectHUAWEI* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawClusterIndirectHUAWEI(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetDeviceMemoryPriorityEXT(Packet_vkSetDeviceMemoryPriorityEXT* packet) +{ + vulkan_replay_consumer_->Process_vkSetDeviceMemoryPriorityEXT(packet->call_info, packet->device, packet->memory, packet->priority); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDescriptorSetLayoutHostMappingInfoVALVE(Packet_vkGetDescriptorSetLayoutHostMappingInfoVALVE* packet) +{ + vulkan_replay_consumer_->Process_vkGetDescriptorSetLayoutHostMappingInfoVALVE(packet->call_info, packet->device, &(packet->pBindingReference), &(packet->pHostMapping)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDescriptorSetHostMappingVALVE(Packet_vkGetDescriptorSetHostMappingVALVE* packet) +{ + vulkan_replay_consumer_->Process_vkGetDescriptorSetHostMappingVALVE(packet->call_info, packet->device, packet->descriptorSet, &(packet->ppData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPipelineIndirectMemoryRequirementsNV(Packet_vkGetPipelineIndirectMemoryRequirementsNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetPipelineIndirectMemoryRequirementsNV(packet->call_info, packet->device, &(packet->pCreateInfo), &(packet->pMemoryRequirements)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdUpdatePipelineIndirectBufferNV(Packet_vkCmdUpdatePipelineIndirectBufferNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdUpdatePipelineIndirectBufferNV(packet->call_info, packet->commandBuffer, packet->pipelineBindPoint, packet->pipeline); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPipelineIndirectDeviceAddressNV(Packet_vkGetPipelineIndirectDeviceAddressNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetPipelineIndirectDeviceAddressNV(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthClampEnableEXT(Packet_vkCmdSetDepthClampEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthClampEnableEXT(packet->call_info, packet->commandBuffer, packet->depthClampEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetPolygonModeEXT(Packet_vkCmdSetPolygonModeEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetPolygonModeEXT(packet->call_info, packet->commandBuffer, packet->polygonMode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetRasterizationSamplesEXT(Packet_vkCmdSetRasterizationSamplesEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetRasterizationSamplesEXT(packet->call_info, packet->commandBuffer, packet->rasterizationSamples); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetSampleMaskEXT(Packet_vkCmdSetSampleMaskEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetSampleMaskEXT(packet->call_info, packet->commandBuffer, packet->samples, &(packet->pSampleMask)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetAlphaToCoverageEnableEXT(Packet_vkCmdSetAlphaToCoverageEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetAlphaToCoverageEnableEXT(packet->call_info, packet->commandBuffer, packet->alphaToCoverageEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetAlphaToOneEnableEXT(Packet_vkCmdSetAlphaToOneEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetAlphaToOneEnableEXT(packet->call_info, packet->commandBuffer, packet->alphaToOneEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetLogicOpEnableEXT(Packet_vkCmdSetLogicOpEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetLogicOpEnableEXT(packet->call_info, packet->commandBuffer, packet->logicOpEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetColorBlendEnableEXT(Packet_vkCmdSetColorBlendEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetColorBlendEnableEXT(packet->call_info, packet->commandBuffer, packet->firstAttachment, packet->attachmentCount, &(packet->pColorBlendEnables)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetColorBlendEquationEXT(Packet_vkCmdSetColorBlendEquationEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetColorBlendEquationEXT(packet->call_info, packet->commandBuffer, packet->firstAttachment, packet->attachmentCount, &(packet->pColorBlendEquations)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetColorWriteMaskEXT(Packet_vkCmdSetColorWriteMaskEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetColorWriteMaskEXT(packet->call_info, packet->commandBuffer, packet->firstAttachment, packet->attachmentCount, &(packet->pColorWriteMasks)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetTessellationDomainOriginEXT(Packet_vkCmdSetTessellationDomainOriginEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetTessellationDomainOriginEXT(packet->call_info, packet->commandBuffer, packet->domainOrigin); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetRasterizationStreamEXT(Packet_vkCmdSetRasterizationStreamEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetRasterizationStreamEXT(packet->call_info, packet->commandBuffer, packet->rasterizationStream); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetConservativeRasterizationModeEXT(Packet_vkCmdSetConservativeRasterizationModeEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetConservativeRasterizationModeEXT(packet->call_info, packet->commandBuffer, packet->conservativeRasterizationMode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetExtraPrimitiveOverestimationSizeEXT(Packet_vkCmdSetExtraPrimitiveOverestimationSizeEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetExtraPrimitiveOverestimationSizeEXT(packet->call_info, packet->commandBuffer, packet->extraPrimitiveOverestimationSize); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthClipEnableEXT(Packet_vkCmdSetDepthClipEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthClipEnableEXT(packet->call_info, packet->commandBuffer, packet->depthClipEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetSampleLocationsEnableEXT(Packet_vkCmdSetSampleLocationsEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetSampleLocationsEnableEXT(packet->call_info, packet->commandBuffer, packet->sampleLocationsEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetColorBlendAdvancedEXT(Packet_vkCmdSetColorBlendAdvancedEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetColorBlendAdvancedEXT(packet->call_info, packet->commandBuffer, packet->firstAttachment, packet->attachmentCount, &(packet->pColorBlendAdvanced)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetProvokingVertexModeEXT(Packet_vkCmdSetProvokingVertexModeEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetProvokingVertexModeEXT(packet->call_info, packet->commandBuffer, packet->provokingVertexMode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetLineRasterizationModeEXT(Packet_vkCmdSetLineRasterizationModeEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetLineRasterizationModeEXT(packet->call_info, packet->commandBuffer, packet->lineRasterizationMode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetLineStippleEnableEXT(Packet_vkCmdSetLineStippleEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetLineStippleEnableEXT(packet->call_info, packet->commandBuffer, packet->stippledLineEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetDepthClipNegativeOneToOneEXT(Packet_vkCmdSetDepthClipNegativeOneToOneEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetDepthClipNegativeOneToOneEXT(packet->call_info, packet->commandBuffer, packet->negativeOneToOne); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetViewportWScalingEnableNV(Packet_vkCmdSetViewportWScalingEnableNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetViewportWScalingEnableNV(packet->call_info, packet->commandBuffer, packet->viewportWScalingEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetViewportSwizzleNV(Packet_vkCmdSetViewportSwizzleNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetViewportSwizzleNV(packet->call_info, packet->commandBuffer, packet->firstViewport, packet->viewportCount, &(packet->pViewportSwizzles)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCoverageToColorEnableNV(Packet_vkCmdSetCoverageToColorEnableNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCoverageToColorEnableNV(packet->call_info, packet->commandBuffer, packet->coverageToColorEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCoverageToColorLocationNV(Packet_vkCmdSetCoverageToColorLocationNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCoverageToColorLocationNV(packet->call_info, packet->commandBuffer, packet->coverageToColorLocation); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCoverageModulationModeNV(Packet_vkCmdSetCoverageModulationModeNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCoverageModulationModeNV(packet->call_info, packet->commandBuffer, packet->coverageModulationMode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCoverageModulationTableEnableNV(Packet_vkCmdSetCoverageModulationTableEnableNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCoverageModulationTableEnableNV(packet->call_info, packet->commandBuffer, packet->coverageModulationTableEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCoverageModulationTableNV(Packet_vkCmdSetCoverageModulationTableNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCoverageModulationTableNV(packet->call_info, packet->commandBuffer, packet->coverageModulationTableCount, &(packet->pCoverageModulationTable)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetShadingRateImageEnableNV(Packet_vkCmdSetShadingRateImageEnableNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetShadingRateImageEnableNV(packet->call_info, packet->commandBuffer, packet->shadingRateImageEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetRepresentativeFragmentTestEnableNV(Packet_vkCmdSetRepresentativeFragmentTestEnableNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetRepresentativeFragmentTestEnableNV(packet->call_info, packet->commandBuffer, packet->representativeFragmentTestEnable); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetCoverageReductionModeNV(Packet_vkCmdSetCoverageReductionModeNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetCoverageReductionModeNV(packet->call_info, packet->commandBuffer, packet->coverageReductionMode); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetShaderModuleIdentifierEXT(Packet_vkGetShaderModuleIdentifierEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetShaderModuleIdentifierEXT(packet->call_info, packet->device, packet->shaderModule, &(packet->pIdentifier)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetShaderModuleCreateInfoIdentifierEXT(Packet_vkGetShaderModuleCreateInfoIdentifierEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetShaderModuleCreateInfoIdentifierEXT(packet->call_info, packet->device, &(packet->pCreateInfo), &(packet->pIdentifier)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(Packet_vkGetPhysicalDeviceOpticalFlowImageFormatsNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(packet->call_info, packet->return_value, packet->physicalDevice, &(packet->pOpticalFlowImageFormatInfo), &(packet->pFormatCount), &(packet->pImageFormatProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateOpticalFlowSessionNV(Packet_vkCreateOpticalFlowSessionNV* packet) +{ + vulkan_replay_consumer_->Process_vkCreateOpticalFlowSessionNV(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pSession)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyOpticalFlowSessionNV(Packet_vkDestroyOpticalFlowSessionNV* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyOpticalFlowSessionNV(packet->call_info, packet->device, packet->session, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkBindOpticalFlowSessionImageNV(Packet_vkBindOpticalFlowSessionImageNV* packet) +{ + vulkan_replay_consumer_->Process_vkBindOpticalFlowSessionImageNV(packet->call_info, packet->return_value, packet->device, packet->session, packet->bindingPoint, packet->view, packet->layout); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdOpticalFlowExecuteNV(Packet_vkCmdOpticalFlowExecuteNV* packet) +{ + vulkan_replay_consumer_->Process_vkCmdOpticalFlowExecuteNV(packet->call_info, packet->commandBuffer, packet->session, &(packet->pExecuteInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateShadersEXT(Packet_vkCreateShadersEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCreateShadersEXT(packet->call_info, packet->return_value, packet->device, packet->createInfoCount, &(packet->pCreateInfos), &(packet->pAllocator), &(packet->pShaders)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyShaderEXT(Packet_vkDestroyShaderEXT* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyShaderEXT(packet->call_info, packet->device, packet->shader, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetShaderBinaryDataEXT(Packet_vkGetShaderBinaryDataEXT* packet) +{ + vulkan_replay_consumer_->Process_vkGetShaderBinaryDataEXT(packet->call_info, packet->return_value, packet->device, packet->shader, &(packet->pDataSize), &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBindShadersEXT(Packet_vkCmdBindShadersEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBindShadersEXT(packet->call_info, packet->commandBuffer, packet->stageCount, &(packet->pStages), &(packet->pShaders)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetFramebufferTilePropertiesQCOM(Packet_vkGetFramebufferTilePropertiesQCOM* packet) +{ + vulkan_replay_consumer_->Process_vkGetFramebufferTilePropertiesQCOM(packet->call_info, packet->return_value, packet->device, packet->framebuffer, &(packet->pPropertiesCount), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDynamicRenderingTilePropertiesQCOM(Packet_vkGetDynamicRenderingTilePropertiesQCOM* packet) +{ + vulkan_replay_consumer_->Process_vkGetDynamicRenderingTilePropertiesQCOM(packet->call_info, packet->return_value, packet->device, &(packet->pRenderingInfo), &(packet->pProperties)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetLatencySleepModeNV(Packet_vkSetLatencySleepModeNV* packet) +{ + vulkan_replay_consumer_->Process_vkSetLatencySleepModeNV(packet->call_info, packet->return_value, packet->device, packet->swapchain, &(packet->pSleepModeInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkLatencySleepNV(Packet_vkLatencySleepNV* packet) +{ + vulkan_replay_consumer_->Process_vkLatencySleepNV(packet->call_info, packet->return_value, packet->device, packet->swapchain, &(packet->pSleepInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkSetLatencyMarkerNV(Packet_vkSetLatencyMarkerNV* packet) +{ + vulkan_replay_consumer_->Process_vkSetLatencyMarkerNV(packet->call_info, packet->device, packet->swapchain, &(packet->pLatencyMarkerInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetLatencyTimingsNV(Packet_vkGetLatencyTimingsNV* packet) +{ + vulkan_replay_consumer_->Process_vkGetLatencyTimingsNV(packet->call_info, packet->device, packet->swapchain, &(packet->pLatencyMarkerInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkQueueNotifyOutOfBandNV(Packet_vkQueueNotifyOutOfBandNV* packet) +{ + vulkan_replay_consumer_->Process_vkQueueNotifyOutOfBandNV(packet->call_info, packet->queue, &(packet->pQueueTypeInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetAttachmentFeedbackLoopEnableEXT(Packet_vkCmdSetAttachmentFeedbackLoopEnableEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetAttachmentFeedbackLoopEnableEXT(packet->call_info, packet->commandBuffer, packet->aspectMask); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCreateAccelerationStructureKHR(Packet_vkCreateAccelerationStructureKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCreateAccelerationStructureKHR(packet->call_info, packet->return_value, packet->device, &(packet->pCreateInfo), &(packet->pAllocator), &(packet->pAccelerationStructure)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkDestroyAccelerationStructureKHR(Packet_vkDestroyAccelerationStructureKHR* packet) +{ + vulkan_replay_consumer_->Process_vkDestroyAccelerationStructureKHR(packet->call_info, packet->device, packet->accelerationStructure, &(packet->pAllocator)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBuildAccelerationStructuresKHR(Packet_vkCmdBuildAccelerationStructuresKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBuildAccelerationStructuresKHR(packet->call_info, packet->commandBuffer, packet->infoCount, &(packet->pInfos), &(packet->ppBuildRangeInfos)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdBuildAccelerationStructuresIndirectKHR(Packet_vkCmdBuildAccelerationStructuresIndirectKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdBuildAccelerationStructuresIndirectKHR(packet->call_info, packet->commandBuffer, packet->infoCount, &(packet->pInfos), &(packet->pIndirectDeviceAddresses), &(packet->pIndirectStrides), &(packet->ppMaxPrimitiveCounts)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCopyAccelerationStructureToMemoryKHR(Packet_vkCopyAccelerationStructureToMemoryKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCopyAccelerationStructureToMemoryKHR(packet->call_info, packet->return_value, packet->device, packet->deferredOperation, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCopyMemoryToAccelerationStructureKHR(Packet_vkCopyMemoryToAccelerationStructureKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCopyMemoryToAccelerationStructureKHR(packet->call_info, packet->return_value, packet->device, packet->deferredOperation, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkWriteAccelerationStructuresPropertiesKHR(Packet_vkWriteAccelerationStructuresPropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkWriteAccelerationStructuresPropertiesKHR(packet->call_info, packet->return_value, packet->device, packet->accelerationStructureCount, &(packet->pAccelerationStructures), packet->queryType, packet->dataSize, &(packet->pData), packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyAccelerationStructureKHR(Packet_vkCmdCopyAccelerationStructureKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyAccelerationStructureKHR(packet->call_info, packet->commandBuffer, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyAccelerationStructureToMemoryKHR(Packet_vkCmdCopyAccelerationStructureToMemoryKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyAccelerationStructureToMemoryKHR(packet->call_info, packet->commandBuffer, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdCopyMemoryToAccelerationStructureKHR(Packet_vkCmdCopyMemoryToAccelerationStructureKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdCopyMemoryToAccelerationStructureKHR(packet->call_info, packet->commandBuffer, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetAccelerationStructureDeviceAddressKHR(Packet_vkGetAccelerationStructureDeviceAddressKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetAccelerationStructureDeviceAddressKHR(packet->call_info, packet->return_value, packet->device, &(packet->pInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdWriteAccelerationStructuresPropertiesKHR(Packet_vkCmdWriteAccelerationStructuresPropertiesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdWriteAccelerationStructuresPropertiesKHR(packet->call_info, packet->commandBuffer, packet->accelerationStructureCount, &(packet->pAccelerationStructures), packet->queryType, packet->queryPool, packet->firstQuery); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetDeviceAccelerationStructureCompatibilityKHR(Packet_vkGetDeviceAccelerationStructureCompatibilityKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetDeviceAccelerationStructureCompatibilityKHR(packet->call_info, packet->device, &(packet->pVersionInfo), &(packet->pCompatibility)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetAccelerationStructureBuildSizesKHR(Packet_vkGetAccelerationStructureBuildSizesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetAccelerationStructureBuildSizesKHR(packet->call_info, packet->device, packet->buildType, &(packet->pBuildInfo), &(packet->pMaxPrimitiveCounts), &(packet->pSizeInfo)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdTraceRaysKHR(Packet_vkCmdTraceRaysKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdTraceRaysKHR(packet->call_info, packet->commandBuffer, &(packet->pRaygenShaderBindingTable), &(packet->pMissShaderBindingTable), &(packet->pHitShaderBindingTable), &(packet->pCallableShaderBindingTable), packet->width, packet->height, packet->depth); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(Packet_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(packet->call_info, packet->return_value, packet->device, packet->pipeline, packet->firstGroup, packet->groupCount, packet->dataSize, &(packet->pData)); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdTraceRaysIndirectKHR(Packet_vkCmdTraceRaysIndirectKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdTraceRaysIndirectKHR(packet->call_info, packet->commandBuffer, &(packet->pRaygenShaderBindingTable), &(packet->pMissShaderBindingTable), &(packet->pHitShaderBindingTable), &(packet->pCallableShaderBindingTable), packet->indirectDeviceAddress); + + return; +} + +void VulkanPreloadReplayer::Replay_vkGetRayTracingShaderGroupStackSizeKHR(Packet_vkGetRayTracingShaderGroupStackSizeKHR* packet) +{ + vulkan_replay_consumer_->Process_vkGetRayTracingShaderGroupStackSizeKHR(packet->call_info, packet->return_value, packet->device, packet->pipeline, packet->group, packet->groupShader); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdSetRayTracingPipelineStackSizeKHR(Packet_vkCmdSetRayTracingPipelineStackSizeKHR* packet) +{ + vulkan_replay_consumer_->Process_vkCmdSetRayTracingPipelineStackSizeKHR(packet->call_info, packet->commandBuffer, packet->pipelineStackSize); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawMeshTasksEXT(Packet_vkCmdDrawMeshTasksEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawMeshTasksEXT(packet->call_info, packet->commandBuffer, packet->groupCountX, packet->groupCountY, packet->groupCountZ); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawMeshTasksIndirectEXT(Packet_vkCmdDrawMeshTasksIndirectEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawMeshTasksIndirectEXT(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->drawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::Replay_vkCmdDrawMeshTasksIndirectCountEXT(Packet_vkCmdDrawMeshTasksIndirectCountEXT* packet) +{ + vulkan_replay_consumer_->Process_vkCmdDrawMeshTasksIndirectCountEXT(packet->call_info, packet->commandBuffer, packet->buffer, packet->offset, packet->countBuffer, packet->countBufferOffset, packet->maxDrawCount, packet->stride); + + return; +} + +void VulkanPreloadReplayer::ReplayFunctionCall(format::PacketCallId& packet_call_id, void* packet) +{ + switch(packet_call_id) + { + default: + VulkanPreloadReplayerBase::ReplayFunctionCall(packet_call_id, packet); + break; + + case format::PacketCallId::PacketCall_vkCreateInstance: + Replay_vkCreateInstance(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyInstance: + Replay_vkDestroyInstance(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkEnumeratePhysicalDevices: + Replay_vkEnumeratePhysicalDevices(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceFeatures: + Replay_vkGetPhysicalDeviceFeatures(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceFormatProperties: + Replay_vkGetPhysicalDeviceFormatProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceImageFormatProperties: + Replay_vkGetPhysicalDeviceImageFormatProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceProperties: + Replay_vkGetPhysicalDeviceProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceQueueFamilyProperties: + Replay_vkGetPhysicalDeviceQueueFamilyProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceMemoryProperties: + Replay_vkGetPhysicalDeviceMemoryProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDevice: + Replay_vkCreateDevice(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyDevice: + Replay_vkDestroyDevice(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceQueue: + Replay_vkGetDeviceQueue(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueSubmit: + Replay_vkQueueSubmit(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueWaitIdle: + Replay_vkQueueWaitIdle(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDeviceWaitIdle: + Replay_vkDeviceWaitIdle(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAllocateMemory: + Replay_vkAllocateMemory(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkFreeMemory: + Replay_vkFreeMemory(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkMapMemory: + Replay_vkMapMemory(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkUnmapMemory: + Replay_vkUnmapMemory(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkFlushMappedMemoryRanges: + Replay_vkFlushMappedMemoryRanges(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkInvalidateMappedMemoryRanges: + Replay_vkInvalidateMappedMemoryRanges(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceMemoryCommitment: + Replay_vkGetDeviceMemoryCommitment(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBindBufferMemory: + Replay_vkBindBufferMemory(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBindImageMemory: + Replay_vkBindImageMemory(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetBufferMemoryRequirements: + Replay_vkGetBufferMemoryRequirements(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageMemoryRequirements: + Replay_vkGetImageMemoryRequirements(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageSparseMemoryRequirements: + Replay_vkGetImageSparseMemoryRequirements(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSparseImageFormatProperties: + Replay_vkGetPhysicalDeviceSparseImageFormatProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueBindSparse: + Replay_vkQueueBindSparse(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateFence: + Replay_vkCreateFence(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyFence: + Replay_vkDestroyFence(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkResetFences: + Replay_vkResetFences(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetFenceStatus: + Replay_vkGetFenceStatus(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkWaitForFences: + Replay_vkWaitForFences(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateSemaphore: + Replay_vkCreateSemaphore(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroySemaphore: + Replay_vkDestroySemaphore(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateEvent: + Replay_vkCreateEvent(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyEvent: + Replay_vkDestroyEvent(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetEventStatus: + Replay_vkGetEventStatus(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetEvent: + Replay_vkSetEvent(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkResetEvent: + Replay_vkResetEvent(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateQueryPool: + Replay_vkCreateQueryPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyQueryPool: + Replay_vkDestroyQueryPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetQueryPoolResults: + Replay_vkGetQueryPoolResults(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateBuffer: + Replay_vkCreateBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyBuffer: + Replay_vkDestroyBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateBufferView: + Replay_vkCreateBufferView(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyBufferView: + Replay_vkDestroyBufferView(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateImage: + Replay_vkCreateImage(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyImage: + Replay_vkDestroyImage(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageSubresourceLayout: + Replay_vkGetImageSubresourceLayout(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateImageView: + Replay_vkCreateImageView(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyImageView: + Replay_vkDestroyImageView(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateShaderModule: + Replay_vkCreateShaderModule(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyShaderModule: + Replay_vkDestroyShaderModule(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreatePipelineCache: + Replay_vkCreatePipelineCache(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyPipelineCache: + Replay_vkDestroyPipelineCache(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPipelineCacheData: + Replay_vkGetPipelineCacheData(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkMergePipelineCaches: + Replay_vkMergePipelineCaches(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateGraphicsPipelines: + Replay_vkCreateGraphicsPipelines(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateComputePipelines: + Replay_vkCreateComputePipelines(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyPipeline: + Replay_vkDestroyPipeline(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreatePipelineLayout: + Replay_vkCreatePipelineLayout(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyPipelineLayout: + Replay_vkDestroyPipelineLayout(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateSampler: + Replay_vkCreateSampler(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroySampler: + Replay_vkDestroySampler(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDescriptorSetLayout: + Replay_vkCreateDescriptorSetLayout(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyDescriptorSetLayout: + Replay_vkDestroyDescriptorSetLayout(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDescriptorPool: + Replay_vkCreateDescriptorPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyDescriptorPool: + Replay_vkDestroyDescriptorPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkResetDescriptorPool: + Replay_vkResetDescriptorPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAllocateDescriptorSets: + Replay_vkAllocateDescriptorSets(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkFreeDescriptorSets: + Replay_vkFreeDescriptorSets(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkUpdateDescriptorSets: + Replay_vkUpdateDescriptorSets(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateFramebuffer: + Replay_vkCreateFramebuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyFramebuffer: + Replay_vkDestroyFramebuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateRenderPass: + Replay_vkCreateRenderPass(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyRenderPass: + Replay_vkDestroyRenderPass(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetRenderAreaGranularity: + Replay_vkGetRenderAreaGranularity(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateCommandPool: + Replay_vkCreateCommandPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyCommandPool: + Replay_vkDestroyCommandPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkResetCommandPool: + Replay_vkResetCommandPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAllocateCommandBuffers: + Replay_vkAllocateCommandBuffers(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkFreeCommandBuffers: + Replay_vkFreeCommandBuffers(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBeginCommandBuffer: + Replay_vkBeginCommandBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkEndCommandBuffer: + Replay_vkEndCommandBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkResetCommandBuffer: + Replay_vkResetCommandBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindPipeline: + Replay_vkCmdBindPipeline(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetViewport: + Replay_vkCmdSetViewport(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetScissor: + Replay_vkCmdSetScissor(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetLineWidth: + Replay_vkCmdSetLineWidth(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthBias: + Replay_vkCmdSetDepthBias(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetBlendConstants: + Replay_vkCmdSetBlendConstants(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthBounds: + Replay_vkCmdSetDepthBounds(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetStencilCompareMask: + Replay_vkCmdSetStencilCompareMask(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetStencilWriteMask: + Replay_vkCmdSetStencilWriteMask(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetStencilReference: + Replay_vkCmdSetStencilReference(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindDescriptorSets: + Replay_vkCmdBindDescriptorSets(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindIndexBuffer: + Replay_vkCmdBindIndexBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindVertexBuffers: + Replay_vkCmdBindVertexBuffers(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDraw: + Replay_vkCmdDraw(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndexed: + Replay_vkCmdDrawIndexed(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndirect: + Replay_vkCmdDrawIndirect(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndexedIndirect: + Replay_vkCmdDrawIndexedIndirect(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDispatch: + Replay_vkCmdDispatch(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDispatchIndirect: + Replay_vkCmdDispatchIndirect(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyBuffer: + Replay_vkCmdCopyBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyImage: + Replay_vkCmdCopyImage(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBlitImage: + Replay_vkCmdBlitImage(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyBufferToImage: + Replay_vkCmdCopyBufferToImage(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyImageToBuffer: + Replay_vkCmdCopyImageToBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdUpdateBuffer: + Replay_vkCmdUpdateBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdFillBuffer: + Replay_vkCmdFillBuffer(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdClearColorImage: + Replay_vkCmdClearColorImage(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdClearDepthStencilImage: + Replay_vkCmdClearDepthStencilImage(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdClearAttachments: + Replay_vkCmdClearAttachments(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdResolveImage: + Replay_vkCmdResolveImage(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetEvent: + Replay_vkCmdSetEvent(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdResetEvent: + Replay_vkCmdResetEvent(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWaitEvents: + Replay_vkCmdWaitEvents(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdPipelineBarrier: + Replay_vkCmdPipelineBarrier(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginQuery: + Replay_vkCmdBeginQuery(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndQuery: + Replay_vkCmdEndQuery(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdResetQueryPool: + Replay_vkCmdResetQueryPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWriteTimestamp: + Replay_vkCmdWriteTimestamp(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyQueryPoolResults: + Replay_vkCmdCopyQueryPoolResults(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdPushConstants: + Replay_vkCmdPushConstants(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginRenderPass: + Replay_vkCmdBeginRenderPass(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdNextSubpass: + Replay_vkCmdNextSubpass(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndRenderPass: + Replay_vkCmdEndRenderPass(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdExecuteCommands: + Replay_vkCmdExecuteCommands(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBindBufferMemory2: + Replay_vkBindBufferMemory2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBindImageMemory2: + Replay_vkBindImageMemory2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceGroupPeerMemoryFeatures: + Replay_vkGetDeviceGroupPeerMemoryFeatures(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDeviceMask: + Replay_vkCmdSetDeviceMask(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDispatchBase: + Replay_vkCmdDispatchBase(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkEnumeratePhysicalDeviceGroups: + Replay_vkEnumeratePhysicalDeviceGroups(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageMemoryRequirements2: + Replay_vkGetImageMemoryRequirements2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetBufferMemoryRequirements2: + Replay_vkGetBufferMemoryRequirements2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageSparseMemoryRequirements2: + Replay_vkGetImageSparseMemoryRequirements2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceFeatures2: + Replay_vkGetPhysicalDeviceFeatures2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceProperties2: + Replay_vkGetPhysicalDeviceProperties2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceFormatProperties2: + Replay_vkGetPhysicalDeviceFormatProperties2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceImageFormatProperties2: + Replay_vkGetPhysicalDeviceImageFormatProperties2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceQueueFamilyProperties2: + Replay_vkGetPhysicalDeviceQueueFamilyProperties2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceMemoryProperties2: + Replay_vkGetPhysicalDeviceMemoryProperties2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSparseImageFormatProperties2: + Replay_vkGetPhysicalDeviceSparseImageFormatProperties2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkTrimCommandPool: + Replay_vkTrimCommandPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceQueue2: + Replay_vkGetDeviceQueue2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateSamplerYcbcrConversion: + Replay_vkCreateSamplerYcbcrConversion(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroySamplerYcbcrConversion: + Replay_vkDestroySamplerYcbcrConversion(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDescriptorUpdateTemplate: + Replay_vkCreateDescriptorUpdateTemplate(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyDescriptorUpdateTemplate: + Replay_vkDestroyDescriptorUpdateTemplate(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceExternalBufferProperties: + Replay_vkGetPhysicalDeviceExternalBufferProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceExternalFenceProperties: + Replay_vkGetPhysicalDeviceExternalFenceProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceExternalSemaphoreProperties: + Replay_vkGetPhysicalDeviceExternalSemaphoreProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDescriptorSetLayoutSupport: + Replay_vkGetDescriptorSetLayoutSupport(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndirectCount: + Replay_vkCmdDrawIndirectCount(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndexedIndirectCount: + Replay_vkCmdDrawIndexedIndirectCount(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateRenderPass2: + Replay_vkCreateRenderPass2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginRenderPass2: + Replay_vkCmdBeginRenderPass2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdNextSubpass2: + Replay_vkCmdNextSubpass2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndRenderPass2: + Replay_vkCmdEndRenderPass2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkResetQueryPool: + Replay_vkResetQueryPool(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetSemaphoreCounterValue: + Replay_vkGetSemaphoreCounterValue(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkWaitSemaphores: + Replay_vkWaitSemaphores(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSignalSemaphore: + Replay_vkSignalSemaphore(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetBufferDeviceAddress: + Replay_vkGetBufferDeviceAddress(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetBufferOpaqueCaptureAddress: + Replay_vkGetBufferOpaqueCaptureAddress(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceMemoryOpaqueCaptureAddress: + Replay_vkGetDeviceMemoryOpaqueCaptureAddress(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceToolProperties: + Replay_vkGetPhysicalDeviceToolProperties(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreatePrivateDataSlot: + Replay_vkCreatePrivateDataSlot(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyPrivateDataSlot: + Replay_vkDestroyPrivateDataSlot(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetPrivateData: + Replay_vkSetPrivateData(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPrivateData: + Replay_vkGetPrivateData(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetEvent2: + Replay_vkCmdSetEvent2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdResetEvent2: + Replay_vkCmdResetEvent2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWaitEvents2: + Replay_vkCmdWaitEvents2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdPipelineBarrier2: + Replay_vkCmdPipelineBarrier2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWriteTimestamp2: + Replay_vkCmdWriteTimestamp2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueSubmit2: + Replay_vkQueueSubmit2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyBuffer2: + Replay_vkCmdCopyBuffer2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyImage2: + Replay_vkCmdCopyImage2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyBufferToImage2: + Replay_vkCmdCopyBufferToImage2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyImageToBuffer2: + Replay_vkCmdCopyImageToBuffer2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBlitImage2: + Replay_vkCmdBlitImage2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdResolveImage2: + Replay_vkCmdResolveImage2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginRendering: + Replay_vkCmdBeginRendering(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndRendering: + Replay_vkCmdEndRendering(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCullMode: + Replay_vkCmdSetCullMode(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetFrontFace: + Replay_vkCmdSetFrontFace(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetPrimitiveTopology: + Replay_vkCmdSetPrimitiveTopology(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetViewportWithCount: + Replay_vkCmdSetViewportWithCount(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetScissorWithCount: + Replay_vkCmdSetScissorWithCount(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindVertexBuffers2: + Replay_vkCmdBindVertexBuffers2(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthTestEnable: + Replay_vkCmdSetDepthTestEnable(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthWriteEnable: + Replay_vkCmdSetDepthWriteEnable(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthCompareOp: + Replay_vkCmdSetDepthCompareOp(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthBoundsTestEnable: + Replay_vkCmdSetDepthBoundsTestEnable(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetStencilTestEnable: + Replay_vkCmdSetStencilTestEnable(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetStencilOp: + Replay_vkCmdSetStencilOp(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetRasterizerDiscardEnable: + Replay_vkCmdSetRasterizerDiscardEnable(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthBiasEnable: + Replay_vkCmdSetDepthBiasEnable(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetPrimitiveRestartEnable: + Replay_vkCmdSetPrimitiveRestartEnable(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceBufferMemoryRequirements: + Replay_vkGetDeviceBufferMemoryRequirements(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceImageMemoryRequirements: + Replay_vkGetDeviceImageMemoryRequirements(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceImageSparseMemoryRequirements: + Replay_vkGetDeviceImageSparseMemoryRequirements(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroySurfaceKHR: + Replay_vkDestroySurfaceKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSurfaceSupportKHR: + Replay_vkGetPhysicalDeviceSurfaceSupportKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSurfaceCapabilitiesKHR: + Replay_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSurfaceFormatsKHR: + Replay_vkGetPhysicalDeviceSurfaceFormatsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSurfacePresentModesKHR: + Replay_vkGetPhysicalDeviceSurfacePresentModesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateSwapchainKHR: + Replay_vkCreateSwapchainKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroySwapchainKHR: + Replay_vkDestroySwapchainKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetSwapchainImagesKHR: + Replay_vkGetSwapchainImagesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAcquireNextImageKHR: + Replay_vkAcquireNextImageKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueuePresentKHR: + Replay_vkQueuePresentKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceGroupPresentCapabilitiesKHR: + Replay_vkGetDeviceGroupPresentCapabilitiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceGroupSurfacePresentModesKHR: + Replay_vkGetDeviceGroupSurfacePresentModesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDevicePresentRectanglesKHR: + Replay_vkGetPhysicalDevicePresentRectanglesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAcquireNextImage2KHR: + Replay_vkAcquireNextImage2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceDisplayPropertiesKHR: + Replay_vkGetPhysicalDeviceDisplayPropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceDisplayPlanePropertiesKHR: + Replay_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDisplayPlaneSupportedDisplaysKHR: + Replay_vkGetDisplayPlaneSupportedDisplaysKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDisplayModePropertiesKHR: + Replay_vkGetDisplayModePropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDisplayModeKHR: + Replay_vkCreateDisplayModeKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDisplayPlaneCapabilitiesKHR: + Replay_vkGetDisplayPlaneCapabilitiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDisplayPlaneSurfaceKHR: + Replay_vkCreateDisplayPlaneSurfaceKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateSharedSwapchainsKHR: + Replay_vkCreateSharedSwapchainsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateXlibSurfaceKHR: + Replay_vkCreateXlibSurfaceKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceXlibPresentationSupportKHR: + Replay_vkGetPhysicalDeviceXlibPresentationSupportKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateXcbSurfaceKHR: + Replay_vkCreateXcbSurfaceKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceXcbPresentationSupportKHR: + Replay_vkGetPhysicalDeviceXcbPresentationSupportKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateWaylandSurfaceKHR: + Replay_vkCreateWaylandSurfaceKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceWaylandPresentationSupportKHR: + Replay_vkGetPhysicalDeviceWaylandPresentationSupportKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateAndroidSurfaceKHR: + Replay_vkCreateAndroidSurfaceKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateWin32SurfaceKHR: + Replay_vkCreateWin32SurfaceKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceWin32PresentationSupportKHR: + Replay_vkGetPhysicalDeviceWin32PresentationSupportKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceVideoCapabilitiesKHR: + Replay_vkGetPhysicalDeviceVideoCapabilitiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceVideoFormatPropertiesKHR: + Replay_vkGetPhysicalDeviceVideoFormatPropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateVideoSessionKHR: + Replay_vkCreateVideoSessionKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyVideoSessionKHR: + Replay_vkDestroyVideoSessionKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetVideoSessionMemoryRequirementsKHR: + Replay_vkGetVideoSessionMemoryRequirementsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBindVideoSessionMemoryKHR: + Replay_vkBindVideoSessionMemoryKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateVideoSessionParametersKHR: + Replay_vkCreateVideoSessionParametersKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkUpdateVideoSessionParametersKHR: + Replay_vkUpdateVideoSessionParametersKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyVideoSessionParametersKHR: + Replay_vkDestroyVideoSessionParametersKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginVideoCodingKHR: + Replay_vkCmdBeginVideoCodingKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndVideoCodingKHR: + Replay_vkCmdEndVideoCodingKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdControlVideoCodingKHR: + Replay_vkCmdControlVideoCodingKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDecodeVideoKHR: + Replay_vkCmdDecodeVideoKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginRenderingKHR: + Replay_vkCmdBeginRenderingKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndRenderingKHR: + Replay_vkCmdEndRenderingKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceFeatures2KHR: + Replay_vkGetPhysicalDeviceFeatures2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceProperties2KHR: + Replay_vkGetPhysicalDeviceProperties2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceFormatProperties2KHR: + Replay_vkGetPhysicalDeviceFormatProperties2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceImageFormatProperties2KHR: + Replay_vkGetPhysicalDeviceImageFormatProperties2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceQueueFamilyProperties2KHR: + Replay_vkGetPhysicalDeviceQueueFamilyProperties2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceMemoryProperties2KHR: + Replay_vkGetPhysicalDeviceMemoryProperties2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSparseImageFormatProperties2KHR: + Replay_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceGroupPeerMemoryFeaturesKHR: + Replay_vkGetDeviceGroupPeerMemoryFeaturesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDeviceMaskKHR: + Replay_vkCmdSetDeviceMaskKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDispatchBaseKHR: + Replay_vkCmdDispatchBaseKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkTrimCommandPoolKHR: + Replay_vkTrimCommandPoolKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkEnumeratePhysicalDeviceGroupsKHR: + Replay_vkEnumeratePhysicalDeviceGroupsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceExternalBufferPropertiesKHR: + Replay_vkGetPhysicalDeviceExternalBufferPropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryWin32HandleKHR: + Replay_vkGetMemoryWin32HandleKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryWin32HandlePropertiesKHR: + Replay_vkGetMemoryWin32HandlePropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryFdKHR: + Replay_vkGetMemoryFdKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryFdPropertiesKHR: + Replay_vkGetMemoryFdPropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR: + Replay_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkImportSemaphoreWin32HandleKHR: + Replay_vkImportSemaphoreWin32HandleKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetSemaphoreWin32HandleKHR: + Replay_vkGetSemaphoreWin32HandleKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkImportSemaphoreFdKHR: + Replay_vkImportSemaphoreFdKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetSemaphoreFdKHR: + Replay_vkGetSemaphoreFdKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdPushDescriptorSetKHR: + Replay_vkCmdPushDescriptorSetKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDescriptorUpdateTemplateKHR: + Replay_vkCreateDescriptorUpdateTemplateKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyDescriptorUpdateTemplateKHR: + Replay_vkDestroyDescriptorUpdateTemplateKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateRenderPass2KHR: + Replay_vkCreateRenderPass2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginRenderPass2KHR: + Replay_vkCmdBeginRenderPass2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdNextSubpass2KHR: + Replay_vkCmdNextSubpass2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndRenderPass2KHR: + Replay_vkCmdEndRenderPass2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetSwapchainStatusKHR: + Replay_vkGetSwapchainStatusKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceExternalFencePropertiesKHR: + Replay_vkGetPhysicalDeviceExternalFencePropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkImportFenceWin32HandleKHR: + Replay_vkImportFenceWin32HandleKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetFenceWin32HandleKHR: + Replay_vkGetFenceWin32HandleKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkImportFenceFdKHR: + Replay_vkImportFenceFdKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetFenceFdKHR: + Replay_vkGetFenceFdKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR: + Replay_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: + Replay_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAcquireProfilingLockKHR: + Replay_vkAcquireProfilingLockKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkReleaseProfilingLockKHR: + Replay_vkReleaseProfilingLockKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSurfaceCapabilities2KHR: + Replay_vkGetPhysicalDeviceSurfaceCapabilities2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSurfaceFormats2KHR: + Replay_vkGetPhysicalDeviceSurfaceFormats2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceDisplayProperties2KHR: + Replay_vkGetPhysicalDeviceDisplayProperties2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceDisplayPlaneProperties2KHR: + Replay_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDisplayModeProperties2KHR: + Replay_vkGetDisplayModeProperties2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDisplayPlaneCapabilities2KHR: + Replay_vkGetDisplayPlaneCapabilities2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageMemoryRequirements2KHR: + Replay_vkGetImageMemoryRequirements2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetBufferMemoryRequirements2KHR: + Replay_vkGetBufferMemoryRequirements2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageSparseMemoryRequirements2KHR: + Replay_vkGetImageSparseMemoryRequirements2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateSamplerYcbcrConversionKHR: + Replay_vkCreateSamplerYcbcrConversionKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroySamplerYcbcrConversionKHR: + Replay_vkDestroySamplerYcbcrConversionKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBindBufferMemory2KHR: + Replay_vkBindBufferMemory2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBindImageMemory2KHR: + Replay_vkBindImageMemory2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDescriptorSetLayoutSupportKHR: + Replay_vkGetDescriptorSetLayoutSupportKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndirectCountKHR: + Replay_vkCmdDrawIndirectCountKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndexedIndirectCountKHR: + Replay_vkCmdDrawIndexedIndirectCountKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetSemaphoreCounterValueKHR: + Replay_vkGetSemaphoreCounterValueKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkWaitSemaphoresKHR: + Replay_vkWaitSemaphoresKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSignalSemaphoreKHR: + Replay_vkSignalSemaphoreKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceFragmentShadingRatesKHR: + Replay_vkGetPhysicalDeviceFragmentShadingRatesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetFragmentShadingRateKHR: + Replay_vkCmdSetFragmentShadingRateKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetRenderingAttachmentLocationsKHR: + Replay_vkCmdSetRenderingAttachmentLocationsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetRenderingInputAttachmentIndicesKHR: + Replay_vkCmdSetRenderingInputAttachmentIndicesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkWaitForPresentKHR: + Replay_vkWaitForPresentKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetBufferDeviceAddressKHR: + Replay_vkGetBufferDeviceAddressKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetBufferOpaqueCaptureAddressKHR: + Replay_vkGetBufferOpaqueCaptureAddressKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceMemoryOpaqueCaptureAddressKHR: + Replay_vkGetDeviceMemoryOpaqueCaptureAddressKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDeferredOperationKHR: + Replay_vkCreateDeferredOperationKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyDeferredOperationKHR: + Replay_vkDestroyDeferredOperationKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeferredOperationMaxConcurrencyKHR: + Replay_vkGetDeferredOperationMaxConcurrencyKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeferredOperationResultKHR: + Replay_vkGetDeferredOperationResultKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDeferredOperationJoinKHR: + Replay_vkDeferredOperationJoinKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPipelineExecutablePropertiesKHR: + Replay_vkGetPipelineExecutablePropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPipelineExecutableStatisticsKHR: + Replay_vkGetPipelineExecutableStatisticsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPipelineExecutableInternalRepresentationsKHR: + Replay_vkGetPipelineExecutableInternalRepresentationsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkMapMemory2KHR: + Replay_vkMapMemory2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkUnmapMemory2KHR: + Replay_vkUnmapMemory2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR: + Replay_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetEncodedVideoSessionParametersKHR: + Replay_vkGetEncodedVideoSessionParametersKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEncodeVideoKHR: + Replay_vkCmdEncodeVideoKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetEvent2KHR: + Replay_vkCmdSetEvent2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdResetEvent2KHR: + Replay_vkCmdResetEvent2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWaitEvents2KHR: + Replay_vkCmdWaitEvents2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdPipelineBarrier2KHR: + Replay_vkCmdPipelineBarrier2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWriteTimestamp2KHR: + Replay_vkCmdWriteTimestamp2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueSubmit2KHR: + Replay_vkQueueSubmit2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWriteBufferMarker2AMD: + Replay_vkCmdWriteBufferMarker2AMD(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetQueueCheckpointData2NV: + Replay_vkGetQueueCheckpointData2NV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyBuffer2KHR: + Replay_vkCmdCopyBuffer2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyImage2KHR: + Replay_vkCmdCopyImage2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyBufferToImage2KHR: + Replay_vkCmdCopyBufferToImage2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyImageToBuffer2KHR: + Replay_vkCmdCopyImageToBuffer2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBlitImage2KHR: + Replay_vkCmdBlitImage2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdResolveImage2KHR: + Replay_vkCmdResolveImage2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdTraceRaysIndirect2KHR: + Replay_vkCmdTraceRaysIndirect2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceBufferMemoryRequirementsKHR: + Replay_vkGetDeviceBufferMemoryRequirementsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceImageMemoryRequirementsKHR: + Replay_vkGetDeviceImageMemoryRequirementsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceImageSparseMemoryRequirementsKHR: + Replay_vkGetDeviceImageSparseMemoryRequirementsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindIndexBuffer2KHR: + Replay_vkCmdBindIndexBuffer2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetRenderingAreaGranularityKHR: + Replay_vkGetRenderingAreaGranularityKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceImageSubresourceLayoutKHR: + Replay_vkGetDeviceImageSubresourceLayoutKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageSubresourceLayout2KHR: + Replay_vkGetImageSubresourceLayout2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR: + Replay_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetLineStippleKHR: + Replay_vkCmdSetLineStippleKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR: + Replay_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetCalibratedTimestampsKHR: + Replay_vkGetCalibratedTimestampsKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindDescriptorSets2KHR: + Replay_vkCmdBindDescriptorSets2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdPushConstants2KHR: + Replay_vkCmdPushConstants2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdPushDescriptorSet2KHR: + Replay_vkCmdPushDescriptorSet2KHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDescriptorBufferOffsets2EXT: + Replay_vkCmdSetDescriptorBufferOffsets2EXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT: + Replay_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkFrameBoundaryANDROID: + Replay_vkFrameBoundaryANDROID(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDebugReportCallbackEXT: + Replay_vkCreateDebugReportCallbackEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyDebugReportCallbackEXT: + Replay_vkDestroyDebugReportCallbackEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDebugReportMessageEXT: + Replay_vkDebugReportMessageEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDebugMarkerSetObjectTagEXT: + Replay_vkDebugMarkerSetObjectTagEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDebugMarkerSetObjectNameEXT: + Replay_vkDebugMarkerSetObjectNameEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDebugMarkerBeginEXT: + Replay_vkCmdDebugMarkerBeginEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDebugMarkerEndEXT: + Replay_vkCmdDebugMarkerEndEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDebugMarkerInsertEXT: + Replay_vkCmdDebugMarkerInsertEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindTransformFeedbackBuffersEXT: + Replay_vkCmdBindTransformFeedbackBuffersEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginTransformFeedbackEXT: + Replay_vkCmdBeginTransformFeedbackEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndTransformFeedbackEXT: + Replay_vkCmdEndTransformFeedbackEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginQueryIndexedEXT: + Replay_vkCmdBeginQueryIndexedEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndQueryIndexedEXT: + Replay_vkCmdEndQueryIndexedEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndirectByteCountEXT: + Replay_vkCmdDrawIndirectByteCountEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageViewHandleNVX: + Replay_vkGetImageViewHandleNVX(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageViewAddressNVX: + Replay_vkGetImageViewAddressNVX(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndirectCountAMD: + Replay_vkCmdDrawIndirectCountAMD(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawIndexedIndirectCountAMD: + Replay_vkCmdDrawIndexedIndirectCountAMD(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetShaderInfoAMD: + Replay_vkGetShaderInfoAMD(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateStreamDescriptorSurfaceGGP: + Replay_vkCreateStreamDescriptorSurfaceGGP(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceExternalImageFormatPropertiesNV: + Replay_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryWin32HandleNV: + Replay_vkGetMemoryWin32HandleNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateViSurfaceNN: + Replay_vkCreateViSurfaceNN(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginConditionalRenderingEXT: + Replay_vkCmdBeginConditionalRenderingEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndConditionalRenderingEXT: + Replay_vkCmdEndConditionalRenderingEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetViewportWScalingNV: + Replay_vkCmdSetViewportWScalingNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkReleaseDisplayEXT: + Replay_vkReleaseDisplayEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAcquireXlibDisplayEXT: + Replay_vkAcquireXlibDisplayEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetRandROutputDisplayEXT: + Replay_vkGetRandROutputDisplayEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSurfaceCapabilities2EXT: + Replay_vkGetPhysicalDeviceSurfaceCapabilities2EXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDisplayPowerControlEXT: + Replay_vkDisplayPowerControlEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkRegisterDeviceEventEXT: + Replay_vkRegisterDeviceEventEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkRegisterDisplayEventEXT: + Replay_vkRegisterDisplayEventEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetSwapchainCounterEXT: + Replay_vkGetSwapchainCounterEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetRefreshCycleDurationGOOGLE: + Replay_vkGetRefreshCycleDurationGOOGLE(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPastPresentationTimingGOOGLE: + Replay_vkGetPastPresentationTimingGOOGLE(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDiscardRectangleEXT: + Replay_vkCmdSetDiscardRectangleEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDiscardRectangleEnableEXT: + Replay_vkCmdSetDiscardRectangleEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDiscardRectangleModeEXT: + Replay_vkCmdSetDiscardRectangleModeEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetHdrMetadataEXT: + Replay_vkSetHdrMetadataEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateIOSSurfaceMVK: + Replay_vkCreateIOSSurfaceMVK(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateMacOSSurfaceMVK: + Replay_vkCreateMacOSSurfaceMVK(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetDebugUtilsObjectNameEXT: + Replay_vkSetDebugUtilsObjectNameEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetDebugUtilsObjectTagEXT: + Replay_vkSetDebugUtilsObjectTagEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueBeginDebugUtilsLabelEXT: + Replay_vkQueueBeginDebugUtilsLabelEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueEndDebugUtilsLabelEXT: + Replay_vkQueueEndDebugUtilsLabelEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueInsertDebugUtilsLabelEXT: + Replay_vkQueueInsertDebugUtilsLabelEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBeginDebugUtilsLabelEXT: + Replay_vkCmdBeginDebugUtilsLabelEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdEndDebugUtilsLabelEXT: + Replay_vkCmdEndDebugUtilsLabelEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdInsertDebugUtilsLabelEXT: + Replay_vkCmdInsertDebugUtilsLabelEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDebugUtilsMessengerEXT: + Replay_vkCreateDebugUtilsMessengerEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyDebugUtilsMessengerEXT: + Replay_vkDestroyDebugUtilsMessengerEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSubmitDebugUtilsMessageEXT: + Replay_vkSubmitDebugUtilsMessageEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetAndroidHardwareBufferPropertiesANDROID: + Replay_vkGetAndroidHardwareBufferPropertiesANDROID(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryAndroidHardwareBufferANDROID: + Replay_vkGetMemoryAndroidHardwareBufferANDROID(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetSampleLocationsEXT: + Replay_vkCmdSetSampleLocationsEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceMultisamplePropertiesEXT: + Replay_vkGetPhysicalDeviceMultisamplePropertiesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageDrmFormatModifierPropertiesEXT: + Replay_vkGetImageDrmFormatModifierPropertiesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateValidationCacheEXT: + Replay_vkCreateValidationCacheEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyValidationCacheEXT: + Replay_vkDestroyValidationCacheEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkMergeValidationCachesEXT: + Replay_vkMergeValidationCachesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetValidationCacheDataEXT: + Replay_vkGetValidationCacheDataEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindShadingRateImageNV: + Replay_vkCmdBindShadingRateImageNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetViewportShadingRatePaletteNV: + Replay_vkCmdSetViewportShadingRatePaletteNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCoarseSampleOrderNV: + Replay_vkCmdSetCoarseSampleOrderNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateAccelerationStructureNV: + Replay_vkCreateAccelerationStructureNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyAccelerationStructureNV: + Replay_vkDestroyAccelerationStructureNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetAccelerationStructureMemoryRequirementsNV: + Replay_vkGetAccelerationStructureMemoryRequirementsNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBindAccelerationStructureMemoryNV: + Replay_vkBindAccelerationStructureMemoryNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBuildAccelerationStructureNV: + Replay_vkCmdBuildAccelerationStructureNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyAccelerationStructureNV: + Replay_vkCmdCopyAccelerationStructureNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdTraceRaysNV: + Replay_vkCmdTraceRaysNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateRayTracingPipelinesNV: + Replay_vkCreateRayTracingPipelinesNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetRayTracingShaderGroupHandlesKHR: + Replay_vkGetRayTracingShaderGroupHandlesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetRayTracingShaderGroupHandlesNV: + Replay_vkGetRayTracingShaderGroupHandlesNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetAccelerationStructureHandleNV: + Replay_vkGetAccelerationStructureHandleNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWriteAccelerationStructuresPropertiesNV: + Replay_vkCmdWriteAccelerationStructuresPropertiesNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCompileDeferredNV: + Replay_vkCompileDeferredNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryHostPointerPropertiesEXT: + Replay_vkGetMemoryHostPointerPropertiesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWriteBufferMarkerAMD: + Replay_vkCmdWriteBufferMarkerAMD(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT: + Replay_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetCalibratedTimestampsEXT: + Replay_vkGetCalibratedTimestampsEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawMeshTasksNV: + Replay_vkCmdDrawMeshTasksNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawMeshTasksIndirectNV: + Replay_vkCmdDrawMeshTasksIndirectNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawMeshTasksIndirectCountNV: + Replay_vkCmdDrawMeshTasksIndirectCountNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetExclusiveScissorEnableNV: + Replay_vkCmdSetExclusiveScissorEnableNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetExclusiveScissorNV: + Replay_vkCmdSetExclusiveScissorNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCheckpointNV: + Replay_vkCmdSetCheckpointNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetQueueCheckpointDataNV: + Replay_vkGetQueueCheckpointDataNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkInitializePerformanceApiINTEL: + Replay_vkInitializePerformanceApiINTEL(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkUninitializePerformanceApiINTEL: + Replay_vkUninitializePerformanceApiINTEL(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetPerformanceMarkerINTEL: + Replay_vkCmdSetPerformanceMarkerINTEL(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetPerformanceStreamMarkerINTEL: + Replay_vkCmdSetPerformanceStreamMarkerINTEL(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetPerformanceOverrideINTEL: + Replay_vkCmdSetPerformanceOverrideINTEL(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAcquirePerformanceConfigurationINTEL: + Replay_vkAcquirePerformanceConfigurationINTEL(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkReleasePerformanceConfigurationINTEL: + Replay_vkReleasePerformanceConfigurationINTEL(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueSetPerformanceConfigurationINTEL: + Replay_vkQueueSetPerformanceConfigurationINTEL(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPerformanceParameterINTEL: + Replay_vkGetPerformanceParameterINTEL(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetLocalDimmingAMD: + Replay_vkSetLocalDimmingAMD(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateImagePipeSurfaceFUCHSIA: + Replay_vkCreateImagePipeSurfaceFUCHSIA(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateMetalSurfaceEXT: + Replay_vkCreateMetalSurfaceEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetBufferDeviceAddressEXT: + Replay_vkGetBufferDeviceAddressEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceToolPropertiesEXT: + Replay_vkGetPhysicalDeviceToolPropertiesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV: + Replay_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV: + Replay_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceSurfacePresentModes2EXT: + Replay_vkGetPhysicalDeviceSurfacePresentModes2EXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAcquireFullScreenExclusiveModeEXT: + Replay_vkAcquireFullScreenExclusiveModeEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkReleaseFullScreenExclusiveModeEXT: + Replay_vkReleaseFullScreenExclusiveModeEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceGroupSurfacePresentModes2EXT: + Replay_vkGetDeviceGroupSurfacePresentModes2EXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateHeadlessSurfaceEXT: + Replay_vkCreateHeadlessSurfaceEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetLineStippleEXT: + Replay_vkCmdSetLineStippleEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkResetQueryPoolEXT: + Replay_vkResetQueryPoolEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCullModeEXT: + Replay_vkCmdSetCullModeEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetFrontFaceEXT: + Replay_vkCmdSetFrontFaceEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetPrimitiveTopologyEXT: + Replay_vkCmdSetPrimitiveTopologyEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetViewportWithCountEXT: + Replay_vkCmdSetViewportWithCountEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetScissorWithCountEXT: + Replay_vkCmdSetScissorWithCountEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindVertexBuffers2EXT: + Replay_vkCmdBindVertexBuffers2EXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthTestEnableEXT: + Replay_vkCmdSetDepthTestEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthWriteEnableEXT: + Replay_vkCmdSetDepthWriteEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthCompareOpEXT: + Replay_vkCmdSetDepthCompareOpEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthBoundsTestEnableEXT: + Replay_vkCmdSetDepthBoundsTestEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetStencilTestEnableEXT: + Replay_vkCmdSetStencilTestEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetStencilOpEXT: + Replay_vkCmdSetStencilOpEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCopyMemoryToImageEXT: + Replay_vkCopyMemoryToImageEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCopyImageToMemoryEXT: + Replay_vkCopyImageToMemoryEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCopyImageToImageEXT: + Replay_vkCopyImageToImageEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkTransitionImageLayoutEXT: + Replay_vkTransitionImageLayoutEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetImageSubresourceLayout2EXT: + Replay_vkGetImageSubresourceLayout2EXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkReleaseSwapchainImagesEXT: + Replay_vkReleaseSwapchainImagesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetGeneratedCommandsMemoryRequirementsNV: + Replay_vkGetGeneratedCommandsMemoryRequirementsNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdPreprocessGeneratedCommandsNV: + Replay_vkCmdPreprocessGeneratedCommandsNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdExecuteGeneratedCommandsNV: + Replay_vkCmdExecuteGeneratedCommandsNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindPipelineShaderGroupNV: + Replay_vkCmdBindPipelineShaderGroupNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateIndirectCommandsLayoutNV: + Replay_vkCreateIndirectCommandsLayoutNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyIndirectCommandsLayoutNV: + Replay_vkDestroyIndirectCommandsLayoutNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthBias2EXT: + Replay_vkCmdSetDepthBias2EXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAcquireDrmDisplayEXT: + Replay_vkAcquireDrmDisplayEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDrmDisplayEXT: + Replay_vkGetDrmDisplayEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreatePrivateDataSlotEXT: + Replay_vkCreatePrivateDataSlotEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyPrivateDataSlotEXT: + Replay_vkDestroyPrivateDataSlotEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetPrivateDataEXT: + Replay_vkSetPrivateDataEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPrivateDataEXT: + Replay_vkGetPrivateDataEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetFragmentShadingRateEnumNV: + Replay_vkCmdSetFragmentShadingRateEnumNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceFaultInfoEXT: + Replay_vkGetDeviceFaultInfoEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkAcquireWinrtDisplayNV: + Replay_vkAcquireWinrtDisplayNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetWinrtDisplayNV: + Replay_vkGetWinrtDisplayNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateDirectFBSurfaceEXT: + Replay_vkCreateDirectFBSurfaceEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceDirectFBPresentationSupportEXT: + Replay_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetVertexInputEXT: + Replay_vkCmdSetVertexInputEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryZirconHandleFUCHSIA: + Replay_vkGetMemoryZirconHandleFUCHSIA(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryZirconHandlePropertiesFUCHSIA: + Replay_vkGetMemoryZirconHandlePropertiesFUCHSIA(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkImportSemaphoreZirconHandleFUCHSIA: + Replay_vkImportSemaphoreZirconHandleFUCHSIA(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetSemaphoreZirconHandleFUCHSIA: + Replay_vkGetSemaphoreZirconHandleFUCHSIA(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindInvocationMaskHUAWEI: + Replay_vkCmdBindInvocationMaskHUAWEI(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMemoryRemoteAddressNV: + Replay_vkGetMemoryRemoteAddressNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetPatchControlPointsEXT: + Replay_vkCmdSetPatchControlPointsEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetRasterizerDiscardEnableEXT: + Replay_vkCmdSetRasterizerDiscardEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthBiasEnableEXT: + Replay_vkCmdSetDepthBiasEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetLogicOpEXT: + Replay_vkCmdSetLogicOpEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetPrimitiveRestartEnableEXT: + Replay_vkCmdSetPrimitiveRestartEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateScreenSurfaceQNX: + Replay_vkCreateScreenSurfaceQNX(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceScreenPresentationSupportQNX: + Replay_vkGetPhysicalDeviceScreenPresentationSupportQNX(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetColorWriteEnableEXT: + Replay_vkCmdSetColorWriteEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawMultiEXT: + Replay_vkCmdDrawMultiEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawMultiIndexedEXT: + Replay_vkCmdDrawMultiIndexedEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateMicromapEXT: + Replay_vkCreateMicromapEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyMicromapEXT: + Replay_vkDestroyMicromapEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBuildMicromapsEXT: + Replay_vkCmdBuildMicromapsEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBuildMicromapsEXT: + Replay_vkBuildMicromapsEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCopyMicromapEXT: + Replay_vkCopyMicromapEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCopyMicromapToMemoryEXT: + Replay_vkCopyMicromapToMemoryEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCopyMemoryToMicromapEXT: + Replay_vkCopyMemoryToMicromapEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkWriteMicromapsPropertiesEXT: + Replay_vkWriteMicromapsPropertiesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyMicromapEXT: + Replay_vkCmdCopyMicromapEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyMicromapToMemoryEXT: + Replay_vkCmdCopyMicromapToMemoryEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyMemoryToMicromapEXT: + Replay_vkCmdCopyMemoryToMicromapEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWriteMicromapsPropertiesEXT: + Replay_vkCmdWriteMicromapsPropertiesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceMicromapCompatibilityEXT: + Replay_vkGetDeviceMicromapCompatibilityEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetMicromapBuildSizesEXT: + Replay_vkGetMicromapBuildSizesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawClusterHUAWEI: + Replay_vkCmdDrawClusterHUAWEI(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawClusterIndirectHUAWEI: + Replay_vkCmdDrawClusterIndirectHUAWEI(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetDeviceMemoryPriorityEXT: + Replay_vkSetDeviceMemoryPriorityEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDescriptorSetLayoutHostMappingInfoVALVE: + Replay_vkGetDescriptorSetLayoutHostMappingInfoVALVE(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDescriptorSetHostMappingVALVE: + Replay_vkGetDescriptorSetHostMappingVALVE(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPipelineIndirectMemoryRequirementsNV: + Replay_vkGetPipelineIndirectMemoryRequirementsNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdUpdatePipelineIndirectBufferNV: + Replay_vkCmdUpdatePipelineIndirectBufferNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPipelineIndirectDeviceAddressNV: + Replay_vkGetPipelineIndirectDeviceAddressNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthClampEnableEXT: + Replay_vkCmdSetDepthClampEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetPolygonModeEXT: + Replay_vkCmdSetPolygonModeEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetRasterizationSamplesEXT: + Replay_vkCmdSetRasterizationSamplesEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetSampleMaskEXT: + Replay_vkCmdSetSampleMaskEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetAlphaToCoverageEnableEXT: + Replay_vkCmdSetAlphaToCoverageEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetAlphaToOneEnableEXT: + Replay_vkCmdSetAlphaToOneEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetLogicOpEnableEXT: + Replay_vkCmdSetLogicOpEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetColorBlendEnableEXT: + Replay_vkCmdSetColorBlendEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetColorBlendEquationEXT: + Replay_vkCmdSetColorBlendEquationEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetColorWriteMaskEXT: + Replay_vkCmdSetColorWriteMaskEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetTessellationDomainOriginEXT: + Replay_vkCmdSetTessellationDomainOriginEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetRasterizationStreamEXT: + Replay_vkCmdSetRasterizationStreamEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetConservativeRasterizationModeEXT: + Replay_vkCmdSetConservativeRasterizationModeEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetExtraPrimitiveOverestimationSizeEXT: + Replay_vkCmdSetExtraPrimitiveOverestimationSizeEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthClipEnableEXT: + Replay_vkCmdSetDepthClipEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetSampleLocationsEnableEXT: + Replay_vkCmdSetSampleLocationsEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetColorBlendAdvancedEXT: + Replay_vkCmdSetColorBlendAdvancedEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetProvokingVertexModeEXT: + Replay_vkCmdSetProvokingVertexModeEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetLineRasterizationModeEXT: + Replay_vkCmdSetLineRasterizationModeEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetLineStippleEnableEXT: + Replay_vkCmdSetLineStippleEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetDepthClipNegativeOneToOneEXT: + Replay_vkCmdSetDepthClipNegativeOneToOneEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetViewportWScalingEnableNV: + Replay_vkCmdSetViewportWScalingEnableNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetViewportSwizzleNV: + Replay_vkCmdSetViewportSwizzleNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCoverageToColorEnableNV: + Replay_vkCmdSetCoverageToColorEnableNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCoverageToColorLocationNV: + Replay_vkCmdSetCoverageToColorLocationNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCoverageModulationModeNV: + Replay_vkCmdSetCoverageModulationModeNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCoverageModulationTableEnableNV: + Replay_vkCmdSetCoverageModulationTableEnableNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCoverageModulationTableNV: + Replay_vkCmdSetCoverageModulationTableNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetShadingRateImageEnableNV: + Replay_vkCmdSetShadingRateImageEnableNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetRepresentativeFragmentTestEnableNV: + Replay_vkCmdSetRepresentativeFragmentTestEnableNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetCoverageReductionModeNV: + Replay_vkCmdSetCoverageReductionModeNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetShaderModuleIdentifierEXT: + Replay_vkGetShaderModuleIdentifierEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetShaderModuleCreateInfoIdentifierEXT: + Replay_vkGetShaderModuleCreateInfoIdentifierEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetPhysicalDeviceOpticalFlowImageFormatsNV: + Replay_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateOpticalFlowSessionNV: + Replay_vkCreateOpticalFlowSessionNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyOpticalFlowSessionNV: + Replay_vkDestroyOpticalFlowSessionNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkBindOpticalFlowSessionImageNV: + Replay_vkBindOpticalFlowSessionImageNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdOpticalFlowExecuteNV: + Replay_vkCmdOpticalFlowExecuteNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateShadersEXT: + Replay_vkCreateShadersEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyShaderEXT: + Replay_vkDestroyShaderEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetShaderBinaryDataEXT: + Replay_vkGetShaderBinaryDataEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBindShadersEXT: + Replay_vkCmdBindShadersEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetFramebufferTilePropertiesQCOM: + Replay_vkGetFramebufferTilePropertiesQCOM(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDynamicRenderingTilePropertiesQCOM: + Replay_vkGetDynamicRenderingTilePropertiesQCOM(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetLatencySleepModeNV: + Replay_vkSetLatencySleepModeNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkLatencySleepNV: + Replay_vkLatencySleepNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkSetLatencyMarkerNV: + Replay_vkSetLatencyMarkerNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetLatencyTimingsNV: + Replay_vkGetLatencyTimingsNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkQueueNotifyOutOfBandNV: + Replay_vkQueueNotifyOutOfBandNV(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetAttachmentFeedbackLoopEnableEXT: + Replay_vkCmdSetAttachmentFeedbackLoopEnableEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCreateAccelerationStructureKHR: + Replay_vkCreateAccelerationStructureKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkDestroyAccelerationStructureKHR: + Replay_vkDestroyAccelerationStructureKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBuildAccelerationStructuresKHR: + Replay_vkCmdBuildAccelerationStructuresKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdBuildAccelerationStructuresIndirectKHR: + Replay_vkCmdBuildAccelerationStructuresIndirectKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCopyAccelerationStructureToMemoryKHR: + Replay_vkCopyAccelerationStructureToMemoryKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCopyMemoryToAccelerationStructureKHR: + Replay_vkCopyMemoryToAccelerationStructureKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkWriteAccelerationStructuresPropertiesKHR: + Replay_vkWriteAccelerationStructuresPropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyAccelerationStructureKHR: + Replay_vkCmdCopyAccelerationStructureKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyAccelerationStructureToMemoryKHR: + Replay_vkCmdCopyAccelerationStructureToMemoryKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdCopyMemoryToAccelerationStructureKHR: + Replay_vkCmdCopyMemoryToAccelerationStructureKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetAccelerationStructureDeviceAddressKHR: + Replay_vkGetAccelerationStructureDeviceAddressKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdWriteAccelerationStructuresPropertiesKHR: + Replay_vkCmdWriteAccelerationStructuresPropertiesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetDeviceAccelerationStructureCompatibilityKHR: + Replay_vkGetDeviceAccelerationStructureCompatibilityKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetAccelerationStructureBuildSizesKHR: + Replay_vkGetAccelerationStructureBuildSizesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdTraceRaysKHR: + Replay_vkCmdTraceRaysKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: + Replay_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdTraceRaysIndirectKHR: + Replay_vkCmdTraceRaysIndirectKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkGetRayTracingShaderGroupStackSizeKHR: + Replay_vkGetRayTracingShaderGroupStackSizeKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdSetRayTracingPipelineStackSizeKHR: + Replay_vkCmdSetRayTracingPipelineStackSizeKHR(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawMeshTasksEXT: + Replay_vkCmdDrawMeshTasksEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawMeshTasksIndirectEXT: + Replay_vkCmdDrawMeshTasksIndirectEXT(reinterpret_cast(packet)); + break; + case format::PacketCallId::PacketCall_vkCmdDrawMeshTasksIndirectCountEXT: + Replay_vkCmdDrawMeshTasksIndirectCountEXT(reinterpret_cast(packet)); + break; + } +} + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/generated/generated_vulkan_preload_replayer.h b/framework/generated/generated_vulkan_preload_replayer.h new file mode 100644 index 0000000000..2f79841ee3 --- /dev/null +++ b/framework/generated/generated_vulkan_preload_replayer.h @@ -0,0 +1,1311 @@ +/* +** Copyright (c) 2018-2023 Valve Corporation +** Copyright (c) 2018-2023 LunarG, Inc. +** Copyright (c) 2023 Advanced Micro Devices, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +/* +** This file is generated from the Khronos Vulkan XML API Registry. +** +*/ + +#ifndef GFXRECON_GENERATED_VULKAN_PRELOAD_REPLAYER_H +#define GFXRECON_GENERATED_VULKAN_PRELOAD_REPLAYER_H + +#include "decode/vulkan_decoder_base.h" +#include "decode/vulkan_preload_replayer_base.h" +#include "util/defines.h" + +#include "vulkan/vulkan.h" +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#include "vk_video/vulkan_video_codecs_common.h" + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +class VulkanPreloadReplayer : public VulkanPreloadReplayerBase +{ + public: + VulkanPreloadReplayer() { } + + virtual ~VulkanPreloadReplayer() { } + + virtual void ReplayFunctionCall(format::PacketCallId& packet_call_id, void* packet); + + private: + void Replay_vkCreateInstance(Packet_vkCreateInstance* packet); + + void Replay_vkDestroyInstance(Packet_vkDestroyInstance* packet); + + void Replay_vkEnumeratePhysicalDevices(Packet_vkEnumeratePhysicalDevices* packet); + + void Replay_vkGetPhysicalDeviceFeatures(Packet_vkGetPhysicalDeviceFeatures* packet); + + void Replay_vkGetPhysicalDeviceFormatProperties(Packet_vkGetPhysicalDeviceFormatProperties* packet); + + void Replay_vkGetPhysicalDeviceImageFormatProperties(Packet_vkGetPhysicalDeviceImageFormatProperties* packet); + + void Replay_vkGetPhysicalDeviceProperties(Packet_vkGetPhysicalDeviceProperties* packet); + + void Replay_vkGetPhysicalDeviceQueueFamilyProperties(Packet_vkGetPhysicalDeviceQueueFamilyProperties* packet); + + void Replay_vkGetPhysicalDeviceMemoryProperties(Packet_vkGetPhysicalDeviceMemoryProperties* packet); + + void Replay_vkCreateDevice(Packet_vkCreateDevice* packet); + + void Replay_vkDestroyDevice(Packet_vkDestroyDevice* packet); + + void Replay_vkGetDeviceQueue(Packet_vkGetDeviceQueue* packet); + + void Replay_vkQueueSubmit(Packet_vkQueueSubmit* packet); + + void Replay_vkQueueWaitIdle(Packet_vkQueueWaitIdle* packet); + + void Replay_vkDeviceWaitIdle(Packet_vkDeviceWaitIdle* packet); + + void Replay_vkAllocateMemory(Packet_vkAllocateMemory* packet); + + void Replay_vkFreeMemory(Packet_vkFreeMemory* packet); + + void Replay_vkMapMemory(Packet_vkMapMemory* packet); + + void Replay_vkUnmapMemory(Packet_vkUnmapMemory* packet); + + void Replay_vkFlushMappedMemoryRanges(Packet_vkFlushMappedMemoryRanges* packet); + + void Replay_vkInvalidateMappedMemoryRanges(Packet_vkInvalidateMappedMemoryRanges* packet); + + void Replay_vkGetDeviceMemoryCommitment(Packet_vkGetDeviceMemoryCommitment* packet); + + void Replay_vkBindBufferMemory(Packet_vkBindBufferMemory* packet); + + void Replay_vkBindImageMemory(Packet_vkBindImageMemory* packet); + + void Replay_vkGetBufferMemoryRequirements(Packet_vkGetBufferMemoryRequirements* packet); + + void Replay_vkGetImageMemoryRequirements(Packet_vkGetImageMemoryRequirements* packet); + + void Replay_vkGetImageSparseMemoryRequirements(Packet_vkGetImageSparseMemoryRequirements* packet); + + void Replay_vkGetPhysicalDeviceSparseImageFormatProperties(Packet_vkGetPhysicalDeviceSparseImageFormatProperties* packet); + + void Replay_vkQueueBindSparse(Packet_vkQueueBindSparse* packet); + + void Replay_vkCreateFence(Packet_vkCreateFence* packet); + + void Replay_vkDestroyFence(Packet_vkDestroyFence* packet); + + void Replay_vkResetFences(Packet_vkResetFences* packet); + + void Replay_vkGetFenceStatus(Packet_vkGetFenceStatus* packet); + + void Replay_vkWaitForFences(Packet_vkWaitForFences* packet); + + void Replay_vkCreateSemaphore(Packet_vkCreateSemaphore* packet); + + void Replay_vkDestroySemaphore(Packet_vkDestroySemaphore* packet); + + void Replay_vkCreateEvent(Packet_vkCreateEvent* packet); + + void Replay_vkDestroyEvent(Packet_vkDestroyEvent* packet); + + void Replay_vkGetEventStatus(Packet_vkGetEventStatus* packet); + + void Replay_vkSetEvent(Packet_vkSetEvent* packet); + + void Replay_vkResetEvent(Packet_vkResetEvent* packet); + + void Replay_vkCreateQueryPool(Packet_vkCreateQueryPool* packet); + + void Replay_vkDestroyQueryPool(Packet_vkDestroyQueryPool* packet); + + void Replay_vkGetQueryPoolResults(Packet_vkGetQueryPoolResults* packet); + + void Replay_vkCreateBuffer(Packet_vkCreateBuffer* packet); + + void Replay_vkDestroyBuffer(Packet_vkDestroyBuffer* packet); + + void Replay_vkCreateBufferView(Packet_vkCreateBufferView* packet); + + void Replay_vkDestroyBufferView(Packet_vkDestroyBufferView* packet); + + void Replay_vkCreateImage(Packet_vkCreateImage* packet); + + void Replay_vkDestroyImage(Packet_vkDestroyImage* packet); + + void Replay_vkGetImageSubresourceLayout(Packet_vkGetImageSubresourceLayout* packet); + + void Replay_vkCreateImageView(Packet_vkCreateImageView* packet); + + void Replay_vkDestroyImageView(Packet_vkDestroyImageView* packet); + + void Replay_vkCreateShaderModule(Packet_vkCreateShaderModule* packet); + + void Replay_vkDestroyShaderModule(Packet_vkDestroyShaderModule* packet); + + void Replay_vkCreatePipelineCache(Packet_vkCreatePipelineCache* packet); + + void Replay_vkDestroyPipelineCache(Packet_vkDestroyPipelineCache* packet); + + void Replay_vkGetPipelineCacheData(Packet_vkGetPipelineCacheData* packet); + + void Replay_vkMergePipelineCaches(Packet_vkMergePipelineCaches* packet); + + void Replay_vkCreateGraphicsPipelines(Packet_vkCreateGraphicsPipelines* packet); + + void Replay_vkCreateComputePipelines(Packet_vkCreateComputePipelines* packet); + + void Replay_vkDestroyPipeline(Packet_vkDestroyPipeline* packet); + + void Replay_vkCreatePipelineLayout(Packet_vkCreatePipelineLayout* packet); + + void Replay_vkDestroyPipelineLayout(Packet_vkDestroyPipelineLayout* packet); + + void Replay_vkCreateSampler(Packet_vkCreateSampler* packet); + + void Replay_vkDestroySampler(Packet_vkDestroySampler* packet); + + void Replay_vkCreateDescriptorSetLayout(Packet_vkCreateDescriptorSetLayout* packet); + + void Replay_vkDestroyDescriptorSetLayout(Packet_vkDestroyDescriptorSetLayout* packet); + + void Replay_vkCreateDescriptorPool(Packet_vkCreateDescriptorPool* packet); + + void Replay_vkDestroyDescriptorPool(Packet_vkDestroyDescriptorPool* packet); + + void Replay_vkResetDescriptorPool(Packet_vkResetDescriptorPool* packet); + + void Replay_vkAllocateDescriptorSets(Packet_vkAllocateDescriptorSets* packet); + + void Replay_vkFreeDescriptorSets(Packet_vkFreeDescriptorSets* packet); + + void Replay_vkUpdateDescriptorSets(Packet_vkUpdateDescriptorSets* packet); + + void Replay_vkCreateFramebuffer(Packet_vkCreateFramebuffer* packet); + + void Replay_vkDestroyFramebuffer(Packet_vkDestroyFramebuffer* packet); + + void Replay_vkCreateRenderPass(Packet_vkCreateRenderPass* packet); + + void Replay_vkDestroyRenderPass(Packet_vkDestroyRenderPass* packet); + + void Replay_vkGetRenderAreaGranularity(Packet_vkGetRenderAreaGranularity* packet); + + void Replay_vkCreateCommandPool(Packet_vkCreateCommandPool* packet); + + void Replay_vkDestroyCommandPool(Packet_vkDestroyCommandPool* packet); + + void Replay_vkResetCommandPool(Packet_vkResetCommandPool* packet); + + void Replay_vkAllocateCommandBuffers(Packet_vkAllocateCommandBuffers* packet); + + void Replay_vkFreeCommandBuffers(Packet_vkFreeCommandBuffers* packet); + + void Replay_vkBeginCommandBuffer(Packet_vkBeginCommandBuffer* packet); + + void Replay_vkEndCommandBuffer(Packet_vkEndCommandBuffer* packet); + + void Replay_vkResetCommandBuffer(Packet_vkResetCommandBuffer* packet); + + void Replay_vkCmdBindPipeline(Packet_vkCmdBindPipeline* packet); + + void Replay_vkCmdSetViewport(Packet_vkCmdSetViewport* packet); + + void Replay_vkCmdSetScissor(Packet_vkCmdSetScissor* packet); + + void Replay_vkCmdSetLineWidth(Packet_vkCmdSetLineWidth* packet); + + void Replay_vkCmdSetDepthBias(Packet_vkCmdSetDepthBias* packet); + + void Replay_vkCmdSetBlendConstants(Packet_vkCmdSetBlendConstants* packet); + + void Replay_vkCmdSetDepthBounds(Packet_vkCmdSetDepthBounds* packet); + + void Replay_vkCmdSetStencilCompareMask(Packet_vkCmdSetStencilCompareMask* packet); + + void Replay_vkCmdSetStencilWriteMask(Packet_vkCmdSetStencilWriteMask* packet); + + void Replay_vkCmdSetStencilReference(Packet_vkCmdSetStencilReference* packet); + + void Replay_vkCmdBindDescriptorSets(Packet_vkCmdBindDescriptorSets* packet); + + void Replay_vkCmdBindIndexBuffer(Packet_vkCmdBindIndexBuffer* packet); + + void Replay_vkCmdBindVertexBuffers(Packet_vkCmdBindVertexBuffers* packet); + + void Replay_vkCmdDraw(Packet_vkCmdDraw* packet); + + void Replay_vkCmdDrawIndexed(Packet_vkCmdDrawIndexed* packet); + + void Replay_vkCmdDrawIndirect(Packet_vkCmdDrawIndirect* packet); + + void Replay_vkCmdDrawIndexedIndirect(Packet_vkCmdDrawIndexedIndirect* packet); + + void Replay_vkCmdDispatch(Packet_vkCmdDispatch* packet); + + void Replay_vkCmdDispatchIndirect(Packet_vkCmdDispatchIndirect* packet); + + void Replay_vkCmdCopyBuffer(Packet_vkCmdCopyBuffer* packet); + + void Replay_vkCmdCopyImage(Packet_vkCmdCopyImage* packet); + + void Replay_vkCmdBlitImage(Packet_vkCmdBlitImage* packet); + + void Replay_vkCmdCopyBufferToImage(Packet_vkCmdCopyBufferToImage* packet); + + void Replay_vkCmdCopyImageToBuffer(Packet_vkCmdCopyImageToBuffer* packet); + + void Replay_vkCmdUpdateBuffer(Packet_vkCmdUpdateBuffer* packet); + + void Replay_vkCmdFillBuffer(Packet_vkCmdFillBuffer* packet); + + void Replay_vkCmdClearColorImage(Packet_vkCmdClearColorImage* packet); + + void Replay_vkCmdClearDepthStencilImage(Packet_vkCmdClearDepthStencilImage* packet); + + void Replay_vkCmdClearAttachments(Packet_vkCmdClearAttachments* packet); + + void Replay_vkCmdResolveImage(Packet_vkCmdResolveImage* packet); + + void Replay_vkCmdSetEvent(Packet_vkCmdSetEvent* packet); + + void Replay_vkCmdResetEvent(Packet_vkCmdResetEvent* packet); + + void Replay_vkCmdWaitEvents(Packet_vkCmdWaitEvents* packet); + + void Replay_vkCmdPipelineBarrier(Packet_vkCmdPipelineBarrier* packet); + + void Replay_vkCmdBeginQuery(Packet_vkCmdBeginQuery* packet); + + void Replay_vkCmdEndQuery(Packet_vkCmdEndQuery* packet); + + void Replay_vkCmdResetQueryPool(Packet_vkCmdResetQueryPool* packet); + + void Replay_vkCmdWriteTimestamp(Packet_vkCmdWriteTimestamp* packet); + + void Replay_vkCmdCopyQueryPoolResults(Packet_vkCmdCopyQueryPoolResults* packet); + + void Replay_vkCmdPushConstants(Packet_vkCmdPushConstants* packet); + + void Replay_vkCmdBeginRenderPass(Packet_vkCmdBeginRenderPass* packet); + + void Replay_vkCmdNextSubpass(Packet_vkCmdNextSubpass* packet); + + void Replay_vkCmdEndRenderPass(Packet_vkCmdEndRenderPass* packet); + + void Replay_vkCmdExecuteCommands(Packet_vkCmdExecuteCommands* packet); + + void Replay_vkBindBufferMemory2(Packet_vkBindBufferMemory2* packet); + + void Replay_vkBindImageMemory2(Packet_vkBindImageMemory2* packet); + + void Replay_vkGetDeviceGroupPeerMemoryFeatures(Packet_vkGetDeviceGroupPeerMemoryFeatures* packet); + + void Replay_vkCmdSetDeviceMask(Packet_vkCmdSetDeviceMask* packet); + + void Replay_vkCmdDispatchBase(Packet_vkCmdDispatchBase* packet); + + void Replay_vkEnumeratePhysicalDeviceGroups(Packet_vkEnumeratePhysicalDeviceGroups* packet); + + void Replay_vkGetImageMemoryRequirements2(Packet_vkGetImageMemoryRequirements2* packet); + + void Replay_vkGetBufferMemoryRequirements2(Packet_vkGetBufferMemoryRequirements2* packet); + + void Replay_vkGetImageSparseMemoryRequirements2(Packet_vkGetImageSparseMemoryRequirements2* packet); + + void Replay_vkGetPhysicalDeviceFeatures2(Packet_vkGetPhysicalDeviceFeatures2* packet); + + void Replay_vkGetPhysicalDeviceProperties2(Packet_vkGetPhysicalDeviceProperties2* packet); + + void Replay_vkGetPhysicalDeviceFormatProperties2(Packet_vkGetPhysicalDeviceFormatProperties2* packet); + + void Replay_vkGetPhysicalDeviceImageFormatProperties2(Packet_vkGetPhysicalDeviceImageFormatProperties2* packet); + + void Replay_vkGetPhysicalDeviceQueueFamilyProperties2(Packet_vkGetPhysicalDeviceQueueFamilyProperties2* packet); + + void Replay_vkGetPhysicalDeviceMemoryProperties2(Packet_vkGetPhysicalDeviceMemoryProperties2* packet); + + void Replay_vkGetPhysicalDeviceSparseImageFormatProperties2(Packet_vkGetPhysicalDeviceSparseImageFormatProperties2* packet); + + void Replay_vkTrimCommandPool(Packet_vkTrimCommandPool* packet); + + void Replay_vkGetDeviceQueue2(Packet_vkGetDeviceQueue2* packet); + + void Replay_vkCreateSamplerYcbcrConversion(Packet_vkCreateSamplerYcbcrConversion* packet); + + void Replay_vkDestroySamplerYcbcrConversion(Packet_vkDestroySamplerYcbcrConversion* packet); + + void Replay_vkCreateDescriptorUpdateTemplate(Packet_vkCreateDescriptorUpdateTemplate* packet); + + void Replay_vkDestroyDescriptorUpdateTemplate(Packet_vkDestroyDescriptorUpdateTemplate* packet); + + void Replay_vkGetPhysicalDeviceExternalBufferProperties(Packet_vkGetPhysicalDeviceExternalBufferProperties* packet); + + void Replay_vkGetPhysicalDeviceExternalFenceProperties(Packet_vkGetPhysicalDeviceExternalFenceProperties* packet); + + void Replay_vkGetPhysicalDeviceExternalSemaphoreProperties(Packet_vkGetPhysicalDeviceExternalSemaphoreProperties* packet); + + void Replay_vkGetDescriptorSetLayoutSupport(Packet_vkGetDescriptorSetLayoutSupport* packet); + + void Replay_vkCmdDrawIndirectCount(Packet_vkCmdDrawIndirectCount* packet); + + void Replay_vkCmdDrawIndexedIndirectCount(Packet_vkCmdDrawIndexedIndirectCount* packet); + + void Replay_vkCreateRenderPass2(Packet_vkCreateRenderPass2* packet); + + void Replay_vkCmdBeginRenderPass2(Packet_vkCmdBeginRenderPass2* packet); + + void Replay_vkCmdNextSubpass2(Packet_vkCmdNextSubpass2* packet); + + void Replay_vkCmdEndRenderPass2(Packet_vkCmdEndRenderPass2* packet); + + void Replay_vkResetQueryPool(Packet_vkResetQueryPool* packet); + + void Replay_vkGetSemaphoreCounterValue(Packet_vkGetSemaphoreCounterValue* packet); + + void Replay_vkWaitSemaphores(Packet_vkWaitSemaphores* packet); + + void Replay_vkSignalSemaphore(Packet_vkSignalSemaphore* packet); + + void Replay_vkGetBufferDeviceAddress(Packet_vkGetBufferDeviceAddress* packet); + + void Replay_vkGetBufferOpaqueCaptureAddress(Packet_vkGetBufferOpaqueCaptureAddress* packet); + + void Replay_vkGetDeviceMemoryOpaqueCaptureAddress(Packet_vkGetDeviceMemoryOpaqueCaptureAddress* packet); + + void Replay_vkGetPhysicalDeviceToolProperties(Packet_vkGetPhysicalDeviceToolProperties* packet); + + void Replay_vkCreatePrivateDataSlot(Packet_vkCreatePrivateDataSlot* packet); + + void Replay_vkDestroyPrivateDataSlot(Packet_vkDestroyPrivateDataSlot* packet); + + void Replay_vkSetPrivateData(Packet_vkSetPrivateData* packet); + + void Replay_vkGetPrivateData(Packet_vkGetPrivateData* packet); + + void Replay_vkCmdSetEvent2(Packet_vkCmdSetEvent2* packet); + + void Replay_vkCmdResetEvent2(Packet_vkCmdResetEvent2* packet); + + void Replay_vkCmdWaitEvents2(Packet_vkCmdWaitEvents2* packet); + + void Replay_vkCmdPipelineBarrier2(Packet_vkCmdPipelineBarrier2* packet); + + void Replay_vkCmdWriteTimestamp2(Packet_vkCmdWriteTimestamp2* packet); + + void Replay_vkQueueSubmit2(Packet_vkQueueSubmit2* packet); + + void Replay_vkCmdCopyBuffer2(Packet_vkCmdCopyBuffer2* packet); + + void Replay_vkCmdCopyImage2(Packet_vkCmdCopyImage2* packet); + + void Replay_vkCmdCopyBufferToImage2(Packet_vkCmdCopyBufferToImage2* packet); + + void Replay_vkCmdCopyImageToBuffer2(Packet_vkCmdCopyImageToBuffer2* packet); + + void Replay_vkCmdBlitImage2(Packet_vkCmdBlitImage2* packet); + + void Replay_vkCmdResolveImage2(Packet_vkCmdResolveImage2* packet); + + void Replay_vkCmdBeginRendering(Packet_vkCmdBeginRendering* packet); + + void Replay_vkCmdEndRendering(Packet_vkCmdEndRendering* packet); + + void Replay_vkCmdSetCullMode(Packet_vkCmdSetCullMode* packet); + + void Replay_vkCmdSetFrontFace(Packet_vkCmdSetFrontFace* packet); + + void Replay_vkCmdSetPrimitiveTopology(Packet_vkCmdSetPrimitiveTopology* packet); + + void Replay_vkCmdSetViewportWithCount(Packet_vkCmdSetViewportWithCount* packet); + + void Replay_vkCmdSetScissorWithCount(Packet_vkCmdSetScissorWithCount* packet); + + void Replay_vkCmdBindVertexBuffers2(Packet_vkCmdBindVertexBuffers2* packet); + + void Replay_vkCmdSetDepthTestEnable(Packet_vkCmdSetDepthTestEnable* packet); + + void Replay_vkCmdSetDepthWriteEnable(Packet_vkCmdSetDepthWriteEnable* packet); + + void Replay_vkCmdSetDepthCompareOp(Packet_vkCmdSetDepthCompareOp* packet); + + void Replay_vkCmdSetDepthBoundsTestEnable(Packet_vkCmdSetDepthBoundsTestEnable* packet); + + void Replay_vkCmdSetStencilTestEnable(Packet_vkCmdSetStencilTestEnable* packet); + + void Replay_vkCmdSetStencilOp(Packet_vkCmdSetStencilOp* packet); + + void Replay_vkCmdSetRasterizerDiscardEnable(Packet_vkCmdSetRasterizerDiscardEnable* packet); + + void Replay_vkCmdSetDepthBiasEnable(Packet_vkCmdSetDepthBiasEnable* packet); + + void Replay_vkCmdSetPrimitiveRestartEnable(Packet_vkCmdSetPrimitiveRestartEnable* packet); + + void Replay_vkGetDeviceBufferMemoryRequirements(Packet_vkGetDeviceBufferMemoryRequirements* packet); + + void Replay_vkGetDeviceImageMemoryRequirements(Packet_vkGetDeviceImageMemoryRequirements* packet); + + void Replay_vkGetDeviceImageSparseMemoryRequirements(Packet_vkGetDeviceImageSparseMemoryRequirements* packet); + + void Replay_vkDestroySurfaceKHR(Packet_vkDestroySurfaceKHR* packet); + + void Replay_vkGetPhysicalDeviceSurfaceSupportKHR(Packet_vkGetPhysicalDeviceSurfaceSupportKHR* packet); + + void Replay_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(Packet_vkGetPhysicalDeviceSurfaceCapabilitiesKHR* packet); + + void Replay_vkGetPhysicalDeviceSurfaceFormatsKHR(Packet_vkGetPhysicalDeviceSurfaceFormatsKHR* packet); + + void Replay_vkGetPhysicalDeviceSurfacePresentModesKHR(Packet_vkGetPhysicalDeviceSurfacePresentModesKHR* packet); + + void Replay_vkCreateSwapchainKHR(Packet_vkCreateSwapchainKHR* packet); + + void Replay_vkDestroySwapchainKHR(Packet_vkDestroySwapchainKHR* packet); + + void Replay_vkGetSwapchainImagesKHR(Packet_vkGetSwapchainImagesKHR* packet); + + void Replay_vkAcquireNextImageKHR(Packet_vkAcquireNextImageKHR* packet); + + void Replay_vkQueuePresentKHR(Packet_vkQueuePresentKHR* packet); + + void Replay_vkGetDeviceGroupPresentCapabilitiesKHR(Packet_vkGetDeviceGroupPresentCapabilitiesKHR* packet); + + void Replay_vkGetDeviceGroupSurfacePresentModesKHR(Packet_vkGetDeviceGroupSurfacePresentModesKHR* packet); + + void Replay_vkGetPhysicalDevicePresentRectanglesKHR(Packet_vkGetPhysicalDevicePresentRectanglesKHR* packet); + + void Replay_vkAcquireNextImage2KHR(Packet_vkAcquireNextImage2KHR* packet); + + void Replay_vkGetPhysicalDeviceDisplayPropertiesKHR(Packet_vkGetPhysicalDeviceDisplayPropertiesKHR* packet); + + void Replay_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(Packet_vkGetPhysicalDeviceDisplayPlanePropertiesKHR* packet); + + void Replay_vkGetDisplayPlaneSupportedDisplaysKHR(Packet_vkGetDisplayPlaneSupportedDisplaysKHR* packet); + + void Replay_vkGetDisplayModePropertiesKHR(Packet_vkGetDisplayModePropertiesKHR* packet); + + void Replay_vkCreateDisplayModeKHR(Packet_vkCreateDisplayModeKHR* packet); + + void Replay_vkGetDisplayPlaneCapabilitiesKHR(Packet_vkGetDisplayPlaneCapabilitiesKHR* packet); + + void Replay_vkCreateDisplayPlaneSurfaceKHR(Packet_vkCreateDisplayPlaneSurfaceKHR* packet); + + void Replay_vkCreateSharedSwapchainsKHR(Packet_vkCreateSharedSwapchainsKHR* packet); + + void Replay_vkCreateXlibSurfaceKHR(Packet_vkCreateXlibSurfaceKHR* packet); + + void Replay_vkGetPhysicalDeviceXlibPresentationSupportKHR(Packet_vkGetPhysicalDeviceXlibPresentationSupportKHR* packet); + + void Replay_vkCreateXcbSurfaceKHR(Packet_vkCreateXcbSurfaceKHR* packet); + + void Replay_vkGetPhysicalDeviceXcbPresentationSupportKHR(Packet_vkGetPhysicalDeviceXcbPresentationSupportKHR* packet); + + void Replay_vkCreateWaylandSurfaceKHR(Packet_vkCreateWaylandSurfaceKHR* packet); + + void Replay_vkGetPhysicalDeviceWaylandPresentationSupportKHR(Packet_vkGetPhysicalDeviceWaylandPresentationSupportKHR* packet); + + void Replay_vkCreateAndroidSurfaceKHR(Packet_vkCreateAndroidSurfaceKHR* packet); + + void Replay_vkCreateWin32SurfaceKHR(Packet_vkCreateWin32SurfaceKHR* packet); + + void Replay_vkGetPhysicalDeviceWin32PresentationSupportKHR(Packet_vkGetPhysicalDeviceWin32PresentationSupportKHR* packet); + + void Replay_vkGetPhysicalDeviceVideoCapabilitiesKHR(Packet_vkGetPhysicalDeviceVideoCapabilitiesKHR* packet); + + void Replay_vkGetPhysicalDeviceVideoFormatPropertiesKHR(Packet_vkGetPhysicalDeviceVideoFormatPropertiesKHR* packet); + + void Replay_vkCreateVideoSessionKHR(Packet_vkCreateVideoSessionKHR* packet); + + void Replay_vkDestroyVideoSessionKHR(Packet_vkDestroyVideoSessionKHR* packet); + + void Replay_vkGetVideoSessionMemoryRequirementsKHR(Packet_vkGetVideoSessionMemoryRequirementsKHR* packet); + + void Replay_vkBindVideoSessionMemoryKHR(Packet_vkBindVideoSessionMemoryKHR* packet); + + void Replay_vkCreateVideoSessionParametersKHR(Packet_vkCreateVideoSessionParametersKHR* packet); + + void Replay_vkUpdateVideoSessionParametersKHR(Packet_vkUpdateVideoSessionParametersKHR* packet); + + void Replay_vkDestroyVideoSessionParametersKHR(Packet_vkDestroyVideoSessionParametersKHR* packet); + + void Replay_vkCmdBeginVideoCodingKHR(Packet_vkCmdBeginVideoCodingKHR* packet); + + void Replay_vkCmdEndVideoCodingKHR(Packet_vkCmdEndVideoCodingKHR* packet); + + void Replay_vkCmdControlVideoCodingKHR(Packet_vkCmdControlVideoCodingKHR* packet); + + void Replay_vkCmdDecodeVideoKHR(Packet_vkCmdDecodeVideoKHR* packet); + + void Replay_vkCmdBeginRenderingKHR(Packet_vkCmdBeginRenderingKHR* packet); + + void Replay_vkCmdEndRenderingKHR(Packet_vkCmdEndRenderingKHR* packet); + + void Replay_vkGetPhysicalDeviceFeatures2KHR(Packet_vkGetPhysicalDeviceFeatures2KHR* packet); + + void Replay_vkGetPhysicalDeviceProperties2KHR(Packet_vkGetPhysicalDeviceProperties2KHR* packet); + + void Replay_vkGetPhysicalDeviceFormatProperties2KHR(Packet_vkGetPhysicalDeviceFormatProperties2KHR* packet); + + void Replay_vkGetPhysicalDeviceImageFormatProperties2KHR(Packet_vkGetPhysicalDeviceImageFormatProperties2KHR* packet); + + void Replay_vkGetPhysicalDeviceQueueFamilyProperties2KHR(Packet_vkGetPhysicalDeviceQueueFamilyProperties2KHR* packet); + + void Replay_vkGetPhysicalDeviceMemoryProperties2KHR(Packet_vkGetPhysicalDeviceMemoryProperties2KHR* packet); + + void Replay_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(Packet_vkGetPhysicalDeviceSparseImageFormatProperties2KHR* packet); + + void Replay_vkGetDeviceGroupPeerMemoryFeaturesKHR(Packet_vkGetDeviceGroupPeerMemoryFeaturesKHR* packet); + + void Replay_vkCmdSetDeviceMaskKHR(Packet_vkCmdSetDeviceMaskKHR* packet); + + void Replay_vkCmdDispatchBaseKHR(Packet_vkCmdDispatchBaseKHR* packet); + + void Replay_vkTrimCommandPoolKHR(Packet_vkTrimCommandPoolKHR* packet); + + void Replay_vkEnumeratePhysicalDeviceGroupsKHR(Packet_vkEnumeratePhysicalDeviceGroupsKHR* packet); + + void Replay_vkGetPhysicalDeviceExternalBufferPropertiesKHR(Packet_vkGetPhysicalDeviceExternalBufferPropertiesKHR* packet); + + void Replay_vkGetMemoryWin32HandleKHR(Packet_vkGetMemoryWin32HandleKHR* packet); + + void Replay_vkGetMemoryWin32HandlePropertiesKHR(Packet_vkGetMemoryWin32HandlePropertiesKHR* packet); + + void Replay_vkGetMemoryFdKHR(Packet_vkGetMemoryFdKHR* packet); + + void Replay_vkGetMemoryFdPropertiesKHR(Packet_vkGetMemoryFdPropertiesKHR* packet); + + void Replay_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(Packet_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR* packet); + + void Replay_vkImportSemaphoreWin32HandleKHR(Packet_vkImportSemaphoreWin32HandleKHR* packet); + + void Replay_vkGetSemaphoreWin32HandleKHR(Packet_vkGetSemaphoreWin32HandleKHR* packet); + + void Replay_vkImportSemaphoreFdKHR(Packet_vkImportSemaphoreFdKHR* packet); + + void Replay_vkGetSemaphoreFdKHR(Packet_vkGetSemaphoreFdKHR* packet); + + void Replay_vkCmdPushDescriptorSetKHR(Packet_vkCmdPushDescriptorSetKHR* packet); + + void Replay_vkCreateDescriptorUpdateTemplateKHR(Packet_vkCreateDescriptorUpdateTemplateKHR* packet); + + void Replay_vkDestroyDescriptorUpdateTemplateKHR(Packet_vkDestroyDescriptorUpdateTemplateKHR* packet); + + void Replay_vkCreateRenderPass2KHR(Packet_vkCreateRenderPass2KHR* packet); + + void Replay_vkCmdBeginRenderPass2KHR(Packet_vkCmdBeginRenderPass2KHR* packet); + + void Replay_vkCmdNextSubpass2KHR(Packet_vkCmdNextSubpass2KHR* packet); + + void Replay_vkCmdEndRenderPass2KHR(Packet_vkCmdEndRenderPass2KHR* packet); + + void Replay_vkGetSwapchainStatusKHR(Packet_vkGetSwapchainStatusKHR* packet); + + void Replay_vkGetPhysicalDeviceExternalFencePropertiesKHR(Packet_vkGetPhysicalDeviceExternalFencePropertiesKHR* packet); + + void Replay_vkImportFenceWin32HandleKHR(Packet_vkImportFenceWin32HandleKHR* packet); + + void Replay_vkGetFenceWin32HandleKHR(Packet_vkGetFenceWin32HandleKHR* packet); + + void Replay_vkImportFenceFdKHR(Packet_vkImportFenceFdKHR* packet); + + void Replay_vkGetFenceFdKHR(Packet_vkGetFenceFdKHR* packet); + + void Replay_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(Packet_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR* packet); + + void Replay_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(Packet_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR* packet); + + void Replay_vkAcquireProfilingLockKHR(Packet_vkAcquireProfilingLockKHR* packet); + + void Replay_vkReleaseProfilingLockKHR(Packet_vkReleaseProfilingLockKHR* packet); + + void Replay_vkGetPhysicalDeviceSurfaceCapabilities2KHR(Packet_vkGetPhysicalDeviceSurfaceCapabilities2KHR* packet); + + void Replay_vkGetPhysicalDeviceSurfaceFormats2KHR(Packet_vkGetPhysicalDeviceSurfaceFormats2KHR* packet); + + void Replay_vkGetPhysicalDeviceDisplayProperties2KHR(Packet_vkGetPhysicalDeviceDisplayProperties2KHR* packet); + + void Replay_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(Packet_vkGetPhysicalDeviceDisplayPlaneProperties2KHR* packet); + + void Replay_vkGetDisplayModeProperties2KHR(Packet_vkGetDisplayModeProperties2KHR* packet); + + void Replay_vkGetDisplayPlaneCapabilities2KHR(Packet_vkGetDisplayPlaneCapabilities2KHR* packet); + + void Replay_vkGetImageMemoryRequirements2KHR(Packet_vkGetImageMemoryRequirements2KHR* packet); + + void Replay_vkGetBufferMemoryRequirements2KHR(Packet_vkGetBufferMemoryRequirements2KHR* packet); + + void Replay_vkGetImageSparseMemoryRequirements2KHR(Packet_vkGetImageSparseMemoryRequirements2KHR* packet); + + void Replay_vkCreateSamplerYcbcrConversionKHR(Packet_vkCreateSamplerYcbcrConversionKHR* packet); + + void Replay_vkDestroySamplerYcbcrConversionKHR(Packet_vkDestroySamplerYcbcrConversionKHR* packet); + + void Replay_vkBindBufferMemory2KHR(Packet_vkBindBufferMemory2KHR* packet); + + void Replay_vkBindImageMemory2KHR(Packet_vkBindImageMemory2KHR* packet); + + void Replay_vkGetDescriptorSetLayoutSupportKHR(Packet_vkGetDescriptorSetLayoutSupportKHR* packet); + + void Replay_vkCmdDrawIndirectCountKHR(Packet_vkCmdDrawIndirectCountKHR* packet); + + void Replay_vkCmdDrawIndexedIndirectCountKHR(Packet_vkCmdDrawIndexedIndirectCountKHR* packet); + + void Replay_vkGetSemaphoreCounterValueKHR(Packet_vkGetSemaphoreCounterValueKHR* packet); + + void Replay_vkWaitSemaphoresKHR(Packet_vkWaitSemaphoresKHR* packet); + + void Replay_vkSignalSemaphoreKHR(Packet_vkSignalSemaphoreKHR* packet); + + void Replay_vkGetPhysicalDeviceFragmentShadingRatesKHR(Packet_vkGetPhysicalDeviceFragmentShadingRatesKHR* packet); + + void Replay_vkCmdSetFragmentShadingRateKHR(Packet_vkCmdSetFragmentShadingRateKHR* packet); + + void Replay_vkCmdSetRenderingAttachmentLocationsKHR(Packet_vkCmdSetRenderingAttachmentLocationsKHR* packet); + + void Replay_vkCmdSetRenderingInputAttachmentIndicesKHR(Packet_vkCmdSetRenderingInputAttachmentIndicesKHR* packet); + + void Replay_vkWaitForPresentKHR(Packet_vkWaitForPresentKHR* packet); + + void Replay_vkGetBufferDeviceAddressKHR(Packet_vkGetBufferDeviceAddressKHR* packet); + + void Replay_vkGetBufferOpaqueCaptureAddressKHR(Packet_vkGetBufferOpaqueCaptureAddressKHR* packet); + + void Replay_vkGetDeviceMemoryOpaqueCaptureAddressKHR(Packet_vkGetDeviceMemoryOpaqueCaptureAddressKHR* packet); + + void Replay_vkCreateDeferredOperationKHR(Packet_vkCreateDeferredOperationKHR* packet); + + void Replay_vkDestroyDeferredOperationKHR(Packet_vkDestroyDeferredOperationKHR* packet); + + void Replay_vkGetDeferredOperationMaxConcurrencyKHR(Packet_vkGetDeferredOperationMaxConcurrencyKHR* packet); + + void Replay_vkGetDeferredOperationResultKHR(Packet_vkGetDeferredOperationResultKHR* packet); + + void Replay_vkDeferredOperationJoinKHR(Packet_vkDeferredOperationJoinKHR* packet); + + void Replay_vkGetPipelineExecutablePropertiesKHR(Packet_vkGetPipelineExecutablePropertiesKHR* packet); + + void Replay_vkGetPipelineExecutableStatisticsKHR(Packet_vkGetPipelineExecutableStatisticsKHR* packet); + + void Replay_vkGetPipelineExecutableInternalRepresentationsKHR(Packet_vkGetPipelineExecutableInternalRepresentationsKHR* packet); + + void Replay_vkMapMemory2KHR(Packet_vkMapMemory2KHR* packet); + + void Replay_vkUnmapMemory2KHR(Packet_vkUnmapMemory2KHR* packet); + + void Replay_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(Packet_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR* packet); + + void Replay_vkGetEncodedVideoSessionParametersKHR(Packet_vkGetEncodedVideoSessionParametersKHR* packet); + + void Replay_vkCmdEncodeVideoKHR(Packet_vkCmdEncodeVideoKHR* packet); + + void Replay_vkCmdSetEvent2KHR(Packet_vkCmdSetEvent2KHR* packet); + + void Replay_vkCmdResetEvent2KHR(Packet_vkCmdResetEvent2KHR* packet); + + void Replay_vkCmdWaitEvents2KHR(Packet_vkCmdWaitEvents2KHR* packet); + + void Replay_vkCmdPipelineBarrier2KHR(Packet_vkCmdPipelineBarrier2KHR* packet); + + void Replay_vkCmdWriteTimestamp2KHR(Packet_vkCmdWriteTimestamp2KHR* packet); + + void Replay_vkQueueSubmit2KHR(Packet_vkQueueSubmit2KHR* packet); + + void Replay_vkCmdWriteBufferMarker2AMD(Packet_vkCmdWriteBufferMarker2AMD* packet); + + void Replay_vkGetQueueCheckpointData2NV(Packet_vkGetQueueCheckpointData2NV* packet); + + void Replay_vkCmdCopyBuffer2KHR(Packet_vkCmdCopyBuffer2KHR* packet); + + void Replay_vkCmdCopyImage2KHR(Packet_vkCmdCopyImage2KHR* packet); + + void Replay_vkCmdCopyBufferToImage2KHR(Packet_vkCmdCopyBufferToImage2KHR* packet); + + void Replay_vkCmdCopyImageToBuffer2KHR(Packet_vkCmdCopyImageToBuffer2KHR* packet); + + void Replay_vkCmdBlitImage2KHR(Packet_vkCmdBlitImage2KHR* packet); + + void Replay_vkCmdResolveImage2KHR(Packet_vkCmdResolveImage2KHR* packet); + + void Replay_vkCmdTraceRaysIndirect2KHR(Packet_vkCmdTraceRaysIndirect2KHR* packet); + + void Replay_vkGetDeviceBufferMemoryRequirementsKHR(Packet_vkGetDeviceBufferMemoryRequirementsKHR* packet); + + void Replay_vkGetDeviceImageMemoryRequirementsKHR(Packet_vkGetDeviceImageMemoryRequirementsKHR* packet); + + void Replay_vkGetDeviceImageSparseMemoryRequirementsKHR(Packet_vkGetDeviceImageSparseMemoryRequirementsKHR* packet); + + void Replay_vkCmdBindIndexBuffer2KHR(Packet_vkCmdBindIndexBuffer2KHR* packet); + + void Replay_vkGetRenderingAreaGranularityKHR(Packet_vkGetRenderingAreaGranularityKHR* packet); + + void Replay_vkGetDeviceImageSubresourceLayoutKHR(Packet_vkGetDeviceImageSubresourceLayoutKHR* packet); + + void Replay_vkGetImageSubresourceLayout2KHR(Packet_vkGetImageSubresourceLayout2KHR* packet); + + void Replay_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(Packet_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR* packet); + + void Replay_vkCmdSetLineStippleKHR(Packet_vkCmdSetLineStippleKHR* packet); + + void Replay_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(Packet_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR* packet); + + void Replay_vkGetCalibratedTimestampsKHR(Packet_vkGetCalibratedTimestampsKHR* packet); + + void Replay_vkCmdBindDescriptorSets2KHR(Packet_vkCmdBindDescriptorSets2KHR* packet); + + void Replay_vkCmdPushConstants2KHR(Packet_vkCmdPushConstants2KHR* packet); + + void Replay_vkCmdPushDescriptorSet2KHR(Packet_vkCmdPushDescriptorSet2KHR* packet); + + void Replay_vkCmdSetDescriptorBufferOffsets2EXT(Packet_vkCmdSetDescriptorBufferOffsets2EXT* packet); + + void Replay_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(Packet_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT* packet); + + void Replay_vkFrameBoundaryANDROID(Packet_vkFrameBoundaryANDROID* packet); + + void Replay_vkCreateDebugReportCallbackEXT(Packet_vkCreateDebugReportCallbackEXT* packet); + + void Replay_vkDestroyDebugReportCallbackEXT(Packet_vkDestroyDebugReportCallbackEXT* packet); + + void Replay_vkDebugReportMessageEXT(Packet_vkDebugReportMessageEXT* packet); + + void Replay_vkDebugMarkerSetObjectTagEXT(Packet_vkDebugMarkerSetObjectTagEXT* packet); + + void Replay_vkDebugMarkerSetObjectNameEXT(Packet_vkDebugMarkerSetObjectNameEXT* packet); + + void Replay_vkCmdDebugMarkerBeginEXT(Packet_vkCmdDebugMarkerBeginEXT* packet); + + void Replay_vkCmdDebugMarkerEndEXT(Packet_vkCmdDebugMarkerEndEXT* packet); + + void Replay_vkCmdDebugMarkerInsertEXT(Packet_vkCmdDebugMarkerInsertEXT* packet); + + void Replay_vkCmdBindTransformFeedbackBuffersEXT(Packet_vkCmdBindTransformFeedbackBuffersEXT* packet); + + void Replay_vkCmdBeginTransformFeedbackEXT(Packet_vkCmdBeginTransformFeedbackEXT* packet); + + void Replay_vkCmdEndTransformFeedbackEXT(Packet_vkCmdEndTransformFeedbackEXT* packet); + + void Replay_vkCmdBeginQueryIndexedEXT(Packet_vkCmdBeginQueryIndexedEXT* packet); + + void Replay_vkCmdEndQueryIndexedEXT(Packet_vkCmdEndQueryIndexedEXT* packet); + + void Replay_vkCmdDrawIndirectByteCountEXT(Packet_vkCmdDrawIndirectByteCountEXT* packet); + + void Replay_vkGetImageViewHandleNVX(Packet_vkGetImageViewHandleNVX* packet); + + void Replay_vkGetImageViewAddressNVX(Packet_vkGetImageViewAddressNVX* packet); + + void Replay_vkCmdDrawIndirectCountAMD(Packet_vkCmdDrawIndirectCountAMD* packet); + + void Replay_vkCmdDrawIndexedIndirectCountAMD(Packet_vkCmdDrawIndexedIndirectCountAMD* packet); + + void Replay_vkGetShaderInfoAMD(Packet_vkGetShaderInfoAMD* packet); + + void Replay_vkCreateStreamDescriptorSurfaceGGP(Packet_vkCreateStreamDescriptorSurfaceGGP* packet); + + void Replay_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(Packet_vkGetPhysicalDeviceExternalImageFormatPropertiesNV* packet); + + void Replay_vkGetMemoryWin32HandleNV(Packet_vkGetMemoryWin32HandleNV* packet); + + void Replay_vkCreateViSurfaceNN(Packet_vkCreateViSurfaceNN* packet); + + void Replay_vkCmdBeginConditionalRenderingEXT(Packet_vkCmdBeginConditionalRenderingEXT* packet); + + void Replay_vkCmdEndConditionalRenderingEXT(Packet_vkCmdEndConditionalRenderingEXT* packet); + + void Replay_vkCmdSetViewportWScalingNV(Packet_vkCmdSetViewportWScalingNV* packet); + + void Replay_vkReleaseDisplayEXT(Packet_vkReleaseDisplayEXT* packet); + + void Replay_vkAcquireXlibDisplayEXT(Packet_vkAcquireXlibDisplayEXT* packet); + + void Replay_vkGetRandROutputDisplayEXT(Packet_vkGetRandROutputDisplayEXT* packet); + + void Replay_vkGetPhysicalDeviceSurfaceCapabilities2EXT(Packet_vkGetPhysicalDeviceSurfaceCapabilities2EXT* packet); + + void Replay_vkDisplayPowerControlEXT(Packet_vkDisplayPowerControlEXT* packet); + + void Replay_vkRegisterDeviceEventEXT(Packet_vkRegisterDeviceEventEXT* packet); + + void Replay_vkRegisterDisplayEventEXT(Packet_vkRegisterDisplayEventEXT* packet); + + void Replay_vkGetSwapchainCounterEXT(Packet_vkGetSwapchainCounterEXT* packet); + + void Replay_vkGetRefreshCycleDurationGOOGLE(Packet_vkGetRefreshCycleDurationGOOGLE* packet); + + void Replay_vkGetPastPresentationTimingGOOGLE(Packet_vkGetPastPresentationTimingGOOGLE* packet); + + void Replay_vkCmdSetDiscardRectangleEXT(Packet_vkCmdSetDiscardRectangleEXT* packet); + + void Replay_vkCmdSetDiscardRectangleEnableEXT(Packet_vkCmdSetDiscardRectangleEnableEXT* packet); + + void Replay_vkCmdSetDiscardRectangleModeEXT(Packet_vkCmdSetDiscardRectangleModeEXT* packet); + + void Replay_vkSetHdrMetadataEXT(Packet_vkSetHdrMetadataEXT* packet); + + void Replay_vkCreateIOSSurfaceMVK(Packet_vkCreateIOSSurfaceMVK* packet); + + void Replay_vkCreateMacOSSurfaceMVK(Packet_vkCreateMacOSSurfaceMVK* packet); + + void Replay_vkSetDebugUtilsObjectNameEXT(Packet_vkSetDebugUtilsObjectNameEXT* packet); + + void Replay_vkSetDebugUtilsObjectTagEXT(Packet_vkSetDebugUtilsObjectTagEXT* packet); + + void Replay_vkQueueBeginDebugUtilsLabelEXT(Packet_vkQueueBeginDebugUtilsLabelEXT* packet); + + void Replay_vkQueueEndDebugUtilsLabelEXT(Packet_vkQueueEndDebugUtilsLabelEXT* packet); + + void Replay_vkQueueInsertDebugUtilsLabelEXT(Packet_vkQueueInsertDebugUtilsLabelEXT* packet); + + void Replay_vkCmdBeginDebugUtilsLabelEXT(Packet_vkCmdBeginDebugUtilsLabelEXT* packet); + + void Replay_vkCmdEndDebugUtilsLabelEXT(Packet_vkCmdEndDebugUtilsLabelEXT* packet); + + void Replay_vkCmdInsertDebugUtilsLabelEXT(Packet_vkCmdInsertDebugUtilsLabelEXT* packet); + + void Replay_vkCreateDebugUtilsMessengerEXT(Packet_vkCreateDebugUtilsMessengerEXT* packet); + + void Replay_vkDestroyDebugUtilsMessengerEXT(Packet_vkDestroyDebugUtilsMessengerEXT* packet); + + void Replay_vkSubmitDebugUtilsMessageEXT(Packet_vkSubmitDebugUtilsMessageEXT* packet); + + void Replay_vkGetAndroidHardwareBufferPropertiesANDROID(Packet_vkGetAndroidHardwareBufferPropertiesANDROID* packet); + + void Replay_vkGetMemoryAndroidHardwareBufferANDROID(Packet_vkGetMemoryAndroidHardwareBufferANDROID* packet); + + void Replay_vkCmdSetSampleLocationsEXT(Packet_vkCmdSetSampleLocationsEXT* packet); + + void Replay_vkGetPhysicalDeviceMultisamplePropertiesEXT(Packet_vkGetPhysicalDeviceMultisamplePropertiesEXT* packet); + + void Replay_vkGetImageDrmFormatModifierPropertiesEXT(Packet_vkGetImageDrmFormatModifierPropertiesEXT* packet); + + void Replay_vkCreateValidationCacheEXT(Packet_vkCreateValidationCacheEXT* packet); + + void Replay_vkDestroyValidationCacheEXT(Packet_vkDestroyValidationCacheEXT* packet); + + void Replay_vkMergeValidationCachesEXT(Packet_vkMergeValidationCachesEXT* packet); + + void Replay_vkGetValidationCacheDataEXT(Packet_vkGetValidationCacheDataEXT* packet); + + void Replay_vkCmdBindShadingRateImageNV(Packet_vkCmdBindShadingRateImageNV* packet); + + void Replay_vkCmdSetViewportShadingRatePaletteNV(Packet_vkCmdSetViewportShadingRatePaletteNV* packet); + + void Replay_vkCmdSetCoarseSampleOrderNV(Packet_vkCmdSetCoarseSampleOrderNV* packet); + + void Replay_vkCreateAccelerationStructureNV(Packet_vkCreateAccelerationStructureNV* packet); + + void Replay_vkDestroyAccelerationStructureNV(Packet_vkDestroyAccelerationStructureNV* packet); + + void Replay_vkGetAccelerationStructureMemoryRequirementsNV(Packet_vkGetAccelerationStructureMemoryRequirementsNV* packet); + + void Replay_vkBindAccelerationStructureMemoryNV(Packet_vkBindAccelerationStructureMemoryNV* packet); + + void Replay_vkCmdBuildAccelerationStructureNV(Packet_vkCmdBuildAccelerationStructureNV* packet); + + void Replay_vkCmdCopyAccelerationStructureNV(Packet_vkCmdCopyAccelerationStructureNV* packet); + + void Replay_vkCmdTraceRaysNV(Packet_vkCmdTraceRaysNV* packet); + + void Replay_vkCreateRayTracingPipelinesNV(Packet_vkCreateRayTracingPipelinesNV* packet); + + void Replay_vkGetRayTracingShaderGroupHandlesKHR(Packet_vkGetRayTracingShaderGroupHandlesKHR* packet); + + void Replay_vkGetRayTracingShaderGroupHandlesNV(Packet_vkGetRayTracingShaderGroupHandlesNV* packet); + + void Replay_vkGetAccelerationStructureHandleNV(Packet_vkGetAccelerationStructureHandleNV* packet); + + void Replay_vkCmdWriteAccelerationStructuresPropertiesNV(Packet_vkCmdWriteAccelerationStructuresPropertiesNV* packet); + + void Replay_vkCompileDeferredNV(Packet_vkCompileDeferredNV* packet); + + void Replay_vkGetMemoryHostPointerPropertiesEXT(Packet_vkGetMemoryHostPointerPropertiesEXT* packet); + + void Replay_vkCmdWriteBufferMarkerAMD(Packet_vkCmdWriteBufferMarkerAMD* packet); + + void Replay_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(Packet_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT* packet); + + void Replay_vkGetCalibratedTimestampsEXT(Packet_vkGetCalibratedTimestampsEXT* packet); + + void Replay_vkCmdDrawMeshTasksNV(Packet_vkCmdDrawMeshTasksNV* packet); + + void Replay_vkCmdDrawMeshTasksIndirectNV(Packet_vkCmdDrawMeshTasksIndirectNV* packet); + + void Replay_vkCmdDrawMeshTasksIndirectCountNV(Packet_vkCmdDrawMeshTasksIndirectCountNV* packet); + + void Replay_vkCmdSetExclusiveScissorEnableNV(Packet_vkCmdSetExclusiveScissorEnableNV* packet); + + void Replay_vkCmdSetExclusiveScissorNV(Packet_vkCmdSetExclusiveScissorNV* packet); + + void Replay_vkCmdSetCheckpointNV(Packet_vkCmdSetCheckpointNV* packet); + + void Replay_vkGetQueueCheckpointDataNV(Packet_vkGetQueueCheckpointDataNV* packet); + + void Replay_vkInitializePerformanceApiINTEL(Packet_vkInitializePerformanceApiINTEL* packet); + + void Replay_vkUninitializePerformanceApiINTEL(Packet_vkUninitializePerformanceApiINTEL* packet); + + void Replay_vkCmdSetPerformanceMarkerINTEL(Packet_vkCmdSetPerformanceMarkerINTEL* packet); + + void Replay_vkCmdSetPerformanceStreamMarkerINTEL(Packet_vkCmdSetPerformanceStreamMarkerINTEL* packet); + + void Replay_vkCmdSetPerformanceOverrideINTEL(Packet_vkCmdSetPerformanceOverrideINTEL* packet); + + void Replay_vkAcquirePerformanceConfigurationINTEL(Packet_vkAcquirePerformanceConfigurationINTEL* packet); + + void Replay_vkReleasePerformanceConfigurationINTEL(Packet_vkReleasePerformanceConfigurationINTEL* packet); + + void Replay_vkQueueSetPerformanceConfigurationINTEL(Packet_vkQueueSetPerformanceConfigurationINTEL* packet); + + void Replay_vkGetPerformanceParameterINTEL(Packet_vkGetPerformanceParameterINTEL* packet); + + void Replay_vkSetLocalDimmingAMD(Packet_vkSetLocalDimmingAMD* packet); + + void Replay_vkCreateImagePipeSurfaceFUCHSIA(Packet_vkCreateImagePipeSurfaceFUCHSIA* packet); + + void Replay_vkCreateMetalSurfaceEXT(Packet_vkCreateMetalSurfaceEXT* packet); + + void Replay_vkGetBufferDeviceAddressEXT(Packet_vkGetBufferDeviceAddressEXT* packet); + + void Replay_vkGetPhysicalDeviceToolPropertiesEXT(Packet_vkGetPhysicalDeviceToolPropertiesEXT* packet); + + void Replay_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(Packet_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV* packet); + + void Replay_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(Packet_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV* packet); + + void Replay_vkGetPhysicalDeviceSurfacePresentModes2EXT(Packet_vkGetPhysicalDeviceSurfacePresentModes2EXT* packet); + + void Replay_vkAcquireFullScreenExclusiveModeEXT(Packet_vkAcquireFullScreenExclusiveModeEXT* packet); + + void Replay_vkReleaseFullScreenExclusiveModeEXT(Packet_vkReleaseFullScreenExclusiveModeEXT* packet); + + void Replay_vkGetDeviceGroupSurfacePresentModes2EXT(Packet_vkGetDeviceGroupSurfacePresentModes2EXT* packet); + + void Replay_vkCreateHeadlessSurfaceEXT(Packet_vkCreateHeadlessSurfaceEXT* packet); + + void Replay_vkCmdSetLineStippleEXT(Packet_vkCmdSetLineStippleEXT* packet); + + void Replay_vkResetQueryPoolEXT(Packet_vkResetQueryPoolEXT* packet); + + void Replay_vkCmdSetCullModeEXT(Packet_vkCmdSetCullModeEXT* packet); + + void Replay_vkCmdSetFrontFaceEXT(Packet_vkCmdSetFrontFaceEXT* packet); + + void Replay_vkCmdSetPrimitiveTopologyEXT(Packet_vkCmdSetPrimitiveTopologyEXT* packet); + + void Replay_vkCmdSetViewportWithCountEXT(Packet_vkCmdSetViewportWithCountEXT* packet); + + void Replay_vkCmdSetScissorWithCountEXT(Packet_vkCmdSetScissorWithCountEXT* packet); + + void Replay_vkCmdBindVertexBuffers2EXT(Packet_vkCmdBindVertexBuffers2EXT* packet); + + void Replay_vkCmdSetDepthTestEnableEXT(Packet_vkCmdSetDepthTestEnableEXT* packet); + + void Replay_vkCmdSetDepthWriteEnableEXT(Packet_vkCmdSetDepthWriteEnableEXT* packet); + + void Replay_vkCmdSetDepthCompareOpEXT(Packet_vkCmdSetDepthCompareOpEXT* packet); + + void Replay_vkCmdSetDepthBoundsTestEnableEXT(Packet_vkCmdSetDepthBoundsTestEnableEXT* packet); + + void Replay_vkCmdSetStencilTestEnableEXT(Packet_vkCmdSetStencilTestEnableEXT* packet); + + void Replay_vkCmdSetStencilOpEXT(Packet_vkCmdSetStencilOpEXT* packet); + + void Replay_vkCopyMemoryToImageEXT(Packet_vkCopyMemoryToImageEXT* packet); + + void Replay_vkCopyImageToMemoryEXT(Packet_vkCopyImageToMemoryEXT* packet); + + void Replay_vkCopyImageToImageEXT(Packet_vkCopyImageToImageEXT* packet); + + void Replay_vkTransitionImageLayoutEXT(Packet_vkTransitionImageLayoutEXT* packet); + + void Replay_vkGetImageSubresourceLayout2EXT(Packet_vkGetImageSubresourceLayout2EXT* packet); + + void Replay_vkReleaseSwapchainImagesEXT(Packet_vkReleaseSwapchainImagesEXT* packet); + + void Replay_vkGetGeneratedCommandsMemoryRequirementsNV(Packet_vkGetGeneratedCommandsMemoryRequirementsNV* packet); + + void Replay_vkCmdPreprocessGeneratedCommandsNV(Packet_vkCmdPreprocessGeneratedCommandsNV* packet); + + void Replay_vkCmdExecuteGeneratedCommandsNV(Packet_vkCmdExecuteGeneratedCommandsNV* packet); + + void Replay_vkCmdBindPipelineShaderGroupNV(Packet_vkCmdBindPipelineShaderGroupNV* packet); + + void Replay_vkCreateIndirectCommandsLayoutNV(Packet_vkCreateIndirectCommandsLayoutNV* packet); + + void Replay_vkDestroyIndirectCommandsLayoutNV(Packet_vkDestroyIndirectCommandsLayoutNV* packet); + + void Replay_vkCmdSetDepthBias2EXT(Packet_vkCmdSetDepthBias2EXT* packet); + + void Replay_vkAcquireDrmDisplayEXT(Packet_vkAcquireDrmDisplayEXT* packet); + + void Replay_vkGetDrmDisplayEXT(Packet_vkGetDrmDisplayEXT* packet); + + void Replay_vkCreatePrivateDataSlotEXT(Packet_vkCreatePrivateDataSlotEXT* packet); + + void Replay_vkDestroyPrivateDataSlotEXT(Packet_vkDestroyPrivateDataSlotEXT* packet); + + void Replay_vkSetPrivateDataEXT(Packet_vkSetPrivateDataEXT* packet); + + void Replay_vkGetPrivateDataEXT(Packet_vkGetPrivateDataEXT* packet); + + void Replay_vkCmdSetFragmentShadingRateEnumNV(Packet_vkCmdSetFragmentShadingRateEnumNV* packet); + + void Replay_vkGetDeviceFaultInfoEXT(Packet_vkGetDeviceFaultInfoEXT* packet); + + void Replay_vkAcquireWinrtDisplayNV(Packet_vkAcquireWinrtDisplayNV* packet); + + void Replay_vkGetWinrtDisplayNV(Packet_vkGetWinrtDisplayNV* packet); + + void Replay_vkCreateDirectFBSurfaceEXT(Packet_vkCreateDirectFBSurfaceEXT* packet); + + void Replay_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(Packet_vkGetPhysicalDeviceDirectFBPresentationSupportEXT* packet); + + void Replay_vkCmdSetVertexInputEXT(Packet_vkCmdSetVertexInputEXT* packet); + + void Replay_vkGetMemoryZirconHandleFUCHSIA(Packet_vkGetMemoryZirconHandleFUCHSIA* packet); + + void Replay_vkGetMemoryZirconHandlePropertiesFUCHSIA(Packet_vkGetMemoryZirconHandlePropertiesFUCHSIA* packet); + + void Replay_vkImportSemaphoreZirconHandleFUCHSIA(Packet_vkImportSemaphoreZirconHandleFUCHSIA* packet); + + void Replay_vkGetSemaphoreZirconHandleFUCHSIA(Packet_vkGetSemaphoreZirconHandleFUCHSIA* packet); + + void Replay_vkCmdBindInvocationMaskHUAWEI(Packet_vkCmdBindInvocationMaskHUAWEI* packet); + + void Replay_vkGetMemoryRemoteAddressNV(Packet_vkGetMemoryRemoteAddressNV* packet); + + void Replay_vkCmdSetPatchControlPointsEXT(Packet_vkCmdSetPatchControlPointsEXT* packet); + + void Replay_vkCmdSetRasterizerDiscardEnableEXT(Packet_vkCmdSetRasterizerDiscardEnableEXT* packet); + + void Replay_vkCmdSetDepthBiasEnableEXT(Packet_vkCmdSetDepthBiasEnableEXT* packet); + + void Replay_vkCmdSetLogicOpEXT(Packet_vkCmdSetLogicOpEXT* packet); + + void Replay_vkCmdSetPrimitiveRestartEnableEXT(Packet_vkCmdSetPrimitiveRestartEnableEXT* packet); + + void Replay_vkCreateScreenSurfaceQNX(Packet_vkCreateScreenSurfaceQNX* packet); + + void Replay_vkGetPhysicalDeviceScreenPresentationSupportQNX(Packet_vkGetPhysicalDeviceScreenPresentationSupportQNX* packet); + + void Replay_vkCmdSetColorWriteEnableEXT(Packet_vkCmdSetColorWriteEnableEXT* packet); + + void Replay_vkCmdDrawMultiEXT(Packet_vkCmdDrawMultiEXT* packet); + + void Replay_vkCmdDrawMultiIndexedEXT(Packet_vkCmdDrawMultiIndexedEXT* packet); + + void Replay_vkCreateMicromapEXT(Packet_vkCreateMicromapEXT* packet); + + void Replay_vkDestroyMicromapEXT(Packet_vkDestroyMicromapEXT* packet); + + void Replay_vkCmdBuildMicromapsEXT(Packet_vkCmdBuildMicromapsEXT* packet); + + void Replay_vkBuildMicromapsEXT(Packet_vkBuildMicromapsEXT* packet); + + void Replay_vkCopyMicromapEXT(Packet_vkCopyMicromapEXT* packet); + + void Replay_vkCopyMicromapToMemoryEXT(Packet_vkCopyMicromapToMemoryEXT* packet); + + void Replay_vkCopyMemoryToMicromapEXT(Packet_vkCopyMemoryToMicromapEXT* packet); + + void Replay_vkWriteMicromapsPropertiesEXT(Packet_vkWriteMicromapsPropertiesEXT* packet); + + void Replay_vkCmdCopyMicromapEXT(Packet_vkCmdCopyMicromapEXT* packet); + + void Replay_vkCmdCopyMicromapToMemoryEXT(Packet_vkCmdCopyMicromapToMemoryEXT* packet); + + void Replay_vkCmdCopyMemoryToMicromapEXT(Packet_vkCmdCopyMemoryToMicromapEXT* packet); + + void Replay_vkCmdWriteMicromapsPropertiesEXT(Packet_vkCmdWriteMicromapsPropertiesEXT* packet); + + void Replay_vkGetDeviceMicromapCompatibilityEXT(Packet_vkGetDeviceMicromapCompatibilityEXT* packet); + + void Replay_vkGetMicromapBuildSizesEXT(Packet_vkGetMicromapBuildSizesEXT* packet); + + void Replay_vkCmdDrawClusterHUAWEI(Packet_vkCmdDrawClusterHUAWEI* packet); + + void Replay_vkCmdDrawClusterIndirectHUAWEI(Packet_vkCmdDrawClusterIndirectHUAWEI* packet); + + void Replay_vkSetDeviceMemoryPriorityEXT(Packet_vkSetDeviceMemoryPriorityEXT* packet); + + void Replay_vkGetDescriptorSetLayoutHostMappingInfoVALVE(Packet_vkGetDescriptorSetLayoutHostMappingInfoVALVE* packet); + + void Replay_vkGetDescriptorSetHostMappingVALVE(Packet_vkGetDescriptorSetHostMappingVALVE* packet); + + void Replay_vkGetPipelineIndirectMemoryRequirementsNV(Packet_vkGetPipelineIndirectMemoryRequirementsNV* packet); + + void Replay_vkCmdUpdatePipelineIndirectBufferNV(Packet_vkCmdUpdatePipelineIndirectBufferNV* packet); + + void Replay_vkGetPipelineIndirectDeviceAddressNV(Packet_vkGetPipelineIndirectDeviceAddressNV* packet); + + void Replay_vkCmdSetDepthClampEnableEXT(Packet_vkCmdSetDepthClampEnableEXT* packet); + + void Replay_vkCmdSetPolygonModeEXT(Packet_vkCmdSetPolygonModeEXT* packet); + + void Replay_vkCmdSetRasterizationSamplesEXT(Packet_vkCmdSetRasterizationSamplesEXT* packet); + + void Replay_vkCmdSetSampleMaskEXT(Packet_vkCmdSetSampleMaskEXT* packet); + + void Replay_vkCmdSetAlphaToCoverageEnableEXT(Packet_vkCmdSetAlphaToCoverageEnableEXT* packet); + + void Replay_vkCmdSetAlphaToOneEnableEXT(Packet_vkCmdSetAlphaToOneEnableEXT* packet); + + void Replay_vkCmdSetLogicOpEnableEXT(Packet_vkCmdSetLogicOpEnableEXT* packet); + + void Replay_vkCmdSetColorBlendEnableEXT(Packet_vkCmdSetColorBlendEnableEXT* packet); + + void Replay_vkCmdSetColorBlendEquationEXT(Packet_vkCmdSetColorBlendEquationEXT* packet); + + void Replay_vkCmdSetColorWriteMaskEXT(Packet_vkCmdSetColorWriteMaskEXT* packet); + + void Replay_vkCmdSetTessellationDomainOriginEXT(Packet_vkCmdSetTessellationDomainOriginEXT* packet); + + void Replay_vkCmdSetRasterizationStreamEXT(Packet_vkCmdSetRasterizationStreamEXT* packet); + + void Replay_vkCmdSetConservativeRasterizationModeEXT(Packet_vkCmdSetConservativeRasterizationModeEXT* packet); + + void Replay_vkCmdSetExtraPrimitiveOverestimationSizeEXT(Packet_vkCmdSetExtraPrimitiveOverestimationSizeEXT* packet); + + void Replay_vkCmdSetDepthClipEnableEXT(Packet_vkCmdSetDepthClipEnableEXT* packet); + + void Replay_vkCmdSetSampleLocationsEnableEXT(Packet_vkCmdSetSampleLocationsEnableEXT* packet); + + void Replay_vkCmdSetColorBlendAdvancedEXT(Packet_vkCmdSetColorBlendAdvancedEXT* packet); + + void Replay_vkCmdSetProvokingVertexModeEXT(Packet_vkCmdSetProvokingVertexModeEXT* packet); + + void Replay_vkCmdSetLineRasterizationModeEXT(Packet_vkCmdSetLineRasterizationModeEXT* packet); + + void Replay_vkCmdSetLineStippleEnableEXT(Packet_vkCmdSetLineStippleEnableEXT* packet); + + void Replay_vkCmdSetDepthClipNegativeOneToOneEXT(Packet_vkCmdSetDepthClipNegativeOneToOneEXT* packet); + + void Replay_vkCmdSetViewportWScalingEnableNV(Packet_vkCmdSetViewportWScalingEnableNV* packet); + + void Replay_vkCmdSetViewportSwizzleNV(Packet_vkCmdSetViewportSwizzleNV* packet); + + void Replay_vkCmdSetCoverageToColorEnableNV(Packet_vkCmdSetCoverageToColorEnableNV* packet); + + void Replay_vkCmdSetCoverageToColorLocationNV(Packet_vkCmdSetCoverageToColorLocationNV* packet); + + void Replay_vkCmdSetCoverageModulationModeNV(Packet_vkCmdSetCoverageModulationModeNV* packet); + + void Replay_vkCmdSetCoverageModulationTableEnableNV(Packet_vkCmdSetCoverageModulationTableEnableNV* packet); + + void Replay_vkCmdSetCoverageModulationTableNV(Packet_vkCmdSetCoverageModulationTableNV* packet); + + void Replay_vkCmdSetShadingRateImageEnableNV(Packet_vkCmdSetShadingRateImageEnableNV* packet); + + void Replay_vkCmdSetRepresentativeFragmentTestEnableNV(Packet_vkCmdSetRepresentativeFragmentTestEnableNV* packet); + + void Replay_vkCmdSetCoverageReductionModeNV(Packet_vkCmdSetCoverageReductionModeNV* packet); + + void Replay_vkGetShaderModuleIdentifierEXT(Packet_vkGetShaderModuleIdentifierEXT* packet); + + void Replay_vkGetShaderModuleCreateInfoIdentifierEXT(Packet_vkGetShaderModuleCreateInfoIdentifierEXT* packet); + + void Replay_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(Packet_vkGetPhysicalDeviceOpticalFlowImageFormatsNV* packet); + + void Replay_vkCreateOpticalFlowSessionNV(Packet_vkCreateOpticalFlowSessionNV* packet); + + void Replay_vkDestroyOpticalFlowSessionNV(Packet_vkDestroyOpticalFlowSessionNV* packet); + + void Replay_vkBindOpticalFlowSessionImageNV(Packet_vkBindOpticalFlowSessionImageNV* packet); + + void Replay_vkCmdOpticalFlowExecuteNV(Packet_vkCmdOpticalFlowExecuteNV* packet); + + void Replay_vkCreateShadersEXT(Packet_vkCreateShadersEXT* packet); + + void Replay_vkDestroyShaderEXT(Packet_vkDestroyShaderEXT* packet); + + void Replay_vkGetShaderBinaryDataEXT(Packet_vkGetShaderBinaryDataEXT* packet); + + void Replay_vkCmdBindShadersEXT(Packet_vkCmdBindShadersEXT* packet); + + void Replay_vkGetFramebufferTilePropertiesQCOM(Packet_vkGetFramebufferTilePropertiesQCOM* packet); + + void Replay_vkGetDynamicRenderingTilePropertiesQCOM(Packet_vkGetDynamicRenderingTilePropertiesQCOM* packet); + + void Replay_vkSetLatencySleepModeNV(Packet_vkSetLatencySleepModeNV* packet); + + void Replay_vkLatencySleepNV(Packet_vkLatencySleepNV* packet); + + void Replay_vkSetLatencyMarkerNV(Packet_vkSetLatencyMarkerNV* packet); + + void Replay_vkGetLatencyTimingsNV(Packet_vkGetLatencyTimingsNV* packet); + + void Replay_vkQueueNotifyOutOfBandNV(Packet_vkQueueNotifyOutOfBandNV* packet); + + void Replay_vkCmdSetAttachmentFeedbackLoopEnableEXT(Packet_vkCmdSetAttachmentFeedbackLoopEnableEXT* packet); + + void Replay_vkCreateAccelerationStructureKHR(Packet_vkCreateAccelerationStructureKHR* packet); + + void Replay_vkDestroyAccelerationStructureKHR(Packet_vkDestroyAccelerationStructureKHR* packet); + + void Replay_vkCmdBuildAccelerationStructuresKHR(Packet_vkCmdBuildAccelerationStructuresKHR* packet); + + void Replay_vkCmdBuildAccelerationStructuresIndirectKHR(Packet_vkCmdBuildAccelerationStructuresIndirectKHR* packet); + + void Replay_vkCopyAccelerationStructureToMemoryKHR(Packet_vkCopyAccelerationStructureToMemoryKHR* packet); + + void Replay_vkCopyMemoryToAccelerationStructureKHR(Packet_vkCopyMemoryToAccelerationStructureKHR* packet); + + void Replay_vkWriteAccelerationStructuresPropertiesKHR(Packet_vkWriteAccelerationStructuresPropertiesKHR* packet); + + void Replay_vkCmdCopyAccelerationStructureKHR(Packet_vkCmdCopyAccelerationStructureKHR* packet); + + void Replay_vkCmdCopyAccelerationStructureToMemoryKHR(Packet_vkCmdCopyAccelerationStructureToMemoryKHR* packet); + + void Replay_vkCmdCopyMemoryToAccelerationStructureKHR(Packet_vkCmdCopyMemoryToAccelerationStructureKHR* packet); + + void Replay_vkGetAccelerationStructureDeviceAddressKHR(Packet_vkGetAccelerationStructureDeviceAddressKHR* packet); + + void Replay_vkCmdWriteAccelerationStructuresPropertiesKHR(Packet_vkCmdWriteAccelerationStructuresPropertiesKHR* packet); + + void Replay_vkGetDeviceAccelerationStructureCompatibilityKHR(Packet_vkGetDeviceAccelerationStructureCompatibilityKHR* packet); + + void Replay_vkGetAccelerationStructureBuildSizesKHR(Packet_vkGetAccelerationStructureBuildSizesKHR* packet); + + void Replay_vkCmdTraceRaysKHR(Packet_vkCmdTraceRaysKHR* packet); + + void Replay_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(Packet_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR* packet); + + void Replay_vkCmdTraceRaysIndirectKHR(Packet_vkCmdTraceRaysIndirectKHR* packet); + + void Replay_vkGetRayTracingShaderGroupStackSizeKHR(Packet_vkGetRayTracingShaderGroupStackSizeKHR* packet); + + void Replay_vkCmdSetRayTracingPipelineStackSizeKHR(Packet_vkCmdSetRayTracingPipelineStackSizeKHR* packet); + + void Replay_vkCmdDrawMeshTasksEXT(Packet_vkCmdDrawMeshTasksEXT* packet); + + void Replay_vkCmdDrawMeshTasksIndirectEXT(Packet_vkCmdDrawMeshTasksIndirectEXT* packet); + + void Replay_vkCmdDrawMeshTasksIndirectCountEXT(Packet_vkCmdDrawMeshTasksIndirectCountEXT* packet); +}; + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) + +#endif diff --git a/framework/generated/generated_vulkan_struct_decoders.cpp b/framework/generated/generated_vulkan_struct_decoders.cpp index 7005d0a697..4a1b7e058f 100644 --- a/framework/generated/generated_vulkan_struct_decoders.cpp +++ b/framework/generated/generated_vulkan_struct_decoders.cpp @@ -39,6 +39,8 @@ GFXRECON_BEGIN_NAMESPACE(decode) size_t DecodePNextStruct(const uint8_t* buffer, size_t buffer_size, PNextNode** pNext); +size_t PreloadDecodePNextStruct(const uint8_t* buffer, size_t buffer_size, PNextNode** pNext); + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH264SpsVuiFlags* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -4606,146 +4608,4713 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderP return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH264SpsVuiFlags* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSubgroupProperties* value = wrapper->decoded_value; + StdVideoH264SpsVuiFlags* 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->subgroupSize)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedStages)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedOperations)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->quadOperationsInAllStages)); + uint32_t temp_aspect_ratio_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_aspect_ratio_info_present_flag); + value->aspect_ratio_info_present_flag = temp_aspect_ratio_info_present_flag; + uint32_t temp_overscan_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_overscan_info_present_flag); + value->overscan_info_present_flag = temp_overscan_info_present_flag; + uint32_t temp_overscan_appropriate_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_overscan_appropriate_flag); + value->overscan_appropriate_flag = temp_overscan_appropriate_flag; + uint32_t temp_video_signal_type_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_video_signal_type_present_flag); + value->video_signal_type_present_flag = temp_video_signal_type_present_flag; + uint32_t temp_video_full_range_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_video_full_range_flag); + value->video_full_range_flag = temp_video_full_range_flag; + uint32_t temp_color_description_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_color_description_present_flag); + value->color_description_present_flag = temp_color_description_present_flag; + uint32_t temp_chroma_loc_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_chroma_loc_info_present_flag); + value->chroma_loc_info_present_flag = temp_chroma_loc_info_present_flag; + uint32_t temp_timing_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_timing_info_present_flag); + value->timing_info_present_flag = temp_timing_info_present_flag; + uint32_t temp_fixed_frame_rate_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_fixed_frame_rate_flag); + value->fixed_frame_rate_flag = temp_fixed_frame_rate_flag; + uint32_t temp_bitstream_restriction_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_bitstream_restriction_flag); + value->bitstream_restriction_flag = temp_bitstream_restriction_flag; + uint32_t temp_nal_hrd_parameters_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_nal_hrd_parameters_present_flag); + value->nal_hrd_parameters_present_flag = temp_nal_hrd_parameters_present_flag; + uint32_t temp_vcl_hrd_parameters_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vcl_hrd_parameters_present_flag); + value->vcl_hrd_parameters_present_flag = temp_vcl_hrd_parameters_present_flag; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindBufferMemoryInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH264HrdParameters* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindBufferMemoryInfo* value = wrapper->decoded_value; + StdVideoH264HrdParameters* 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->buffer)); - value->buffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); - value->memory = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cpb_cnt_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bit_rate_scale)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cpb_size_scale)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + wrapper->bit_rate_value_minus1.SetExternalMemory(value->bit_rate_value_minus1, STD_VIDEO_H264_CPB_CNT_LIST_SIZE); + bytes_read += wrapper->bit_rate_value_minus1.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->cpb_size_value_minus1.SetExternalMemory(value->cpb_size_value_minus1, STD_VIDEO_H264_CPB_CNT_LIST_SIZE); + bytes_read += wrapper->cpb_size_value_minus1.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->cbr_flag.SetExternalMemory(value->cbr_flag, STD_VIDEO_H264_CPB_CNT_LIST_SIZE); + bytes_read += wrapper->cbr_flag.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->initial_cpb_removal_delay_length_minus1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cpb_removal_delay_length_minus1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dpb_output_delay_length_minus1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->time_offset_length)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImageMemoryInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH264SequenceParameterSetVui* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindImageMemoryInfo* value = wrapper->decoded_value; + StdVideoH264SequenceParameterSetVui* 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->memory)); - value->memory = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspect_ratio_idc)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sar_width)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sar_height)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->video_format)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colour_primaries)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transfer_characteristics)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->matrix_coefficients)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_units_in_tick)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->time_scale)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_num_reorder_frames)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_dec_frame_buffering)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_sample_loc_type_top_field)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_sample_loc_type_bottom_field)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + wrapper->pHrdParameters = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pHrdParameters->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pHrdParameters = wrapper->pHrdParameters->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevice16BitStorageFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH264SpsFlags* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevice16BitStorageFeatures* value = wrapper->decoded_value; + StdVideoH264SpsFlags* 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->storageBuffer16BitAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer16BitAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageInputOutput16)); + uint32_t temp_constraint_set0_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_constraint_set0_flag); + value->constraint_set0_flag = temp_constraint_set0_flag; + uint32_t temp_constraint_set1_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_constraint_set1_flag); + value->constraint_set1_flag = temp_constraint_set1_flag; + uint32_t temp_constraint_set2_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_constraint_set2_flag); + value->constraint_set2_flag = temp_constraint_set2_flag; + uint32_t temp_constraint_set3_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_constraint_set3_flag); + value->constraint_set3_flag = temp_constraint_set3_flag; + uint32_t temp_constraint_set4_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_constraint_set4_flag); + value->constraint_set4_flag = temp_constraint_set4_flag; + uint32_t temp_constraint_set5_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_constraint_set5_flag); + value->constraint_set5_flag = temp_constraint_set5_flag; + uint32_t temp_direct_8x8_inference_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_direct_8x8_inference_flag); + value->direct_8x8_inference_flag = temp_direct_8x8_inference_flag; + uint32_t temp_mb_adaptive_frame_field_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mb_adaptive_frame_field_flag); + value->mb_adaptive_frame_field_flag = temp_mb_adaptive_frame_field_flag; + uint32_t temp_frame_mbs_only_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_frame_mbs_only_flag); + value->frame_mbs_only_flag = temp_frame_mbs_only_flag; + uint32_t temp_delta_pic_order_always_zero_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_delta_pic_order_always_zero_flag); + value->delta_pic_order_always_zero_flag = temp_delta_pic_order_always_zero_flag; + uint32_t temp_separate_colour_plane_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_separate_colour_plane_flag); + value->separate_colour_plane_flag = temp_separate_colour_plane_flag; + uint32_t temp_gaps_in_frame_num_value_allowed_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_gaps_in_frame_num_value_allowed_flag); + value->gaps_in_frame_num_value_allowed_flag = temp_gaps_in_frame_num_value_allowed_flag; + uint32_t temp_qpprime_y_zero_transform_bypass_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_qpprime_y_zero_transform_bypass_flag); + value->qpprime_y_zero_transform_bypass_flag = temp_qpprime_y_zero_transform_bypass_flag; + uint32_t temp_frame_cropping_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_frame_cropping_flag); + value->frame_cropping_flag = temp_frame_cropping_flag; + uint32_t temp_seq_scaling_matrix_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_seq_scaling_matrix_present_flag); + value->seq_scaling_matrix_present_flag = temp_seq_scaling_matrix_present_flag; + uint32_t temp_vui_parameters_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vui_parameters_present_flag); + value->vui_parameters_present_flag = temp_vui_parameters_present_flag; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryDedicatedRequirements* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH264ScalingLists* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryDedicatedRequirements* value = wrapper->decoded_value; + StdVideoH264ScalingLists* 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->prefersDedicatedAllocation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiresDedicatedAllocation)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->scaling_list_present_mask)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->use_default_scaling_matrix_mask)); + wrapper->ScalingList4x4.SetExternalMemory(value->ScalingList4x4, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS); + bytes_read += wrapper->ScalingList4x4.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ScalingList8x8.SetExternalMemory(value->ScalingList8x8, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS); + bytes_read += wrapper->ScalingList8x8.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryDedicatedAllocateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH264SequenceParameterSet* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryDedicatedAllocateInfo* value = wrapper->decoded_value; + StdVideoH264SequenceParameterSet* 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->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->profile_idc)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->level_idc)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_format_idc)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->seq_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bit_depth_luma_minus8)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bit_depth_chroma_minus8)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_max_frame_num_minus4)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_order_cnt_type)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset_for_non_ref_pic)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset_for_top_to_bottom_field)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_max_pic_order_cnt_lsb_minus4)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ref_frames_in_pic_order_cnt_cycle)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_num_ref_frames)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_width_in_mbs_minus1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_height_in_map_units_minus1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_crop_left_offset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_crop_right_offset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_crop_top_offset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_crop_bottom_offset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved2)); + bytes_read += wrapper->pOffsetForRefFrame.PreloadDecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pOffsetForRefFrame = wrapper->pOffsetForRefFrame.GetPointer(); + wrapper->pScalingLists = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pScalingLists->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pScalingLists = wrapper->pScalingLists->GetPointer(); + wrapper->pSequenceParameterSetVui = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSequenceParameterSetVui->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSequenceParameterSetVui = wrapper->pSequenceParameterSetVui->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryAllocateFlagsInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH264PpsFlags* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryAllocateFlagsInfo* value = wrapper->decoded_value; + StdVideoH264PpsFlags* 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->deviceMask)); + uint32_t temp_transform_8x8_mode_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_transform_8x8_mode_flag); + value->transform_8x8_mode_flag = temp_transform_8x8_mode_flag; + uint32_t temp_redundant_pic_cnt_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_redundant_pic_cnt_present_flag); + value->redundant_pic_cnt_present_flag = temp_redundant_pic_cnt_present_flag; + uint32_t temp_constrained_intra_pred_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_constrained_intra_pred_flag); + value->constrained_intra_pred_flag = temp_constrained_intra_pred_flag; + uint32_t temp_deblocking_filter_control_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_deblocking_filter_control_present_flag); + value->deblocking_filter_control_present_flag = temp_deblocking_filter_control_present_flag; + uint32_t temp_weighted_pred_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_weighted_pred_flag); + value->weighted_pred_flag = temp_weighted_pred_flag; + uint32_t temp_bottom_field_pic_order_in_frame_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_bottom_field_pic_order_in_frame_present_flag); + value->bottom_field_pic_order_in_frame_present_flag = temp_bottom_field_pic_order_in_frame_present_flag; + uint32_t temp_entropy_coding_mode_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_entropy_coding_mode_flag); + value->entropy_coding_mode_flag = temp_entropy_coding_mode_flag; + uint32_t temp_pic_scaling_matrix_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pic_scaling_matrix_present_flag); + value->pic_scaling_matrix_present_flag = temp_pic_scaling_matrix_present_flag; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupRenderPassBeginInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH264PictureParameterSet* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceGroupRenderPassBeginInfo* value = wrapper->decoded_value; + StdVideoH264PictureParameterSet* 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->deviceMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceRenderAreaCount)); - wrapper->pDeviceRenderAreas = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDeviceRenderAreas->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDeviceRenderAreas = wrapper->pDeviceRenderAreas->GetPointer(); + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->seq_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ref_idx_l0_default_active_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ref_idx_l1_default_active_minus1)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->weighted_bipred_idc)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_init_qp_minus26)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_init_qs_minus26)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_qp_index_offset)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->second_chroma_qp_index_offset)); + wrapper->pScalingLists = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pScalingLists->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pScalingLists = wrapper->pScalingLists->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeH264PictureInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeH264PictureInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_field_pic_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_field_pic_flag); + value->field_pic_flag = temp_field_pic_flag; + uint32_t temp_is_intra; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_is_intra); + value->is_intra = temp_is_intra; + uint32_t temp_IdrPicFlag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_IdrPicFlag); + value->IdrPicFlag = temp_IdrPicFlag; + uint32_t temp_bottom_field_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_bottom_field_flag); + value->bottom_field_flag = temp_bottom_field_flag; + uint32_t temp_is_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_is_reference); + value->is_reference = temp_is_reference; + uint32_t temp_complementary_field_pair; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_complementary_field_pair); + value->complementary_field_pair = temp_complementary_field_pair; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeH264PictureInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeH264PictureInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->seq_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved2)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_num)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->idr_pic_id)); + wrapper->PicOrderCnt.SetExternalMemory(value->PicOrderCnt, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE); + bytes_read += wrapper->PicOrderCnt.PreloadDecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeH264ReferenceInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeH264ReferenceInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_top_field_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_top_field_flag); + value->top_field_flag = temp_top_field_flag; + uint32_t temp_bottom_field_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_bottom_field_flag); + value->bottom_field_flag = temp_bottom_field_flag; + uint32_t temp_used_for_long_term_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_used_for_long_term_reference); + value->used_for_long_term_reference = temp_used_for_long_term_reference; + uint32_t temp_is_non_existing; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_is_non_existing); + value->is_non_existing = temp_is_non_existing; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeH264ReferenceInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeH264ReferenceInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->FrameNum)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved)); + wrapper->PicOrderCnt.SetExternalMemory(value->PicOrderCnt, STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE); + bytes_read += wrapper->PicOrderCnt.PreloadDecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264WeightTableFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264WeightTableFlags* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->luma_weight_l0_flag)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_weight_l0_flag)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->luma_weight_l1_flag)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_weight_l1_flag)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264WeightTable* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264WeightTable* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->luma_log2_weight_denom)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_log2_weight_denom)); + wrapper->luma_weight_l0.SetExternalMemory(value->luma_weight_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF); + bytes_read += wrapper->luma_weight_l0.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->luma_offset_l0.SetExternalMemory(value->luma_offset_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF); + bytes_read += wrapper->luma_offset_l0.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->chroma_weight_l0.SetExternalMemory(value->chroma_weight_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES); + bytes_read += wrapper->chroma_weight_l0.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->chroma_offset_l0.SetExternalMemory(value->chroma_offset_l0, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES); + bytes_read += wrapper->chroma_offset_l0.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->luma_weight_l1.SetExternalMemory(value->luma_weight_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF); + bytes_read += wrapper->luma_weight_l1.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->luma_offset_l1.SetExternalMemory(value->luma_offset_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF); + bytes_read += wrapper->luma_offset_l1.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->chroma_weight_l1.SetExternalMemory(value->chroma_weight_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES); + bytes_read += wrapper->chroma_weight_l1.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->chroma_offset_l1.SetExternalMemory(value->chroma_offset_l1, STD_VIDEO_H264_MAX_NUM_LIST_REF, STD_VIDEO_H264_MAX_CHROMA_PLANES); + bytes_read += wrapper->chroma_offset_l1.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264SliceHeaderFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264SliceHeaderFlags* value = wrapper->decoded_value; + + uint32_t temp_direct_spatial_mv_pred_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_direct_spatial_mv_pred_flag); + value->direct_spatial_mv_pred_flag = temp_direct_spatial_mv_pred_flag; + uint32_t temp_num_ref_idx_active_override_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_num_ref_idx_active_override_flag); + value->num_ref_idx_active_override_flag = temp_num_ref_idx_active_override_flag; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264PictureInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264PictureInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_IdrPicFlag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_IdrPicFlag); + value->IdrPicFlag = temp_IdrPicFlag; + uint32_t temp_is_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_is_reference); + value->is_reference = temp_is_reference; + uint32_t temp_no_output_of_prior_pics_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_no_output_of_prior_pics_flag); + value->no_output_of_prior_pics_flag = temp_no_output_of_prior_pics_flag; + uint32_t temp_long_term_reference_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_long_term_reference_flag); + value->long_term_reference_flag = temp_long_term_reference_flag; + uint32_t temp_adaptive_ref_pic_marking_mode_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_adaptive_ref_pic_marking_mode_flag); + value->adaptive_ref_pic_marking_mode_flag = temp_adaptive_ref_pic_marking_mode_flag; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264ReferenceInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264ReferenceInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_used_for_long_term_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_used_for_long_term_reference); + value->used_for_long_term_reference = temp_used_for_long_term_reference; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264ReferenceListsInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264ReferenceListsInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_ref_pic_list_modification_flag_l0; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_ref_pic_list_modification_flag_l0); + value->ref_pic_list_modification_flag_l0 = temp_ref_pic_list_modification_flag_l0; + uint32_t temp_ref_pic_list_modification_flag_l1; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_ref_pic_list_modification_flag_l1); + value->ref_pic_list_modification_flag_l1 = temp_ref_pic_list_modification_flag_l1; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264RefListModEntry* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264RefListModEntry* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->modification_of_pic_nums_idc)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->abs_diff_pic_num_minus1)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->long_term_pic_num)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264RefPicMarkingEntry* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264RefPicMarkingEntry* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->memory_management_control_operation)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->difference_of_pic_nums_minus1)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->long_term_pic_num)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->long_term_frame_idx)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_long_term_frame_idx_plus1)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264ReferenceListsInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264ReferenceListsInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ref_idx_l0_active_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ref_idx_l1_active_minus1)); + wrapper->RefPicList0.SetExternalMemory(value->RefPicList0, STD_VIDEO_H264_MAX_NUM_LIST_REF); + bytes_read += wrapper->RefPicList0.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->RefPicList1.SetExternalMemory(value->RefPicList1, STD_VIDEO_H264_MAX_NUM_LIST_REF); + bytes_read += wrapper->RefPicList1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refList0ModOpCount)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refList1ModOpCount)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refPicMarkingOpCount)); + wrapper->reserved1.SetExternalMemory(value->reserved1, 7); + bytes_read += wrapper->reserved1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pRefList0ModOperations = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRefList0ModOperations->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRefList0ModOperations = wrapper->pRefList0ModOperations->GetPointer(); + wrapper->pRefList1ModOperations = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRefList1ModOperations->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRefList1ModOperations = wrapper->pRefList1ModOperations->GetPointer(); + wrapper->pRefPicMarkingOperations = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRefPicMarkingOperations->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRefPicMarkingOperations = wrapper->pRefPicMarkingOperations->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264PictureInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264PictureInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->seq_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->idr_pic_id)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->primary_pic_type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_num)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->PicOrderCnt)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->temporal_id)); + wrapper->reserved1.SetExternalMemory(value->reserved1, 3); + bytes_read += wrapper->reserved1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pRefLists = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRefLists->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRefLists = wrapper->pRefLists->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264ReferenceInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264ReferenceInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->primary_pic_type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->FrameNum)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->PicOrderCnt)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->long_term_pic_num)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->long_term_frame_idx)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->temporal_id)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH264SliceHeader* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH264SliceHeader* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->first_mb_in_slice)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_type)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_alpha_c0_offset_div2)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_beta_offset_div2)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_qp_delta)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->cabac_init_idc)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->disable_deblocking_filter_idc)); + wrapper->pWeightTable = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pWeightTable->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWeightTable = wrapper->pWeightTable->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265ProfileTierLevelFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265ProfileTierLevelFlags* value = wrapper->decoded_value; + + uint32_t temp_general_tier_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_general_tier_flag); + value->general_tier_flag = temp_general_tier_flag; + uint32_t temp_general_progressive_source_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_general_progressive_source_flag); + value->general_progressive_source_flag = temp_general_progressive_source_flag; + uint32_t temp_general_interlaced_source_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_general_interlaced_source_flag); + value->general_interlaced_source_flag = temp_general_interlaced_source_flag; + uint32_t temp_general_non_packed_constraint_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_general_non_packed_constraint_flag); + value->general_non_packed_constraint_flag = temp_general_non_packed_constraint_flag; + uint32_t temp_general_frame_only_constraint_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_general_frame_only_constraint_flag); + value->general_frame_only_constraint_flag = temp_general_frame_only_constraint_flag; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265ProfileTierLevel* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265ProfileTierLevel* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->general_profile_idc)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->general_level_idc)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265DecPicBufMgr* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265DecPicBufMgr* value = wrapper->decoded_value; + + wrapper->max_latency_increase_plus1.SetExternalMemory(value->max_latency_increase_plus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE); + bytes_read += wrapper->max_latency_increase_plus1.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->max_dec_pic_buffering_minus1.SetExternalMemory(value->max_dec_pic_buffering_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE); + bytes_read += wrapper->max_dec_pic_buffering_minus1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->max_num_reorder_pics.SetExternalMemory(value->max_num_reorder_pics, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE); + bytes_read += wrapper->max_num_reorder_pics.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265SubLayerHrdParameters* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265SubLayerHrdParameters* value = wrapper->decoded_value; + + wrapper->bit_rate_value_minus1.SetExternalMemory(value->bit_rate_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE); + bytes_read += wrapper->bit_rate_value_minus1.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->cpb_size_value_minus1.SetExternalMemory(value->cpb_size_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE); + bytes_read += wrapper->cpb_size_value_minus1.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->cpb_size_du_value_minus1.SetExternalMemory(value->cpb_size_du_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE); + bytes_read += wrapper->cpb_size_du_value_minus1.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->bit_rate_du_value_minus1.SetExternalMemory(value->bit_rate_du_value_minus1, STD_VIDEO_H265_CPB_CNT_LIST_SIZE); + bytes_read += wrapper->bit_rate_du_value_minus1.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cbr_flag)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265HrdFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265HrdFlags* value = wrapper->decoded_value; + + uint32_t temp_nal_hrd_parameters_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_nal_hrd_parameters_present_flag); + value->nal_hrd_parameters_present_flag = temp_nal_hrd_parameters_present_flag; + uint32_t temp_vcl_hrd_parameters_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vcl_hrd_parameters_present_flag); + value->vcl_hrd_parameters_present_flag = temp_vcl_hrd_parameters_present_flag; + uint32_t temp_sub_pic_hrd_params_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sub_pic_hrd_params_present_flag); + value->sub_pic_hrd_params_present_flag = temp_sub_pic_hrd_params_present_flag; + uint32_t temp_sub_pic_cpb_params_in_pic_timing_sei_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sub_pic_cpb_params_in_pic_timing_sei_flag); + value->sub_pic_cpb_params_in_pic_timing_sei_flag = temp_sub_pic_cpb_params_in_pic_timing_sei_flag; + uint32_t temp_fixed_pic_rate_general_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_fixed_pic_rate_general_flag); + value->fixed_pic_rate_general_flag = temp_fixed_pic_rate_general_flag; + uint32_t temp_fixed_pic_rate_within_cvs_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_fixed_pic_rate_within_cvs_flag); + value->fixed_pic_rate_within_cvs_flag = temp_fixed_pic_rate_within_cvs_flag; + uint32_t temp_low_delay_hrd_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_low_delay_hrd_flag); + value->low_delay_hrd_flag = temp_low_delay_hrd_flag; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265HrdParameters* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265HrdParameters* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tick_divisor_minus2)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->du_cpb_removal_delay_increment_length_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dpb_output_delay_du_length_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bit_rate_scale)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cpb_size_scale)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cpb_size_du_scale)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->initial_cpb_removal_delay_length_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->au_cpb_removal_delay_length_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dpb_output_delay_length_minus1)); + wrapper->cpb_cnt_minus1.SetExternalMemory(value->cpb_cnt_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE); + bytes_read += wrapper->cpb_cnt_minus1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->elemental_duration_in_tc_minus1.SetExternalMemory(value->elemental_duration_in_tc_minus1, STD_VIDEO_H265_SUBLAYERS_LIST_SIZE); + bytes_read += wrapper->elemental_duration_in_tc_minus1.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->reserved.SetExternalMemory(value->reserved, 3); + bytes_read += wrapper->reserved.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pSubLayerHrdParametersNal = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSubLayerHrdParametersNal->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSubLayerHrdParametersNal = wrapper->pSubLayerHrdParametersNal->GetPointer(); + wrapper->pSubLayerHrdParametersVcl = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSubLayerHrdParametersVcl->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSubLayerHrdParametersVcl = wrapper->pSubLayerHrdParametersVcl->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265VpsFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265VpsFlags* value = wrapper->decoded_value; + + uint32_t temp_vps_temporal_id_nesting_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vps_temporal_id_nesting_flag); + value->vps_temporal_id_nesting_flag = temp_vps_temporal_id_nesting_flag; + uint32_t temp_vps_sub_layer_ordering_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vps_sub_layer_ordering_info_present_flag); + value->vps_sub_layer_ordering_info_present_flag = temp_vps_sub_layer_ordering_info_present_flag; + uint32_t temp_vps_timing_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vps_timing_info_present_flag); + value->vps_timing_info_present_flag = temp_vps_timing_info_present_flag; + uint32_t temp_vps_poc_proportional_to_timing_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vps_poc_proportional_to_timing_flag); + value->vps_poc_proportional_to_timing_flag = temp_vps_poc_proportional_to_timing_flag; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265VideoParameterSet* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265VideoParameterSet* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vps_video_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vps_max_sub_layers_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vps_num_units_in_tick)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vps_time_scale)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vps_num_ticks_poc_diff_one_minus1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved3)); + wrapper->pDecPicBufMgr = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDecPicBufMgr->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDecPicBufMgr = wrapper->pDecPicBufMgr->GetPointer(); + wrapper->pHrdParameters = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pHrdParameters->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pHrdParameters = wrapper->pHrdParameters->GetPointer(); + wrapper->pProfileTierLevel = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pProfileTierLevel->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pProfileTierLevel = wrapper->pProfileTierLevel->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265ScalingLists* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265ScalingLists* value = wrapper->decoded_value; + + wrapper->ScalingList4x4.SetExternalMemory(value->ScalingList4x4, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS); + bytes_read += wrapper->ScalingList4x4.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ScalingList8x8.SetExternalMemory(value->ScalingList8x8, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS); + bytes_read += wrapper->ScalingList8x8.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ScalingList16x16.SetExternalMemory(value->ScalingList16x16, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS); + bytes_read += wrapper->ScalingList16x16.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ScalingList32x32.SetExternalMemory(value->ScalingList32x32, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS); + bytes_read += wrapper->ScalingList32x32.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ScalingListDCCoef16x16.SetExternalMemory(value->ScalingListDCCoef16x16, STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS); + bytes_read += wrapper->ScalingListDCCoef16x16.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ScalingListDCCoef32x32.SetExternalMemory(value->ScalingListDCCoef32x32, STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS); + bytes_read += wrapper->ScalingListDCCoef32x32.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265ShortTermRefPicSetFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265ShortTermRefPicSetFlags* value = wrapper->decoded_value; + + uint32_t temp_inter_ref_pic_set_prediction_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_inter_ref_pic_set_prediction_flag); + value->inter_ref_pic_set_prediction_flag = temp_inter_ref_pic_set_prediction_flag; + uint32_t temp_delta_rps_sign; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_delta_rps_sign); + value->delta_rps_sign = temp_delta_rps_sign; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265ShortTermRefPicSet* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265ShortTermRefPicSet* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->delta_idx_minus1)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->use_delta_flag)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->abs_delta_rps_minus1)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->used_by_curr_pic_flag)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->used_by_curr_pic_s0_flag)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->used_by_curr_pic_s1_flag)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved2)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved3)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_negative_pics)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_positive_pics)); + wrapper->delta_poc_s0_minus1.SetExternalMemory(value->delta_poc_s0_minus1, STD_VIDEO_H265_MAX_DPB_SIZE); + bytes_read += wrapper->delta_poc_s0_minus1.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->delta_poc_s1_minus1.SetExternalMemory(value->delta_poc_s1_minus1, STD_VIDEO_H265_MAX_DPB_SIZE); + bytes_read += wrapper->delta_poc_s1_minus1.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265LongTermRefPicsSps* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265LongTermRefPicsSps* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->used_by_curr_pic_lt_sps_flag)); + wrapper->lt_ref_pic_poc_lsb_sps.SetExternalMemory(value->lt_ref_pic_poc_lsb_sps, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS); + bytes_read += wrapper->lt_ref_pic_poc_lsb_sps.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265SpsVuiFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265SpsVuiFlags* value = wrapper->decoded_value; + + uint32_t temp_aspect_ratio_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_aspect_ratio_info_present_flag); + value->aspect_ratio_info_present_flag = temp_aspect_ratio_info_present_flag; + uint32_t temp_overscan_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_overscan_info_present_flag); + value->overscan_info_present_flag = temp_overscan_info_present_flag; + uint32_t temp_overscan_appropriate_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_overscan_appropriate_flag); + value->overscan_appropriate_flag = temp_overscan_appropriate_flag; + uint32_t temp_video_signal_type_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_video_signal_type_present_flag); + value->video_signal_type_present_flag = temp_video_signal_type_present_flag; + uint32_t temp_video_full_range_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_video_full_range_flag); + value->video_full_range_flag = temp_video_full_range_flag; + uint32_t temp_colour_description_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_colour_description_present_flag); + value->colour_description_present_flag = temp_colour_description_present_flag; + uint32_t temp_chroma_loc_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_chroma_loc_info_present_flag); + value->chroma_loc_info_present_flag = temp_chroma_loc_info_present_flag; + uint32_t temp_neutral_chroma_indication_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_neutral_chroma_indication_flag); + value->neutral_chroma_indication_flag = temp_neutral_chroma_indication_flag; + uint32_t temp_field_seq_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_field_seq_flag); + value->field_seq_flag = temp_field_seq_flag; + uint32_t temp_frame_field_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_frame_field_info_present_flag); + value->frame_field_info_present_flag = temp_frame_field_info_present_flag; + uint32_t temp_default_display_window_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_default_display_window_flag); + value->default_display_window_flag = temp_default_display_window_flag; + uint32_t temp_vui_timing_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vui_timing_info_present_flag); + value->vui_timing_info_present_flag = temp_vui_timing_info_present_flag; + uint32_t temp_vui_poc_proportional_to_timing_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vui_poc_proportional_to_timing_flag); + value->vui_poc_proportional_to_timing_flag = temp_vui_poc_proportional_to_timing_flag; + uint32_t temp_vui_hrd_parameters_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vui_hrd_parameters_present_flag); + value->vui_hrd_parameters_present_flag = temp_vui_hrd_parameters_present_flag; + uint32_t temp_bitstream_restriction_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_bitstream_restriction_flag); + value->bitstream_restriction_flag = temp_bitstream_restriction_flag; + uint32_t temp_tiles_fixed_structure_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_tiles_fixed_structure_flag); + value->tiles_fixed_structure_flag = temp_tiles_fixed_structure_flag; + uint32_t temp_motion_vectors_over_pic_boundaries_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_motion_vectors_over_pic_boundaries_flag); + value->motion_vectors_over_pic_boundaries_flag = temp_motion_vectors_over_pic_boundaries_flag; + uint32_t temp_restricted_ref_pic_lists_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_restricted_ref_pic_lists_flag); + value->restricted_ref_pic_lists_flag = temp_restricted_ref_pic_lists_flag; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265SequenceParameterSetVui* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265SequenceParameterSetVui* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspect_ratio_idc)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sar_width)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sar_height)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->video_format)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colour_primaries)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transfer_characteristics)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->matrix_coeffs)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_sample_loc_type_top_field)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_sample_loc_type_bottom_field)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved2)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->def_disp_win_left_offset)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->def_disp_win_right_offset)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->def_disp_win_top_offset)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->def_disp_win_bottom_offset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vui_num_units_in_tick)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vui_time_scale)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vui_num_ticks_poc_diff_one_minus1)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->min_spatial_segmentation_idc)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved3)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_bytes_per_pic_denom)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_bits_per_min_cu_denom)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_max_mv_length_horizontal)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_max_mv_length_vertical)); + wrapper->pHrdParameters = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pHrdParameters->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pHrdParameters = wrapper->pHrdParameters->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265PredictorPaletteEntries* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265PredictorPaletteEntries* value = wrapper->decoded_value; + + wrapper->PredictorPaletteEntries.SetExternalMemory(value->PredictorPaletteEntries, STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE, STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE); + bytes_read += wrapper->PredictorPaletteEntries.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265SpsFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265SpsFlags* value = wrapper->decoded_value; + + uint32_t temp_sps_temporal_id_nesting_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sps_temporal_id_nesting_flag); + value->sps_temporal_id_nesting_flag = temp_sps_temporal_id_nesting_flag; + uint32_t temp_separate_colour_plane_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_separate_colour_plane_flag); + value->separate_colour_plane_flag = temp_separate_colour_plane_flag; + uint32_t temp_conformance_window_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_conformance_window_flag); + value->conformance_window_flag = temp_conformance_window_flag; + uint32_t temp_sps_sub_layer_ordering_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sps_sub_layer_ordering_info_present_flag); + value->sps_sub_layer_ordering_info_present_flag = temp_sps_sub_layer_ordering_info_present_flag; + uint32_t temp_scaling_list_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_scaling_list_enabled_flag); + value->scaling_list_enabled_flag = temp_scaling_list_enabled_flag; + uint32_t temp_sps_scaling_list_data_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sps_scaling_list_data_present_flag); + value->sps_scaling_list_data_present_flag = temp_sps_scaling_list_data_present_flag; + uint32_t temp_amp_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_amp_enabled_flag); + value->amp_enabled_flag = temp_amp_enabled_flag; + uint32_t temp_sample_adaptive_offset_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sample_adaptive_offset_enabled_flag); + value->sample_adaptive_offset_enabled_flag = temp_sample_adaptive_offset_enabled_flag; + uint32_t temp_pcm_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pcm_enabled_flag); + value->pcm_enabled_flag = temp_pcm_enabled_flag; + uint32_t temp_pcm_loop_filter_disabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pcm_loop_filter_disabled_flag); + value->pcm_loop_filter_disabled_flag = temp_pcm_loop_filter_disabled_flag; + uint32_t temp_long_term_ref_pics_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_long_term_ref_pics_present_flag); + value->long_term_ref_pics_present_flag = temp_long_term_ref_pics_present_flag; + uint32_t temp_sps_temporal_mvp_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sps_temporal_mvp_enabled_flag); + value->sps_temporal_mvp_enabled_flag = temp_sps_temporal_mvp_enabled_flag; + uint32_t temp_strong_intra_smoothing_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_strong_intra_smoothing_enabled_flag); + value->strong_intra_smoothing_enabled_flag = temp_strong_intra_smoothing_enabled_flag; + uint32_t temp_vui_parameters_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_vui_parameters_present_flag); + value->vui_parameters_present_flag = temp_vui_parameters_present_flag; + uint32_t temp_sps_extension_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sps_extension_present_flag); + value->sps_extension_present_flag = temp_sps_extension_present_flag; + uint32_t temp_sps_range_extension_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sps_range_extension_flag); + value->sps_range_extension_flag = temp_sps_range_extension_flag; + uint32_t temp_transform_skip_rotation_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_transform_skip_rotation_enabled_flag); + value->transform_skip_rotation_enabled_flag = temp_transform_skip_rotation_enabled_flag; + uint32_t temp_transform_skip_context_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_transform_skip_context_enabled_flag); + value->transform_skip_context_enabled_flag = temp_transform_skip_context_enabled_flag; + uint32_t temp_implicit_rdpcm_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_implicit_rdpcm_enabled_flag); + value->implicit_rdpcm_enabled_flag = temp_implicit_rdpcm_enabled_flag; + uint32_t temp_explicit_rdpcm_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_explicit_rdpcm_enabled_flag); + value->explicit_rdpcm_enabled_flag = temp_explicit_rdpcm_enabled_flag; + uint32_t temp_extended_precision_processing_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_extended_precision_processing_flag); + value->extended_precision_processing_flag = temp_extended_precision_processing_flag; + uint32_t temp_intra_smoothing_disabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_intra_smoothing_disabled_flag); + value->intra_smoothing_disabled_flag = temp_intra_smoothing_disabled_flag; + uint32_t temp_high_precision_offsets_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_high_precision_offsets_enabled_flag); + value->high_precision_offsets_enabled_flag = temp_high_precision_offsets_enabled_flag; + uint32_t temp_persistent_rice_adaptation_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_persistent_rice_adaptation_enabled_flag); + value->persistent_rice_adaptation_enabled_flag = temp_persistent_rice_adaptation_enabled_flag; + uint32_t temp_cabac_bypass_alignment_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_cabac_bypass_alignment_enabled_flag); + value->cabac_bypass_alignment_enabled_flag = temp_cabac_bypass_alignment_enabled_flag; + uint32_t temp_sps_scc_extension_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sps_scc_extension_flag); + value->sps_scc_extension_flag = temp_sps_scc_extension_flag; + uint32_t temp_sps_curr_pic_ref_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sps_curr_pic_ref_enabled_flag); + value->sps_curr_pic_ref_enabled_flag = temp_sps_curr_pic_ref_enabled_flag; + uint32_t temp_palette_mode_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_palette_mode_enabled_flag); + value->palette_mode_enabled_flag = temp_palette_mode_enabled_flag; + uint32_t temp_sps_palette_predictor_initializers_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sps_palette_predictor_initializers_present_flag); + value->sps_palette_predictor_initializers_present_flag = temp_sps_palette_predictor_initializers_present_flag; + uint32_t temp_intra_boundary_filtering_disabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_intra_boundary_filtering_disabled_flag); + value->intra_boundary_filtering_disabled_flag = temp_intra_boundary_filtering_disabled_flag; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265SequenceParameterSet* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265SequenceParameterSet* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_format_idc)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_width_in_luma_samples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_height_in_luma_samples)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sps_video_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sps_max_sub_layers_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sps_seq_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bit_depth_luma_minus8)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bit_depth_chroma_minus8)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_max_pic_order_cnt_lsb_minus4)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_min_luma_coding_block_size_minus3)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_diff_max_min_luma_coding_block_size)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_min_luma_transform_block_size_minus2)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_diff_max_min_luma_transform_block_size)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_transform_hierarchy_depth_inter)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_transform_hierarchy_depth_intra)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_short_term_ref_pic_sets)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_long_term_ref_pics_sps)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pcm_sample_bit_depth_luma_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pcm_sample_bit_depth_chroma_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_min_pcm_luma_coding_block_size_minus3)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_diff_max_min_pcm_luma_coding_block_size)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved2)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->palette_max_size)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->delta_palette_max_predictor_size)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->motion_vector_resolution_control_idc)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sps_num_palette_predictor_initializers_minus1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conf_win_left_offset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conf_win_right_offset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conf_win_top_offset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conf_win_bottom_offset)); + wrapper->pProfileTierLevel = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pProfileTierLevel->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pProfileTierLevel = wrapper->pProfileTierLevel->GetPointer(); + wrapper->pDecPicBufMgr = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDecPicBufMgr->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDecPicBufMgr = wrapper->pDecPicBufMgr->GetPointer(); + wrapper->pScalingLists = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pScalingLists->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pScalingLists = wrapper->pScalingLists->GetPointer(); + wrapper->pShortTermRefPicSet = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pShortTermRefPicSet->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pShortTermRefPicSet = wrapper->pShortTermRefPicSet->GetPointer(); + wrapper->pLongTermRefPicsSps = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pLongTermRefPicsSps->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLongTermRefPicsSps = wrapper->pLongTermRefPicsSps->GetPointer(); + wrapper->pSequenceParameterSetVui = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSequenceParameterSetVui->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSequenceParameterSetVui = wrapper->pSequenceParameterSetVui->GetPointer(); + wrapper->pPredictorPaletteEntries = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPredictorPaletteEntries->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPredictorPaletteEntries = wrapper->pPredictorPaletteEntries->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265PpsFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265PpsFlags* value = wrapper->decoded_value; + + uint32_t temp_dependent_slice_segments_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_dependent_slice_segments_enabled_flag); + value->dependent_slice_segments_enabled_flag = temp_dependent_slice_segments_enabled_flag; + uint32_t temp_output_flag_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_output_flag_present_flag); + value->output_flag_present_flag = temp_output_flag_present_flag; + uint32_t temp_sign_data_hiding_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_sign_data_hiding_enabled_flag); + value->sign_data_hiding_enabled_flag = temp_sign_data_hiding_enabled_flag; + uint32_t temp_cabac_init_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_cabac_init_present_flag); + value->cabac_init_present_flag = temp_cabac_init_present_flag; + uint32_t temp_constrained_intra_pred_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_constrained_intra_pred_flag); + value->constrained_intra_pred_flag = temp_constrained_intra_pred_flag; + uint32_t temp_transform_skip_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_transform_skip_enabled_flag); + value->transform_skip_enabled_flag = temp_transform_skip_enabled_flag; + uint32_t temp_cu_qp_delta_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_cu_qp_delta_enabled_flag); + value->cu_qp_delta_enabled_flag = temp_cu_qp_delta_enabled_flag; + uint32_t temp_pps_slice_chroma_qp_offsets_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pps_slice_chroma_qp_offsets_present_flag); + value->pps_slice_chroma_qp_offsets_present_flag = temp_pps_slice_chroma_qp_offsets_present_flag; + uint32_t temp_weighted_pred_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_weighted_pred_flag); + value->weighted_pred_flag = temp_weighted_pred_flag; + uint32_t temp_weighted_bipred_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_weighted_bipred_flag); + value->weighted_bipred_flag = temp_weighted_bipred_flag; + uint32_t temp_transquant_bypass_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_transquant_bypass_enabled_flag); + value->transquant_bypass_enabled_flag = temp_transquant_bypass_enabled_flag; + uint32_t temp_tiles_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_tiles_enabled_flag); + value->tiles_enabled_flag = temp_tiles_enabled_flag; + uint32_t temp_entropy_coding_sync_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_entropy_coding_sync_enabled_flag); + value->entropy_coding_sync_enabled_flag = temp_entropy_coding_sync_enabled_flag; + uint32_t temp_uniform_spacing_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_uniform_spacing_flag); + value->uniform_spacing_flag = temp_uniform_spacing_flag; + uint32_t temp_loop_filter_across_tiles_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_loop_filter_across_tiles_enabled_flag); + value->loop_filter_across_tiles_enabled_flag = temp_loop_filter_across_tiles_enabled_flag; + uint32_t temp_pps_loop_filter_across_slices_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pps_loop_filter_across_slices_enabled_flag); + value->pps_loop_filter_across_slices_enabled_flag = temp_pps_loop_filter_across_slices_enabled_flag; + uint32_t temp_deblocking_filter_control_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_deblocking_filter_control_present_flag); + value->deblocking_filter_control_present_flag = temp_deblocking_filter_control_present_flag; + uint32_t temp_deblocking_filter_override_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_deblocking_filter_override_enabled_flag); + value->deblocking_filter_override_enabled_flag = temp_deblocking_filter_override_enabled_flag; + uint32_t temp_pps_deblocking_filter_disabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pps_deblocking_filter_disabled_flag); + value->pps_deblocking_filter_disabled_flag = temp_pps_deblocking_filter_disabled_flag; + uint32_t temp_pps_scaling_list_data_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pps_scaling_list_data_present_flag); + value->pps_scaling_list_data_present_flag = temp_pps_scaling_list_data_present_flag; + uint32_t temp_lists_modification_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_lists_modification_present_flag); + value->lists_modification_present_flag = temp_lists_modification_present_flag; + uint32_t temp_slice_segment_header_extension_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_slice_segment_header_extension_present_flag); + value->slice_segment_header_extension_present_flag = temp_slice_segment_header_extension_present_flag; + uint32_t temp_pps_extension_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pps_extension_present_flag); + value->pps_extension_present_flag = temp_pps_extension_present_flag; + uint32_t temp_cross_component_prediction_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_cross_component_prediction_enabled_flag); + value->cross_component_prediction_enabled_flag = temp_cross_component_prediction_enabled_flag; + uint32_t temp_chroma_qp_offset_list_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_chroma_qp_offset_list_enabled_flag); + value->chroma_qp_offset_list_enabled_flag = temp_chroma_qp_offset_list_enabled_flag; + uint32_t temp_pps_curr_pic_ref_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pps_curr_pic_ref_enabled_flag); + value->pps_curr_pic_ref_enabled_flag = temp_pps_curr_pic_ref_enabled_flag; + uint32_t temp_residual_adaptive_colour_transform_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_residual_adaptive_colour_transform_enabled_flag); + value->residual_adaptive_colour_transform_enabled_flag = temp_residual_adaptive_colour_transform_enabled_flag; + uint32_t temp_pps_slice_act_qp_offsets_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pps_slice_act_qp_offsets_present_flag); + value->pps_slice_act_qp_offsets_present_flag = temp_pps_slice_act_qp_offsets_present_flag; + uint32_t temp_pps_palette_predictor_initializers_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pps_palette_predictor_initializers_present_flag); + value->pps_palette_predictor_initializers_present_flag = temp_pps_palette_predictor_initializers_present_flag; + uint32_t temp_monochrome_palette_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_monochrome_palette_flag); + value->monochrome_palette_flag = temp_monochrome_palette_flag; + uint32_t temp_pps_range_extension_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pps_range_extension_flag); + value->pps_range_extension_flag = temp_pps_range_extension_flag; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoH265PictureParameterSet* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoH265PictureParameterSet* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_pic_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_seq_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sps_video_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_extra_slice_header_bits)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ref_idx_l0_default_active_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ref_idx_l1_default_active_minus1)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->init_qp_minus26)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->diff_cu_qp_delta_depth)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_cb_qp_offset)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_cr_qp_offset)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_beta_offset_div2)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_tc_offset_div2)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_parallel_merge_level_minus2)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_max_transform_skip_block_size_minus2)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->diff_cu_chroma_qp_offset_depth)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_qp_offset_list_len_minus1)); + wrapper->cb_qp_offset_list.SetExternalMemory(value->cb_qp_offset_list, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE); + bytes_read += wrapper->cb_qp_offset_list.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->cr_qp_offset_list.SetExternalMemory(value->cr_qp_offset_list, STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE); + bytes_read += wrapper->cr_qp_offset_list.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_sao_offset_scale_luma)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->log2_sao_offset_scale_chroma)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_act_y_qp_offset_plus5)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_act_cb_qp_offset_plus5)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_act_cr_qp_offset_plus3)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_num_palette_predictor_initializers)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->luma_bit_depth_entry_minus8)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_bit_depth_entry_minus8)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_tile_columns_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_tile_rows_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved2)); + wrapper->column_width_minus1.SetExternalMemory(value->column_width_minus1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE); + bytes_read += wrapper->column_width_minus1.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->row_height_minus1.SetExternalMemory(value->row_height_minus1, STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE); + bytes_read += wrapper->row_height_minus1.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved3)); + wrapper->pScalingLists = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pScalingLists->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pScalingLists = wrapper->pScalingLists->GetPointer(); + wrapper->pPredictorPaletteEntries = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPredictorPaletteEntries->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPredictorPaletteEntries = wrapper->pPredictorPaletteEntries->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeH265PictureInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeH265PictureInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_IrapPicFlag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_IrapPicFlag); + value->IrapPicFlag = temp_IrapPicFlag; + uint32_t temp_IdrPicFlag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_IdrPicFlag); + value->IdrPicFlag = temp_IdrPicFlag; + uint32_t temp_IsReference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_IsReference); + value->IsReference = temp_IsReference; + uint32_t temp_short_term_ref_pic_set_sps_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_short_term_ref_pic_set_sps_flag); + value->short_term_ref_pic_set_sps_flag = temp_short_term_ref_pic_set_sps_flag; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeH265PictureInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeH265PictureInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sps_video_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_seq_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_pic_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->NumDeltaPocsOfRefRpsIdx)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->PicOrderCntVal)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->NumBitsForSTRefPicSetInSlice)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved)); + wrapper->RefPicSetStCurrBefore.SetExternalMemory(value->RefPicSetStCurrBefore, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE); + bytes_read += wrapper->RefPicSetStCurrBefore.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->RefPicSetStCurrAfter.SetExternalMemory(value->RefPicSetStCurrAfter, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE); + bytes_read += wrapper->RefPicSetStCurrAfter.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->RefPicSetLtCurr.SetExternalMemory(value->RefPicSetLtCurr, STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE); + bytes_read += wrapper->RefPicSetLtCurr.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeH265ReferenceInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeH265ReferenceInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_used_for_long_term_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_used_for_long_term_reference); + value->used_for_long_term_reference = temp_used_for_long_term_reference; + uint32_t temp_unused_for_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_unused_for_reference); + value->unused_for_reference = temp_unused_for_reference; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeH265ReferenceInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeH265ReferenceInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->PicOrderCntVal)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265WeightTableFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265WeightTableFlags* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->luma_weight_l0_flag)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_weight_l0_flag)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->luma_weight_l1_flag)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_weight_l1_flag)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265WeightTable* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265WeightTable* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->luma_log2_weight_denom)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->delta_chroma_log2_weight_denom)); + wrapper->delta_luma_weight_l0.SetExternalMemory(value->delta_luma_weight_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF); + bytes_read += wrapper->delta_luma_weight_l0.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->luma_offset_l0.SetExternalMemory(value->luma_offset_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF); + bytes_read += wrapper->luma_offset_l0.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->delta_chroma_weight_l0.SetExternalMemory(value->delta_chroma_weight_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES); + bytes_read += wrapper->delta_chroma_weight_l0.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->delta_chroma_offset_l0.SetExternalMemory(value->delta_chroma_offset_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES); + bytes_read += wrapper->delta_chroma_offset_l0.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->delta_luma_weight_l1.SetExternalMemory(value->delta_luma_weight_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF); + bytes_read += wrapper->delta_luma_weight_l1.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->luma_offset_l1.SetExternalMemory(value->luma_offset_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF); + bytes_read += wrapper->luma_offset_l1.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->delta_chroma_weight_l1.SetExternalMemory(value->delta_chroma_weight_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES); + bytes_read += wrapper->delta_chroma_weight_l1.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->delta_chroma_offset_l1.SetExternalMemory(value->delta_chroma_offset_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF, STD_VIDEO_H265_MAX_CHROMA_PLANES); + bytes_read += wrapper->delta_chroma_offset_l1.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265LongTermRefPics* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265LongTermRefPics* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_long_term_sps)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_long_term_pics)); + wrapper->lt_idx_sps.SetExternalMemory(value->lt_idx_sps, STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS); + bytes_read += wrapper->lt_idx_sps.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->poc_lsb_lt.SetExternalMemory(value->poc_lsb_lt, STD_VIDEO_H265_MAX_LONG_TERM_PICS); + bytes_read += wrapper->poc_lsb_lt.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->used_by_curr_pic_lt_flag)); + wrapper->delta_poc_msb_present_flag.SetExternalMemory(value->delta_poc_msb_present_flag, STD_VIDEO_H265_MAX_DELTA_POC); + bytes_read += wrapper->delta_poc_msb_present_flag.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->delta_poc_msb_cycle_lt.SetExternalMemory(value->delta_poc_msb_cycle_lt, STD_VIDEO_H265_MAX_DELTA_POC); + bytes_read += wrapper->delta_poc_msb_cycle_lt.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265SliceSegmentHeaderFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265SliceSegmentHeaderFlags* value = wrapper->decoded_value; + + uint32_t temp_first_slice_segment_in_pic_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_first_slice_segment_in_pic_flag); + value->first_slice_segment_in_pic_flag = temp_first_slice_segment_in_pic_flag; + uint32_t temp_dependent_slice_segment_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_dependent_slice_segment_flag); + value->dependent_slice_segment_flag = temp_dependent_slice_segment_flag; + uint32_t temp_slice_sao_luma_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_slice_sao_luma_flag); + value->slice_sao_luma_flag = temp_slice_sao_luma_flag; + uint32_t temp_slice_sao_chroma_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_slice_sao_chroma_flag); + value->slice_sao_chroma_flag = temp_slice_sao_chroma_flag; + uint32_t temp_num_ref_idx_active_override_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_num_ref_idx_active_override_flag); + value->num_ref_idx_active_override_flag = temp_num_ref_idx_active_override_flag; + uint32_t temp_mvd_l1_zero_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mvd_l1_zero_flag); + value->mvd_l1_zero_flag = temp_mvd_l1_zero_flag; + uint32_t temp_cabac_init_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_cabac_init_flag); + value->cabac_init_flag = temp_cabac_init_flag; + uint32_t temp_cu_chroma_qp_offset_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_cu_chroma_qp_offset_enabled_flag); + value->cu_chroma_qp_offset_enabled_flag = temp_cu_chroma_qp_offset_enabled_flag; + uint32_t temp_deblocking_filter_override_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_deblocking_filter_override_flag); + value->deblocking_filter_override_flag = temp_deblocking_filter_override_flag; + uint32_t temp_slice_deblocking_filter_disabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_slice_deblocking_filter_disabled_flag); + value->slice_deblocking_filter_disabled_flag = temp_slice_deblocking_filter_disabled_flag; + uint32_t temp_collocated_from_l0_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_collocated_from_l0_flag); + value->collocated_from_l0_flag = temp_collocated_from_l0_flag; + uint32_t temp_slice_loop_filter_across_slices_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_slice_loop_filter_across_slices_enabled_flag); + value->slice_loop_filter_across_slices_enabled_flag = temp_slice_loop_filter_across_slices_enabled_flag; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265SliceSegmentHeader* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265SliceSegmentHeader* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_segment_address)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->collocated_ref_idx)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->MaxNumMergeCand)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_cb_qp_offset)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_cr_qp_offset)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_beta_offset_div2)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_tc_offset_div2)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_act_y_qp_offset)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_act_cb_qp_offset)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_act_cr_qp_offset)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->slice_qp_delta)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + wrapper->pWeightTable = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pWeightTable->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWeightTable = wrapper->pWeightTable->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265ReferenceListsInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265ReferenceListsInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_ref_pic_list_modification_flag_l0; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_ref_pic_list_modification_flag_l0); + value->ref_pic_list_modification_flag_l0 = temp_ref_pic_list_modification_flag_l0; + uint32_t temp_ref_pic_list_modification_flag_l1; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_ref_pic_list_modification_flag_l1); + value->ref_pic_list_modification_flag_l1 = temp_ref_pic_list_modification_flag_l1; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265ReferenceListsInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265ReferenceListsInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ref_idx_l0_active_minus1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ref_idx_l1_active_minus1)); + wrapper->RefPicList0.SetExternalMemory(value->RefPicList0, STD_VIDEO_H265_MAX_NUM_LIST_REF); + bytes_read += wrapper->RefPicList0.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->RefPicList1.SetExternalMemory(value->RefPicList1, STD_VIDEO_H265_MAX_NUM_LIST_REF); + bytes_read += wrapper->RefPicList1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->list_entry_l0.SetExternalMemory(value->list_entry_l0, STD_VIDEO_H265_MAX_NUM_LIST_REF); + bytes_read += wrapper->list_entry_l0.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->list_entry_l1.SetExternalMemory(value->list_entry_l1, STD_VIDEO_H265_MAX_NUM_LIST_REF); + bytes_read += wrapper->list_entry_l1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265PictureInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265PictureInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_is_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_is_reference); + value->is_reference = temp_is_reference; + uint32_t temp_IrapPicFlag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_IrapPicFlag); + value->IrapPicFlag = temp_IrapPicFlag; + uint32_t temp_used_for_long_term_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_used_for_long_term_reference); + value->used_for_long_term_reference = temp_used_for_long_term_reference; + uint32_t temp_discardable_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_discardable_flag); + value->discardable_flag = temp_discardable_flag; + uint32_t temp_cross_layer_bla_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_cross_layer_bla_flag); + value->cross_layer_bla_flag = temp_cross_layer_bla_flag; + uint32_t temp_pic_output_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_pic_output_flag); + value->pic_output_flag = temp_pic_output_flag; + uint32_t temp_no_output_of_prior_pics_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_no_output_of_prior_pics_flag); + value->no_output_of_prior_pics_flag = temp_no_output_of_prior_pics_flag; + uint32_t temp_short_term_ref_pic_set_sps_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_short_term_ref_pic_set_sps_flag); + value->short_term_ref_pic_set_sps_flag = temp_short_term_ref_pic_set_sps_flag; + uint32_t temp_slice_temporal_mvp_enabled_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_slice_temporal_mvp_enabled_flag); + value->slice_temporal_mvp_enabled_flag = temp_slice_temporal_mvp_enabled_flag; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265PictureInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265PictureInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_type)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sps_video_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_seq_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pps_pic_parameter_set_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->short_term_ref_pic_set_idx)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->PicOrderCntVal)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->TemporalId)); + wrapper->reserved1.SetExternalMemory(value->reserved1, 7); + bytes_read += wrapper->reserved1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pRefLists = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRefLists->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRefLists = wrapper->pRefLists->GetPointer(); + wrapper->pShortTermRefPicSet = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pShortTermRefPicSet->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pShortTermRefPicSet = wrapper->pShortTermRefPicSet->GetPointer(); + wrapper->pLongTermRefPics = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pLongTermRefPics->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLongTermRefPics = wrapper->pLongTermRefPics->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265ReferenceInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265ReferenceInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_used_for_long_term_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_used_for_long_term_reference); + value->used_for_long_term_reference = temp_used_for_long_term_reference; + uint32_t temp_unused_for_reference; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_unused_for_reference); + value->unused_for_reference = temp_unused_for_reference; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoEncodeH265ReferenceInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoEncodeH265ReferenceInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pic_type)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->PicOrderCntVal)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->TemporalId)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1ColorConfigFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1ColorConfigFlags* value = wrapper->decoded_value; + + uint32_t temp_mono_chrome; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mono_chrome); + value->mono_chrome = temp_mono_chrome; + uint32_t temp_color_range; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_color_range); + value->color_range = temp_color_range; + uint32_t temp_separate_uv_delta_q; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_separate_uv_delta_q); + value->separate_uv_delta_q = temp_separate_uv_delta_q; + uint32_t temp_color_description_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_color_description_present_flag); + value->color_description_present_flag = temp_color_description_present_flag; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1ColorConfig* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1ColorConfig* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->BitDepth)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsampling_x)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsampling_y)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->color_primaries)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transfer_characteristics)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->matrix_coefficients)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chroma_sample_position)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1TimingInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1TimingInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_equal_picture_interval; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_equal_picture_interval); + value->equal_picture_interval = temp_equal_picture_interval; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1TimingInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1TimingInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_units_in_display_tick)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->time_scale)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_ticks_per_picture_minus_1)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1SequenceHeaderFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1SequenceHeaderFlags* value = wrapper->decoded_value; + + uint32_t temp_still_picture; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_still_picture); + value->still_picture = temp_still_picture; + uint32_t temp_reduced_still_picture_header; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reduced_still_picture_header); + value->reduced_still_picture_header = temp_reduced_still_picture_header; + uint32_t temp_use_128x128_superblock; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_use_128x128_superblock); + value->use_128x128_superblock = temp_use_128x128_superblock; + uint32_t temp_enable_filter_intra; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_filter_intra); + value->enable_filter_intra = temp_enable_filter_intra; + uint32_t temp_enable_intra_edge_filter; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_intra_edge_filter); + value->enable_intra_edge_filter = temp_enable_intra_edge_filter; + uint32_t temp_enable_interintra_compound; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_interintra_compound); + value->enable_interintra_compound = temp_enable_interintra_compound; + uint32_t temp_enable_masked_compound; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_masked_compound); + value->enable_masked_compound = temp_enable_masked_compound; + uint32_t temp_enable_warped_motion; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_warped_motion); + value->enable_warped_motion = temp_enable_warped_motion; + uint32_t temp_enable_dual_filter; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_dual_filter); + value->enable_dual_filter = temp_enable_dual_filter; + uint32_t temp_enable_order_hint; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_order_hint); + value->enable_order_hint = temp_enable_order_hint; + uint32_t temp_enable_jnt_comp; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_jnt_comp); + value->enable_jnt_comp = temp_enable_jnt_comp; + uint32_t temp_enable_ref_frame_mvs; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_ref_frame_mvs); + value->enable_ref_frame_mvs = temp_enable_ref_frame_mvs; + uint32_t temp_frame_id_numbers_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_frame_id_numbers_present_flag); + value->frame_id_numbers_present_flag = temp_frame_id_numbers_present_flag; + uint32_t temp_enable_superres; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_superres); + value->enable_superres = temp_enable_superres; + uint32_t temp_enable_cdef; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_cdef); + value->enable_cdef = temp_enable_cdef; + uint32_t temp_enable_restoration; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_enable_restoration); + value->enable_restoration = temp_enable_restoration; + uint32_t temp_film_grain_params_present; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_film_grain_params_present); + value->film_grain_params_present = temp_film_grain_params_present; + uint32_t temp_timing_info_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_timing_info_present_flag); + value->timing_info_present_flag = temp_timing_info_present_flag; + uint32_t temp_initial_display_delay_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_initial_display_delay_present_flag); + value->initial_display_delay_present_flag = temp_initial_display_delay_present_flag; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1SequenceHeader* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1SequenceHeader* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->seq_profile)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_width_bits_minus_1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_height_bits_minus_1)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_frame_width_minus_1)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->max_frame_height_minus_1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->delta_frame_id_length_minus_2)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->additional_frame_id_length_minus_1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->order_hint_bits_minus_1)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->seq_force_integer_mv)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->seq_force_screen_content_tools)); + wrapper->reserved1.SetExternalMemory(value->reserved1, 5); + bytes_read += wrapper->reserved1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pColorConfig = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pColorConfig->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorConfig = wrapper->pColorConfig->GetPointer(); + wrapper->pTimingInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pTimingInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTimingInfo = wrapper->pTimingInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1LoopFilterFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1LoopFilterFlags* value = wrapper->decoded_value; + + uint32_t temp_loop_filter_delta_enabled; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_loop_filter_delta_enabled); + value->loop_filter_delta_enabled = temp_loop_filter_delta_enabled; + uint32_t temp_loop_filter_delta_update; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_loop_filter_delta_update); + value->loop_filter_delta_update = temp_loop_filter_delta_update; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1LoopFilter* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1LoopFilter* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + wrapper->loop_filter_level.SetExternalMemory(value->loop_filter_level, STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS); + bytes_read += wrapper->loop_filter_level.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->loop_filter_sharpness)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->update_ref_delta)); + wrapper->loop_filter_ref_deltas.SetExternalMemory(value->loop_filter_ref_deltas, STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME); + bytes_read += wrapper->loop_filter_ref_deltas.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->update_mode_delta)); + wrapper->loop_filter_mode_deltas.SetExternalMemory(value->loop_filter_mode_deltas, STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS); + bytes_read += wrapper->loop_filter_mode_deltas.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1QuantizationFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1QuantizationFlags* value = wrapper->decoded_value; + + uint32_t temp_using_qmatrix; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_using_qmatrix); + value->using_qmatrix = temp_using_qmatrix; + uint32_t temp_diff_uv_delta; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_diff_uv_delta); + value->diff_uv_delta = temp_diff_uv_delta; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1Quantization* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1Quantization* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->base_q_idx)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->DeltaQYDc)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->DeltaQUDc)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->DeltaQUAc)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->DeltaQVDc)); + bytes_read += ValueDecoder::DecodeInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->DeltaQVAc)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qm_y)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qm_u)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->qm_v)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1Segmentation* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1Segmentation* value = wrapper->decoded_value; + + wrapper->FeatureEnabled.SetExternalMemory(value->FeatureEnabled, STD_VIDEO_AV1_MAX_SEGMENTS); + bytes_read += wrapper->FeatureEnabled.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->FeatureData.SetExternalMemory(value->FeatureData, STD_VIDEO_AV1_MAX_SEGMENTS, STD_VIDEO_AV1_SEG_LVL_MAX); + bytes_read += wrapper->FeatureData.PreloadDecodeInt16((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1TileInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1TileInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_uniform_tile_spacing_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_uniform_tile_spacing_flag); + value->uniform_tile_spacing_flag = temp_uniform_tile_spacing_flag; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1TileInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1TileInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->TileCols)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->TileRows)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->context_update_tile_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tile_size_bytes_minus_1)); + wrapper->reserved1.SetExternalMemory(value->reserved1, 7); + bytes_read += wrapper->reserved1.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += wrapper->pMiColStarts.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMiColStarts = wrapper->pMiColStarts.GetPointer(); + bytes_read += wrapper->pMiRowStarts.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMiRowStarts = wrapper->pMiRowStarts.GetPointer(); + bytes_read += wrapper->pWidthInSbsMinus1.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWidthInSbsMinus1 = wrapper->pWidthInSbsMinus1.GetPointer(); + bytes_read += wrapper->pHeightInSbsMinus1.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + value->pHeightInSbsMinus1 = wrapper->pHeightInSbsMinus1.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1CDEF* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1CDEF* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cdef_damping_minus_3)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cdef_bits)); + wrapper->cdef_y_pri_strength.SetExternalMemory(value->cdef_y_pri_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS); + bytes_read += wrapper->cdef_y_pri_strength.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->cdef_y_sec_strength.SetExternalMemory(value->cdef_y_sec_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS); + bytes_read += wrapper->cdef_y_sec_strength.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->cdef_uv_pri_strength.SetExternalMemory(value->cdef_uv_pri_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS); + bytes_read += wrapper->cdef_uv_pri_strength.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->cdef_uv_sec_strength.SetExternalMemory(value->cdef_uv_sec_strength, STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS); + bytes_read += wrapper->cdef_uv_sec_strength.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1LoopRestoration* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1LoopRestoration* value = wrapper->decoded_value; + + wrapper->FrameRestorationType.SetExternalMemory(value->FrameRestorationType, STD_VIDEO_AV1_MAX_NUM_PLANES); + bytes_read += wrapper->FrameRestorationType.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->LoopRestorationSize.SetExternalMemory(value->LoopRestorationSize, STD_VIDEO_AV1_MAX_NUM_PLANES); + bytes_read += wrapper->LoopRestorationSize.PreloadDecodeUInt16((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1GlobalMotion* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1GlobalMotion* value = wrapper->decoded_value; + + wrapper->GmType.SetExternalMemory(value->GmType, STD_VIDEO_AV1_NUM_REF_FRAMES); + bytes_read += wrapper->GmType.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->gm_params.SetExternalMemory(value->gm_params, STD_VIDEO_AV1_NUM_REF_FRAMES, STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS); + bytes_read += wrapper->gm_params.PreloadDecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1FilmGrainFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1FilmGrainFlags* value = wrapper->decoded_value; + + uint32_t temp_chroma_scaling_from_luma; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_chroma_scaling_from_luma); + value->chroma_scaling_from_luma = temp_chroma_scaling_from_luma; + uint32_t temp_overlap_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_overlap_flag); + value->overlap_flag = temp_overlap_flag; + uint32_t temp_clip_to_restricted_range; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_clip_to_restricted_range); + value->clip_to_restricted_range = temp_clip_to_restricted_range; + uint32_t temp_update_grain; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_update_grain); + value->update_grain = temp_update_grain; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoAV1FilmGrain* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoAV1FilmGrain* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->grain_scaling_minus_8)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ar_coeff_lag)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ar_coeff_shift_minus_6)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->grain_scale_shift)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->grain_seed)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->film_grain_params_ref_idx)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_y_points)); + wrapper->point_y_value.SetExternalMemory(value->point_y_value, STD_VIDEO_AV1_MAX_NUM_Y_POINTS); + bytes_read += wrapper->point_y_value.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->point_y_scaling.SetExternalMemory(value->point_y_scaling, STD_VIDEO_AV1_MAX_NUM_Y_POINTS); + bytes_read += wrapper->point_y_scaling.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_cb_points)); + wrapper->point_cb_value.SetExternalMemory(value->point_cb_value, STD_VIDEO_AV1_MAX_NUM_CB_POINTS); + bytes_read += wrapper->point_cb_value.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->point_cb_scaling.SetExternalMemory(value->point_cb_scaling, STD_VIDEO_AV1_MAX_NUM_CB_POINTS); + bytes_read += wrapper->point_cb_scaling.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->num_cr_points)); + wrapper->point_cr_value.SetExternalMemory(value->point_cr_value, STD_VIDEO_AV1_MAX_NUM_CR_POINTS); + bytes_read += wrapper->point_cr_value.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->point_cr_scaling.SetExternalMemory(value->point_cr_scaling, STD_VIDEO_AV1_MAX_NUM_CR_POINTS); + bytes_read += wrapper->point_cr_scaling.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ar_coeffs_y_plus_128.SetExternalMemory(value->ar_coeffs_y_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_LUMA); + bytes_read += wrapper->ar_coeffs_y_plus_128.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ar_coeffs_cb_plus_128.SetExternalMemory(value->ar_coeffs_cb_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA); + bytes_read += wrapper->ar_coeffs_cb_plus_128.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ar_coeffs_cr_plus_128.SetExternalMemory(value->ar_coeffs_cr_plus_128, STD_VIDEO_AV1_MAX_NUM_POS_CHROMA); + bytes_read += wrapper->ar_coeffs_cr_plus_128.PreloadDecodeInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cb_mult)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cb_luma_mult)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cb_offset)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cr_mult)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cr_luma_mult)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cr_offset)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeAV1PictureInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeAV1PictureInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_error_resilient_mode; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_error_resilient_mode); + value->error_resilient_mode = temp_error_resilient_mode; + uint32_t temp_disable_cdf_update; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_disable_cdf_update); + value->disable_cdf_update = temp_disable_cdf_update; + uint32_t temp_use_superres; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_use_superres); + value->use_superres = temp_use_superres; + uint32_t temp_render_and_frame_size_different; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_render_and_frame_size_different); + value->render_and_frame_size_different = temp_render_and_frame_size_different; + uint32_t temp_allow_screen_content_tools; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_allow_screen_content_tools); + value->allow_screen_content_tools = temp_allow_screen_content_tools; + uint32_t temp_is_filter_switchable; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_is_filter_switchable); + value->is_filter_switchable = temp_is_filter_switchable; + uint32_t temp_force_integer_mv; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_force_integer_mv); + value->force_integer_mv = temp_force_integer_mv; + uint32_t temp_frame_size_override_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_frame_size_override_flag); + value->frame_size_override_flag = temp_frame_size_override_flag; + uint32_t temp_buffer_removal_time_present_flag; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_buffer_removal_time_present_flag); + value->buffer_removal_time_present_flag = temp_buffer_removal_time_present_flag; + uint32_t temp_allow_intrabc; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_allow_intrabc); + value->allow_intrabc = temp_allow_intrabc; + uint32_t temp_frame_refs_short_signaling; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_frame_refs_short_signaling); + value->frame_refs_short_signaling = temp_frame_refs_short_signaling; + uint32_t temp_allow_high_precision_mv; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_allow_high_precision_mv); + value->allow_high_precision_mv = temp_allow_high_precision_mv; + uint32_t temp_is_motion_mode_switchable; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_is_motion_mode_switchable); + value->is_motion_mode_switchable = temp_is_motion_mode_switchable; + uint32_t temp_use_ref_frame_mvs; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_use_ref_frame_mvs); + value->use_ref_frame_mvs = temp_use_ref_frame_mvs; + uint32_t temp_disable_frame_end_update_cdf; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_disable_frame_end_update_cdf); + value->disable_frame_end_update_cdf = temp_disable_frame_end_update_cdf; + uint32_t temp_allow_warped_motion; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_allow_warped_motion); + value->allow_warped_motion = temp_allow_warped_motion; + uint32_t temp_reduced_tx_set; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reduced_tx_set); + value->reduced_tx_set = temp_reduced_tx_set; + uint32_t temp_reference_select; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reference_select); + value->reference_select = temp_reference_select; + uint32_t temp_skip_mode_present; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_skip_mode_present); + value->skip_mode_present = temp_skip_mode_present; + uint32_t temp_delta_q_present; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_delta_q_present); + value->delta_q_present = temp_delta_q_present; + uint32_t temp_delta_lf_present; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_delta_lf_present); + value->delta_lf_present = temp_delta_lf_present; + uint32_t temp_delta_lf_multi; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_delta_lf_multi); + value->delta_lf_multi = temp_delta_lf_multi; + uint32_t temp_segmentation_enabled; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_segmentation_enabled); + value->segmentation_enabled = temp_segmentation_enabled; + uint32_t temp_segmentation_update_map; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_segmentation_update_map); + value->segmentation_update_map = temp_segmentation_update_map; + uint32_t temp_segmentation_temporal_update; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_segmentation_temporal_update); + value->segmentation_temporal_update = temp_segmentation_temporal_update; + uint32_t temp_segmentation_update_data; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_segmentation_update_data); + value->segmentation_update_data = temp_segmentation_update_data; + uint32_t temp_UsesLr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_UsesLr); + value->UsesLr = temp_UsesLr; + uint32_t temp_usesChromaLr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_usesChromaLr); + value->usesChromaLr = temp_usesChromaLr; + uint32_t temp_apply_grain; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_apply_grain); + value->apply_grain = temp_apply_grain; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeAV1PictureInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeAV1PictureInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->current_frame_id)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->OrderHint)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primary_ref_frame)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refresh_frame_flags)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reserved1)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->interpolation_filter)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->TxMode)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->delta_q_res)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->delta_lf_res)); + wrapper->SkipModeFrame.SetExternalMemory(value->SkipModeFrame, STD_VIDEO_AV1_SKIP_MODE_FRAMES); + bytes_read += wrapper->SkipModeFrame.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coded_denom)); + wrapper->reserved2.SetExternalMemory(value->reserved2, 3); + bytes_read += wrapper->reserved2.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->OrderHints.SetExternalMemory(value->OrderHints, STD_VIDEO_AV1_NUM_REF_FRAMES); + bytes_read += wrapper->OrderHints.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->expectedFrameId.SetExternalMemory(value->expectedFrameId, STD_VIDEO_AV1_NUM_REF_FRAMES); + bytes_read += wrapper->expectedFrameId.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pTileInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pTileInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTileInfo = wrapper->pTileInfo->GetPointer(); + wrapper->pQuantization = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pQuantization->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQuantization = wrapper->pQuantization->GetPointer(); + wrapper->pSegmentation = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSegmentation->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSegmentation = wrapper->pSegmentation->GetPointer(); + wrapper->pLoopFilter = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pLoopFilter->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLoopFilter = wrapper->pLoopFilter->GetPointer(); + wrapper->pCDEF = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pCDEF->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCDEF = wrapper->pCDEF->GetPointer(); + wrapper->pLoopRestoration = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pLoopRestoration->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLoopRestoration = wrapper->pLoopRestoration->GetPointer(); + wrapper->pGlobalMotion = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pGlobalMotion->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pGlobalMotion = wrapper->pGlobalMotion->GetPointer(); + wrapper->pFilmGrain = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pFilmGrain->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pFilmGrain = wrapper->pFilmGrain->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeAV1ReferenceInfoFlags* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeAV1ReferenceInfoFlags* value = wrapper->decoded_value; + + uint32_t temp_disable_frame_end_update_cdf; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_disable_frame_end_update_cdf); + value->disable_frame_end_update_cdf = temp_disable_frame_end_update_cdf; + uint32_t temp_segmentation_enabled; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_segmentation_enabled); + value->segmentation_enabled = temp_segmentation_enabled; + uint32_t temp_reserved; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_reserved); + value->reserved = temp_reserved; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_StdVideoDecodeAV1ReferenceInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + StdVideoDecodeAV1ReferenceInfo* value = wrapper->decoded_value; + + wrapper->flags = PreloadDecodeAllocator::Allocate(); + wrapper->flags->decoded_value = &(value->flags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->flags); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frame_type)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->RefFrameSignBias)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->OrderHint)); + wrapper->SavedOrderHints.SetExternalMemory(value->SavedOrderHints, STD_VIDEO_AV1_NUM_REF_FRAMES); + bytes_read += wrapper->SavedOrderHints.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExtent2D* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExtent2D* value = wrapper->decoded_value; + + 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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExtent3D* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExtent3D* value = wrapper->decoded_value; + + 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOffset2D* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkOffset2D* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOffset3D* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkOffset3D* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->z)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRect2D* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRect2D* value = wrapper->decoded_value; + + wrapper->offset = PreloadDecodeAllocator::Allocate(); + wrapper->offset->decoded_value = &(value->offset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->offset); + wrapper->extent = PreloadDecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferMemoryBarrier* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferMemoryBarrier* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDispatchIndirectCommand* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDispatchIndirectCommand* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->z)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrawIndexedIndirectCommand* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDrawIndexedIndirectCommand* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->instanceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstIndex)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstInstance)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrawIndirectCommand* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDrawIndirectCommand* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->instanceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstVertex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstInstance)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSubresourceRange* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageSubresourceRange* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseMipLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->levelCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseArrayLayer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layerCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageMemoryBarrier* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageMemoryBarrier* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->oldLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->newLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); + value->image = VK_NULL_HANDLE; + wrapper->subresourceRange = PreloadDecodeAllocator::Allocate(); + wrapper->subresourceRange->decoded_value = &(value->subresourceRange); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceRange); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryBarrier* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryBarrier* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCacheHeaderVersionOne* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineCacheHeaderVersionOne* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->headerSize)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->headerVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceID)); + wrapper->pipelineCacheUUID.SetExternalMemory(value->pipelineCacheUUID, VK_UUID_SIZE); + bytes_read += wrapper->pipelineCacheUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAllocationCallbacks* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAllocationCallbacks* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pUserData)); + value->pUserData = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnAllocation)); + value->pfnAllocation = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnReallocation)); + value->pfnReallocation = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnFree)); + value->pfnFree = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnInternalAllocation)); + value->pfnInternalAllocation = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnInternalFree)); + value->pfnInternalFree = nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkApplicationInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkApplicationInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += wrapper->pApplicationName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pApplicationName = wrapper->pApplicationName.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->applicationVersion)); + bytes_read += wrapper->pEngineName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pEngineName = wrapper->pEngineName.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->engineVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->apiVersion)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFormatProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFormatProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->linearTilingFeatures)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimalTilingFeatures)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferFeatures)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageFormatProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageFormatProperties* value = wrapper->decoded_value; + + wrapper->maxExtent = PreloadDecodeAllocator::Allocate(); + wrapper->maxExtent->decoded_value = &(value->maxExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMipLevels)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxArrayLayers)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleCounts)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxResourceSize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkInstanceCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkInstanceCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + wrapper->pApplicationInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pApplicationInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pApplicationInfo = wrapper->pApplicationInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enabledLayerCount)); + bytes_read += wrapper->ppEnabledLayerNames.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppEnabledLayerNames = wrapper->ppEnabledLayerNames.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enabledExtensionCount)); + bytes_read += wrapper->ppEnabledExtensionNames.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppEnabledExtensionNames = wrapper->ppEnabledExtensionNames.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryHeap* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryHeap* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryType* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryType* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->propertyFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->heapIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustBufferAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fullDrawIndexUint32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCubeArray)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentBlend)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleRateShading)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dualSrcBlend)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->logicOp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiDrawIndirect)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drawIndirectFirstInstance)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthClamp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasClamp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fillModeNonSolid)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBounds)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->wideLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->largePoints)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaToOne)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiViewport)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerAnisotropy)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureCompressionETC2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureCompressionASTC_LDR)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureCompressionBC)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->occlusionQueryPrecise)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineStatisticsQuery)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexPipelineStoresAndAtomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentStoresAndAtomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTessellationAndGeometryPointSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageGatherExtended)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageExtendedFormats)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageMultisample)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageReadWithoutFormat)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageWriteWithoutFormat)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderClipDistance)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCullDistance)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInt64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInt16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderResourceResidency)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderResourceMinLod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseBinding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseResidencyBuffer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseResidencyImage2D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseResidencyImage3D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseResidency2Samples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseResidency4Samples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseResidency8Samples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseResidency16Samples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseResidencyAliased)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variableMultisampleRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inheritedQueries)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLimits* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLimits* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageDimension1D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageDimension2D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageDimension3D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageDimensionCube)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageArrayLayers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTexelBufferElements)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxUniformBufferRange)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxStorageBufferRange)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPushConstantsSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMemoryAllocationCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSamplerAllocationCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferImageGranularity)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseAddressSpaceSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBoundDescriptorSets)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorInputAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageResources)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUniformBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetStorageBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetInputAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexInputAttributes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexInputBindings)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexInputAttributeOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexInputBindingStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexOutputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTessellationGenerationLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTessellationPatchSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTessellationControlPerVertexInputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTessellationControlPerVertexOutputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTessellationControlPerPatchOutputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTessellationControlTotalOutputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTessellationEvaluationInputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTessellationEvaluationOutputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGeometryShaderInvocations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGeometryInputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGeometryOutputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGeometryOutputVertices)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGeometryTotalOutputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentInputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentOutputAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentDualSrcAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentCombinedOutputResources)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxComputeSharedMemorySize)); + wrapper->maxComputeWorkGroupCount.SetExternalMemory(value->maxComputeWorkGroupCount, 3); + bytes_read += wrapper->maxComputeWorkGroupCount.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxComputeWorkGroupInvocations)); + wrapper->maxComputeWorkGroupSize.SetExternalMemory(value->maxComputeWorkGroupSize, 3); + bytes_read += wrapper->maxComputeWorkGroupSize.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subPixelPrecisionBits)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subTexelPrecisionBits)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mipmapPrecisionBits)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDrawIndexedIndexValue)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDrawIndirectCount)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSamplerLodBias)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSamplerAnisotropy)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxViewports)); + wrapper->maxViewportDimensions.SetExternalMemory(value->maxViewportDimensions, 2); + bytes_read += wrapper->maxViewportDimensions.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->viewportBoundsRange.SetExternalMemory(value->viewportBoundsRange, 2); + bytes_read += wrapper->viewportBoundsRange.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportSubPixelBits)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minMemoryMapAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minTexelBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minUniformBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minStorageBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minTexelOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTexelOffset)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minTexelGatherOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTexelGatherOffset)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minInterpolationOffset)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInterpolationOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subPixelInterpolationOffsetBits)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFramebufferWidth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFramebufferHeight)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFramebufferLayers)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->framebufferColorSampleCounts)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->framebufferDepthSampleCounts)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->framebufferStencilSampleCounts)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->framebufferNoAttachmentsSampleCounts)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxColorAttachments)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampledImageColorSampleCounts)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampledImageIntegerSampleCounts)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampledImageDepthSampleCounts)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampledImageStencilSampleCounts)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageImageSampleCounts)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSampleMaskWords)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timestampComputeAndGraphics)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->timestampPeriod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxClipDistances)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxCullDistances)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxCombinedClipAndCullDistances)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->discreteQueuePriorities)); + wrapper->pointSizeRange.SetExternalMemory(value->pointSizeRange, 2); + bytes_read += wrapper->pointSizeRange.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->lineWidthRange.SetExternalMemory(value->lineWidthRange, 2); + bytes_read += wrapper->lineWidthRange.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pointSizeGranularity)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->lineWidthGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->strictLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->standardSampleLocations)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimalBufferCopyOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimalBufferCopyRowPitchAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonCoherentAtomSize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMemoryProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryTypeCount)); + wrapper->memoryTypes = PreloadDecodeAllocator::Allocate>(); + wrapper->memoryTypes->SetExternalMemory(value->memoryTypes, VK_MAX_MEMORY_TYPES); + bytes_read += wrapper->memoryTypes->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryHeapCount)); + wrapper->memoryHeaps = PreloadDecodeAllocator::Allocate>(); + wrapper->memoryHeaps->SetExternalMemory(value->memoryHeaps, VK_MAX_MEMORY_HEAPS); + bytes_read += wrapper->memoryHeaps->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSparseProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSparseProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->residencyStandard2DBlockShape)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->residencyStandard2DMultisampleBlockShape)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->residencyStandard3DBlockShape)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->residencyAlignedMipSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->residencyNonResidentStrict)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->apiVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceID)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceType)); + wrapper->deviceName.SetExternalMemory(value->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); + bytes_read += wrapper->deviceName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pipelineCacheUUID.SetExternalMemory(value->pipelineCacheUUID, VK_UUID_SIZE); + bytes_read += wrapper->pipelineCacheUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->limits = PreloadDecodeAllocator::Allocate(); + wrapper->limits->decoded_value = &(value->limits); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->limits); + wrapper->sparseProperties = PreloadDecodeAllocator::Allocate(); + wrapper->sparseProperties->decoded_value = &(value->sparseProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sparseProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueueFamilyProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timestampValidBits)); + wrapper->minImageTransferGranularity = PreloadDecodeAllocator::Allocate(); + wrapper->minImageTransferGranularity->decoded_value = &(value->minImageTransferGranularity); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minImageTransferGranularity); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceQueueCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->queueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueCount)); + bytes_read += wrapper->pQueuePriorities.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueuePriorities = wrapper->pQueuePriorities.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->queueCreateInfoCount)); + wrapper->pQueueCreateInfos = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pQueueCreateInfos->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueueCreateInfos = wrapper->pQueueCreateInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enabledLayerCount)); + bytes_read += wrapper->ppEnabledLayerNames.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppEnabledLayerNames = wrapper->ppEnabledLayerNames.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enabledExtensionCount)); + bytes_read += wrapper->ppEnabledExtensionNames.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppEnabledExtensionNames = wrapper->ppEnabledExtensionNames.GetPointer(); + wrapper->pEnabledFeatures = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pEnabledFeatures->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pEnabledFeatures = wrapper->pEnabledFeatures->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExtensionProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExtensionProperties* value = wrapper->decoded_value; + + wrapper->extensionName.SetExternalMemory(value->extensionName, VK_MAX_EXTENSION_NAME_SIZE); + bytes_read += wrapper->extensionName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->specVersion)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLayerProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkLayerProperties* value = wrapper->decoded_value; + + wrapper->layerName.SetExternalMemory(value->layerName, VK_MAX_EXTENSION_NAME_SIZE); + bytes_read += wrapper->layerName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->specVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->implementationVersion)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubmitInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->waitSemaphoreCount)); + bytes_read += wrapper->pWaitSemaphores.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphores = nullptr; + bytes_read += wrapper->pWaitDstStageMask.PreloadDecodeFlags((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitDstStageMask = wrapper->pWaitDstStageMask.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->commandBufferCount)); + bytes_read += wrapper->pCommandBuffers.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCommandBuffers = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreCount)); + bytes_read += wrapper->pSignalSemaphores.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSignalSemaphores = nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMappedMemoryRange* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMappedMemoryRange* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryAllocateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->allocationSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryTypeIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryRequirements* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryRequirements* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->alignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryTypeBits)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseMemoryBind* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseMemoryBind* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->resourceOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseBufferMemoryBindInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseBufferMemoryBindInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bindCount)); + wrapper->pBinds = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pBinds->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBinds = wrapper->pBinds->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageOpaqueMemoryBindInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseImageOpaqueMemoryBindInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); + value->image = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bindCount)); + wrapper->pBinds = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pBinds->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBinds = wrapper->pBinds->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSubresource* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageSubresource* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mipLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->arrayLayer)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageMemoryBind* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseImageMemoryBind* value = wrapper->decoded_value; + + wrapper->subresource = PreloadDecodeAllocator::Allocate(); + wrapper->subresource->decoded_value = &(value->subresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresource); + wrapper->offset = PreloadDecodeAllocator::Allocate(); + wrapper->offset->decoded_value = &(value->offset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->offset); + wrapper->extent = PreloadDecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageMemoryBindInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseImageMemoryBindInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); + value->image = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bindCount)); + wrapper->pBinds = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pBinds->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBinds = wrapper->pBinds->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindSparseInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindSparseInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->waitSemaphoreCount)); + bytes_read += wrapper->pWaitSemaphores.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphores = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferBindCount)); + wrapper->pBufferBinds = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pBufferBinds->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBufferBinds = wrapper->pBufferBinds->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageOpaqueBindCount)); + wrapper->pImageOpaqueBinds = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pImageOpaqueBinds->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImageOpaqueBinds = wrapper->pImageOpaqueBinds->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageBindCount)); + wrapper->pImageBinds = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pImageBinds->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImageBinds = wrapper->pImageBinds->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreCount)); + bytes_read += wrapper->pSignalSemaphores.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSignalSemaphores = nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageFormatProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseImageFormatProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + wrapper->imageGranularity = PreloadDecodeAllocator::Allocate(); + wrapper->imageGranularity->decoded_value = &(value->imageGranularity); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageGranularity); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageMemoryRequirements* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseImageMemoryRequirements* value = wrapper->decoded_value; + + wrapper->formatProperties = PreloadDecodeAllocator::Allocate(); + wrapper->formatProperties->decoded_value = &(value->formatProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->formatProperties); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageMipTailFirstLod)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageMipTailSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageMipTailOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageMipTailStride)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFenceCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFenceCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkEventCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkEventCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueryPoolCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->queryType)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queryCount)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineStatistics)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->size)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sharingMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndexCount)); + bytes_read += wrapper->pQueueFamilyIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueueFamilyIndices = wrapper->pQueueFamilyIndices.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferViewCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferViewCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->range)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->imageType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + wrapper->extent = PreloadDecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mipLevels)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->arrayLayers)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->samples)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tiling)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sharingMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndexCount)); + bytes_read += wrapper->pQueueFamilyIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueueFamilyIndices = wrapper->pQueueFamilyIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialLayout)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubresourceLayout* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubresourceLayout* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rowPitch)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->arrayPitch)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthPitch)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkComponentMapping* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkComponentMapping* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->r)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->g)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->b)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->a)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageViewCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->image)); + value->image = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + wrapper->components = PreloadDecodeAllocator::Allocate(); + wrapper->components->decoded_value = &(value->components); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->components); + wrapper->subresourceRange = PreloadDecodeAllocator::Allocate(); + wrapper->subresourceRange->decoded_value = &(value->subresourceRange); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceRange); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderModuleCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkShaderModuleCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->codeSize)); + bytes_read += wrapper->pCode.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCode = wrapper->pCode.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCacheCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineCacheCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialDataSize)); + bytes_read += wrapper->pInitialData.PreloadDecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pInitialData = wrapper->pInitialData.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSpecializationMapEntry* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSpecializationMapEntry* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->constantID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSpecializationInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSpecializationInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mapEntryCount)); + wrapper->pMapEntries = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pMapEntries->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMapEntries = wrapper->pMapEntries->GetPointer(); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dataSize)); + bytes_read += wrapper->pData.PreloadDecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pData = wrapper->pData.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineShaderStageCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineShaderStageCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->stage)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->module)); + value->module = VK_NULL_HANDLE; + bytes_read += wrapper->pName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pName = wrapper->pName.GetPointer(); + wrapper->pSpecializationInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSpecializationInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSpecializationInfo = wrapper->pSpecializationInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkComputePipelineCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkComputePipelineCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + wrapper->stage = PreloadDecodeAllocator::Allocate(); + wrapper->stage->decoded_value = &(value->stage); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->stage); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->basePipelineHandle)); + value->basePipelineHandle = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->basePipelineIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDescription* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVertexInputBindingDescription* 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->stride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputRate)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputAttributeDescription* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVertexInputAttributeDescription* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->location)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineVertexInputStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineVertexInputStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->vertexBindingDescriptionCount)); + wrapper->pVertexBindingDescriptions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pVertexBindingDescriptions->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVertexBindingDescriptions = wrapper->pVertexBindingDescriptions->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeDescriptionCount)); + wrapper->pVertexAttributeDescriptions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pVertexAttributeDescriptions->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVertexAttributeDescriptions = wrapper->pVertexAttributeDescriptions->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineInputAssemblyStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineInputAssemblyStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->topology)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveRestartEnable)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineTessellationStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineTessellationStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->patchControlPoints)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViewport* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkViewport* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->width)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->height)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minDepth)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDepth)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineViewportStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->viewportCount)); + wrapper->pViewports = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pViewports->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewports = wrapper->pViewports->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->scissorCount)); + wrapper->pScissors = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pScissors->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pScissors = wrapper->pScissors->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineRasterizationStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->depthClampEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizerDiscardEnable)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->polygonMode)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->cullMode)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->frontFace)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasEnable)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasConstantFactor)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasClamp)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasSlopeFactor)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->lineWidth)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineMultisampleStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineMultisampleStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->rasterizationSamples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleShadingEnable)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSampleShading)); + bytes_read += wrapper->pSampleMask.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSampleMask = wrapper->pSampleMask.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaToCoverageEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaToOneEnable)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkStencilOpState* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkStencilOpState* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->failOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->passOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthFailOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compareOp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->compareMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reference)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineDepthStencilStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineDepthStencilStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->depthTestEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthWriteEnable)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthCompareOp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBoundsTestEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilTestEnable)); + wrapper->front = PreloadDecodeAllocator::Allocate(); + wrapper->front->decoded_value = &(value->front); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->front); + wrapper->back = PreloadDecodeAllocator::Allocate(); + wrapper->back->decoded_value = &(value->back); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->back); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minDepthBounds)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDepthBounds)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineColorBlendAttachmentState* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineColorBlendAttachmentState* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->blendEnable)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcColorBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstColorBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorBlendOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAlphaBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAlphaBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaBlendOp)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorWriteMask)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineColorBlendStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineColorBlendStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->logicOpEnable)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->logicOp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentCount)); + wrapper->pAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachments = wrapper->pAttachments->GetPointer(); + wrapper->blendConstants.SetExternalMemory(value->blendConstants, 4); + bytes_read += wrapper->blendConstants.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineDynamicStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineDynamicStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dynamicStateCount)); + bytes_read += wrapper->pDynamicStates.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDynamicStates = wrapper->pDynamicStates.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGraphicsPipelineCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkGraphicsPipelineCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->stageCount)); + wrapper->pStages = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStages->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStages = wrapper->pStages->GetPointer(); + wrapper->pVertexInputState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pVertexInputState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVertexInputState = wrapper->pVertexInputState->GetPointer(); + wrapper->pInputAssemblyState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pInputAssemblyState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pInputAssemblyState = wrapper->pInputAssemblyState->GetPointer(); + wrapper->pTessellationState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pTessellationState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTessellationState = wrapper->pTessellationState->GetPointer(); + wrapper->pViewportState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pViewportState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewportState = wrapper->pViewportState->GetPointer(); + wrapper->pRasterizationState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRasterizationState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRasterizationState = wrapper->pRasterizationState->GetPointer(); + wrapper->pMultisampleState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pMultisampleState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMultisampleState = wrapper->pMultisampleState->GetPointer(); + wrapper->pDepthStencilState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDepthStencilState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthStencilState = wrapper->pDepthStencilState->GetPointer(); + wrapper->pColorBlendState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pColorBlendState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorBlendState = wrapper->pColorBlendState->GetPointer(); + wrapper->pDynamicState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDynamicState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDynamicState = wrapper->pDynamicState->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->renderPass)); + value->renderPass = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpass)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->basePipelineHandle)); + value->basePipelineHandle = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->basePipelineIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushConstantRange* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPushConstantRange* value = wrapper->decoded_value; + + 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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineLayoutCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineLayoutCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->setLayoutCount)); + bytes_read += wrapper->pSetLayouts.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSetLayouts = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushConstantRangeCount)); + wrapper->pPushConstantRanges = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPushConstantRanges->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPushConstantRanges = wrapper->pPushConstantRanges->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->magFilter)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minFilter)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mipmapMode)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressModeU)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressModeV)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressModeW)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mipLodBias)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->anisotropyEnable)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxAnisotropy)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->compareEnable)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compareOp)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minLod)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLod)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->borderColor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->unnormalizedCoordinates)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyDescriptorSet* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCopyDescriptorSet* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcSet)); + value->srcSet = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcBinding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcArrayElement)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstSet)); + value->dstSet = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBinding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstArrayElement)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorBufferInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorBufferInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->range)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorPoolSize* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorPoolSize* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorPoolCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorPoolCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxSets)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->poolSizeCount)); + wrapper->pPoolSizes = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPoolSizes->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPoolSizes = wrapper->pPoolSizes->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetAllocateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->descriptorPool)); + value->descriptorPool = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorSetCount)); + bytes_read += wrapper->pSetLayouts.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSetLayouts = nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutBinding* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetLayoutBinding* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorType)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorCount)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageFlags)); + bytes_read += wrapper->pImmutableSamplers.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImmutableSamplers = nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetLayoutCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->bindingCount)); + wrapper->pBindings = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pBindings->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBindings = wrapper->pBindings->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentDescription* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentDescription* value = wrapper->decoded_value; + + 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->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->samples)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->loadOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storeOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilLoadOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilStoreOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->finalLayout)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentReference* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentReference* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachment)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->layout)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFramebufferCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFramebufferCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->renderPass)); + value->renderPass = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentCount)); + bytes_read += wrapper->pAttachments.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachments = nullptr; + 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->layers)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDescription* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassDescription* value = wrapper->decoded_value; + + 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->pipelineBindPoint)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputAttachmentCount)); + wrapper->pInputAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pInputAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pInputAttachments = wrapper->pInputAttachments->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentCount)); + wrapper->pColorAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pColorAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachments = wrapper->pColorAttachments->GetPointer(); + wrapper->pResolveAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pResolveAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pResolveAttachments = wrapper->pResolveAttachments->GetPointer(); + wrapper->pDepthStencilAttachment = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDepthStencilAttachment->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthStencilAttachment = wrapper->pDepthStencilAttachment->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preserveAttachmentCount)); + bytes_read += wrapper->pPreserveAttachments.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPreserveAttachments = wrapper->pPreserveAttachments.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDependency* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassDependency* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcSubpass)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstSubpass)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcStageMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyFlags)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->attachmentCount)); + wrapper->pAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachments = wrapper->pAttachments->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassCount)); + wrapper->pSubpasses = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSubpasses->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSubpasses = wrapper->pSubpasses->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyCount)); + wrapper->pDependencies = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDependencies->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDependencies = wrapper->pDependencies->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandPoolCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCommandPoolCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->queueFamilyIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCommandBufferAllocateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->commandPool)); + value->commandPool = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->level)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->commandBufferCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCommandBufferInheritanceInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->renderPass)); + value->renderPass = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpass)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->framebuffer)); + value->framebuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->occlusionQueryEnable)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->queryFlags)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineStatistics)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferBeginInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCommandBufferBeginInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + wrapper->pInheritanceInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pInheritanceInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pInheritanceInfo = wrapper->pInheritanceInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferCopy* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferCopy* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSubresourceLayers* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageSubresourceLayers* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mipLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseArrayLayer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layerCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferImageCopy* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferImageCopy* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferRowLength)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferImageHeight)); + wrapper->imageSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->imageSubresource->decoded_value = &(value->imageSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); + wrapper->imageOffset = PreloadDecodeAllocator::Allocate(); + wrapper->imageOffset->decoded_value = &(value->imageOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); + wrapper->imageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearDepthStencilValue* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkClearDepthStencilValue* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencil)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearAttachment* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkClearAttachment* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachment)); + wrapper->clearValue = PreloadDecodeAllocator::Allocate(); + wrapper->clearValue->decoded_value = &(value->clearValue); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->clearValue); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearRect* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkClearRect* value = wrapper->decoded_value; + + wrapper->rect = PreloadDecodeAllocator::Allocate(); + wrapper->rect->decoded_value = &(value->rect); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->rect); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseArrayLayer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layerCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageBlit* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageBlit* value = wrapper->decoded_value; + + wrapper->srcSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->srcSubresource->decoded_value = &(value->srcSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); + wrapper->srcOffsets = PreloadDecodeAllocator::Allocate>(); + wrapper->srcOffsets->SetExternalMemory(value->srcOffsets, 2); + bytes_read += wrapper->srcOffsets->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->dstSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->dstSubresource->decoded_value = &(value->dstSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); + wrapper->dstOffsets = PreloadDecodeAllocator::Allocate>(); + wrapper->dstOffsets->SetExternalMemory(value->dstOffsets, 2); + bytes_read += wrapper->dstOffsets->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCopy* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageCopy* value = wrapper->decoded_value; + + wrapper->srcSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->srcSubresource->decoded_value = &(value->srcSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); + wrapper->srcOffset = PreloadDecodeAllocator::Allocate(); + wrapper->srcOffset->decoded_value = &(value->srcOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcOffset); + wrapper->dstSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->dstSubresource->decoded_value = &(value->dstSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); + wrapper->dstOffset = PreloadDecodeAllocator::Allocate(); + wrapper->dstOffset->decoded_value = &(value->dstOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstOffset); + wrapper->extent = PreloadDecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageResolve* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageResolve* value = wrapper->decoded_value; + + wrapper->srcSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->srcSubresource->decoded_value = &(value->srcSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); + wrapper->srcOffset = PreloadDecodeAllocator::Allocate(); + wrapper->srcOffset->decoded_value = &(value->srcOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcOffset); + wrapper->dstSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->dstSubresource->decoded_value = &(value->dstSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); + wrapper->dstOffset = PreloadDecodeAllocator::Allocate(); + wrapper->dstOffset->decoded_value = &(value->dstOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstOffset); + wrapper->extent = PreloadDecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassBeginInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassBeginInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->renderPass)); + value->renderPass = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->framebuffer)); + value->framebuffer = VK_NULL_HANDLE; + wrapper->renderArea = PreloadDecodeAllocator::Allocate(); + wrapper->renderArea->decoded_value = &(value->renderArea); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderArea); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clearValueCount)); + wrapper->pClearValues = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pClearValues->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pClearValues = wrapper->pClearValues->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSubgroupProperties* 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->subgroupSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedStages)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedOperations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->quadOperationsInAllStages)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindBufferMemoryInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindBufferMemoryInfo* 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->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImageMemoryInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindImageMemoryInfo* 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->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevice16BitStorageFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevice16BitStorageFeatures* 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->storageBuffer16BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer16BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageInputOutput16)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryDedicatedRequirements* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryDedicatedRequirements* 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->prefersDedicatedAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiresDedicatedAllocation)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryDedicatedAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryDedicatedAllocateInfo* 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; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryAllocateFlagsInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryAllocateFlagsInfo* 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->deviceMask)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupRenderPassBeginInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupRenderPassBeginInfo* 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->deviceMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceRenderAreaCount)); + wrapper->pDeviceRenderAreas = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDeviceRenderAreas->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceRenderAreas = wrapper->pDeviceRenderAreas->GetPointer(); return bytes_read; } @@ -4755,14937 +9324,30061 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceG assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceGroupCommandBufferBeginInfo* value = wrapper->decoded_value; + VkDeviceGroupCommandBufferBeginInfo* 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->deviceMask)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupSubmitInfo* 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->waitSemaphoreCount)); + bytes_read += wrapper->pWaitSemaphoreDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphoreDeviceIndices = wrapper->pWaitSemaphoreDeviceIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->commandBufferCount)); + bytes_read += wrapper->pCommandBufferDeviceMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCommandBufferDeviceMasks = wrapper->pCommandBufferDeviceMasks.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreCount)); + bytes_read += wrapper->pSignalSemaphoreDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSignalSemaphoreDeviceIndices = wrapper->pSignalSemaphoreDeviceIndices.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupBindSparseInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupBindSparseInfo* 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->resourceDeviceIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryDeviceIndex)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindBufferMemoryDeviceGroupInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindBufferMemoryDeviceGroupInfo* 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->deviceIndexCount)); + bytes_read += wrapper->pDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceIndices = wrapper->pDeviceIndices.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImageMemoryDeviceGroupInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindImageMemoryDeviceGroupInfo* 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->deviceIndexCount)); + bytes_read += wrapper->pDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceIndices = wrapper->pDeviceIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->splitInstanceBindRegionCount)); + wrapper->pSplitInstanceBindRegions = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSplitInstanceBindRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSplitInstanceBindRegions = wrapper->pSplitInstanceBindRegions->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGroupProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceGroupProperties* 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->physicalDeviceCount)); + wrapper->physicalDevices.SetExternalMemory(value->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE); + bytes_read += wrapper->physicalDevices.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsetAllocation)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupDeviceCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupDeviceCreateInfo* 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->physicalDeviceCount)); + bytes_read += wrapper->pPhysicalDevices.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPhysicalDevices = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferMemoryRequirementsInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferMemoryRequirementsInfo2* 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->buffer)); + value->buffer = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageMemoryRequirementsInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageMemoryRequirementsInfo2* 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; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSparseMemoryRequirementsInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageSparseMemoryRequirementsInfo2* 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; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryRequirements2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryRequirements2* 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->memoryRequirements = DecodeAllocator::Allocate(); + wrapper->memoryRequirements->decoded_value = &(value->memoryRequirements); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryRequirements); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageMemoryRequirements2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseImageMemoryRequirements2* 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->memoryRequirements = DecodeAllocator::Allocate(); + wrapper->memoryRequirements->decoded_value = &(value->memoryRequirements); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryRequirements); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFeatures2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFeatures2* 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->features = DecodeAllocator::Allocate(); + wrapper->features->decoded_value = &(value->features); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->features); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceProperties2* 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->properties = DecodeAllocator::Allocate(); + wrapper->properties->decoded_value = &(value->properties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->properties); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFormatProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFormatProperties2* 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->formatProperties = DecodeAllocator::Allocate(); + wrapper->formatProperties->decoded_value = &(value->formatProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->formatProperties); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageFormatProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageFormatProperties2* 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->imageFormatProperties = DecodeAllocator::Allocate(); + wrapper->imageFormatProperties->decoded_value = &(value->imageFormatProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageFormatProperties); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageFormatInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceImageFormatInfo2* 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->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tiling)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueueFamilyProperties2* 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->queueFamilyProperties = DecodeAllocator::Allocate(); + wrapper->queueFamilyProperties->decoded_value = &(value->queueFamilyProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->queueFamilyProperties); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMemoryProperties2* 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->memoryProperties = DecodeAllocator::Allocate(); + wrapper->memoryProperties->decoded_value = &(value->memoryProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryProperties); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageFormatProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseImageFormatProperties2* 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->properties = DecodeAllocator::Allocate(); + wrapper->properties->decoded_value = &(value->properties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->properties); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSparseImageFormatInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSparseImageFormatInfo2* 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->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->samples)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tiling)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePointClippingProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePointClippingProperties* 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->pointClippingBehavior)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkInputAttachmentAspectReference* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkInputAttachmentAspectReference* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpass)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputAttachmentIndex)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassInputAttachmentAspectCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassInputAttachmentAspectCreateInfo* 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->aspectReferenceCount)); + wrapper->pAspectReferences = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pAspectReferences->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAspectReferences = wrapper->pAspectReferences->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewUsageCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageViewUsageCreateInfo* 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->usage)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineTessellationDomainOriginStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineTessellationDomainOriginStateCreateInfo* 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->domainOrigin)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassMultiviewCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassMultiviewCreateInfo* 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->subpassCount)); + bytes_read += wrapper->pViewMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewMasks = wrapper->pViewMasks.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyCount)); + bytes_read += wrapper->pViewOffsets.DecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewOffsets = wrapper->pViewOffsets.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->correlationMaskCount)); + bytes_read += wrapper->pCorrelationMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCorrelationMasks = wrapper->pCorrelationMasks.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMultiviewFeatures* 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->multiview)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewGeometryShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewTessellationShader)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMultiviewProperties* 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->maxMultiviewViewCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiviewInstanceIndex)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVariablePointersFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVariablePointersFeatures* 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->variablePointersStorageBuffer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variablePointers)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProtectedMemoryFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceProtectedMemoryFeatures* 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->protectedMemory)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProtectedMemoryProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceProtectedMemoryProperties* 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->protectedNoFault)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceQueueInfo2* 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->queueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueIndex)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkProtectedSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkProtectedSubmitInfo* 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->protectedSubmit)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerYcbcrConversionCreateInfo* 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->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrModel)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrRange)); + wrapper->components = DecodeAllocator::Allocate(); + wrapper->components->decoded_value = &(value->components); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->components); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->xChromaOffset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->yChromaOffset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chromaFilter)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->forceExplicitReconstruction)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerYcbcrConversionInfo* 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->conversion)); + value->conversion = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImagePlaneMemoryInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindImagePlaneMemoryInfo* 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->planeAspect)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImagePlaneMemoryRequirementsInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImagePlaneMemoryRequirementsInfo* 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->planeAspect)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSamplerYcbcrConversionFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSamplerYcbcrConversionFeatures* 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->samplerYcbcrConversion)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionImageFormatProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerYcbcrConversionImageFormatProperties* 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->combinedImageSamplerDescriptorCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorUpdateTemplateEntry* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorUpdateTemplateEntry* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBinding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstArrayElement)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorCount)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorType)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorUpdateTemplateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorUpdateTemplateCreateInfo* 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->descriptorUpdateEntryCount)); + wrapper->pDescriptorUpdateEntries = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDescriptorUpdateEntries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDescriptorUpdateEntries = wrapper->pDescriptorUpdateEntries->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->templateType)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->descriptorSetLayout)); + value->descriptorSetLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineBindPoint)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipelineLayout)); + value->pipelineLayout = 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_VkExternalMemoryProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalMemoryProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalMemoryFeatures)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->exportFromImportedHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalImageFormatInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceExternalImageFormatInfo* 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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalImageFormatProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalImageFormatProperties* 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->externalMemoryProperties = DecodeAllocator::Allocate(); + wrapper->externalMemoryProperties->decoded_value = &(value->externalMemoryProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->externalMemoryProperties); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalBufferInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceExternalBufferInfo* 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->usage)); + 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_VkExternalBufferProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalBufferProperties* 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->externalMemoryProperties = DecodeAllocator::Allocate(); + wrapper->externalMemoryProperties->decoded_value = &(value->externalMemoryProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->externalMemoryProperties); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceIDProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceIDProperties* 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->deviceUUID.SetExternalMemory(value->deviceUUID, VK_UUID_SIZE); + bytes_read += wrapper->deviceUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->driverUUID.SetExternalMemory(value->driverUUID, VK_UUID_SIZE); + bytes_read += wrapper->driverUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->deviceLUID.SetExternalMemory(value->deviceLUID, VK_LUID_SIZE); + bytes_read += wrapper->deviceLUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceNodeMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceLUIDValid)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryImageCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalMemoryImageCreateInfo* 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->handleTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryBufferCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalMemoryBufferCreateInfo* 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->handleTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportMemoryAllocateInfo* 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->handleTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFenceInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceExternalFenceInfo* 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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalFenceProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalFenceProperties* 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->exportFromImportedHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFenceFeatures)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportFenceCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportFenceCreateInfo* 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->handleTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportSemaphoreCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportSemaphoreCreateInfo* 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->handleTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalSemaphoreInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceExternalSemaphoreInfo* 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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalSemaphoreProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalSemaphoreProperties* 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->exportFromImportedHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalSemaphoreFeatures)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance3Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance3Properties* 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->maxPerSetDescriptors)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMemoryAllocationSize)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutSupport* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetLayoutSupport* 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->supported)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderDrawParametersFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderDrawParametersFeatures* 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->shaderDrawParameters)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSubgroupProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->subgroupSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedStages)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedOperations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->quadOperationsInAllStages)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindBufferMemoryInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindBufferMemoryInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImageMemoryInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindImageMemoryInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevice16BitStorageFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevice16BitStorageFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->storageBuffer16BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer16BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageInputOutput16)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryDedicatedRequirements* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryDedicatedRequirements* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->prefersDedicatedAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiresDedicatedAllocation)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryDedicatedAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryDedicatedAllocateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryAllocateFlagsInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryAllocateFlagsInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->deviceMask)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupRenderPassBeginInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupRenderPassBeginInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->deviceMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceRenderAreaCount)); + wrapper->pDeviceRenderAreas = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDeviceRenderAreas->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceRenderAreas = wrapper->pDeviceRenderAreas->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupCommandBufferBeginInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupCommandBufferBeginInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->deviceMask)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupSubmitInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->waitSemaphoreCount)); + bytes_read += wrapper->pWaitSemaphoreDeviceIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphoreDeviceIndices = wrapper->pWaitSemaphoreDeviceIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->commandBufferCount)); + bytes_read += wrapper->pCommandBufferDeviceMasks.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCommandBufferDeviceMasks = wrapper->pCommandBufferDeviceMasks.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreCount)); + bytes_read += wrapper->pSignalSemaphoreDeviceIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSignalSemaphoreDeviceIndices = wrapper->pSignalSemaphoreDeviceIndices.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupBindSparseInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupBindSparseInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->resourceDeviceIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryDeviceIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindBufferMemoryDeviceGroupInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindBufferMemoryDeviceGroupInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->deviceIndexCount)); + bytes_read += wrapper->pDeviceIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceIndices = wrapper->pDeviceIndices.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImageMemoryDeviceGroupInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindImageMemoryDeviceGroupInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->deviceIndexCount)); + bytes_read += wrapper->pDeviceIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceIndices = wrapper->pDeviceIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->splitInstanceBindRegionCount)); + wrapper->pSplitInstanceBindRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSplitInstanceBindRegions->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSplitInstanceBindRegions = wrapper->pSplitInstanceBindRegions->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGroupProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceGroupProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->physicalDeviceCount)); + wrapper->physicalDevices.SetExternalMemory(value->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE); + bytes_read += wrapper->physicalDevices.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsetAllocation)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupDeviceCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupDeviceCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->physicalDeviceCount)); + bytes_read += wrapper->pPhysicalDevices.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPhysicalDevices = nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferMemoryRequirementsInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferMemoryRequirementsInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->buffer)); + value->buffer = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageMemoryRequirementsInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageMemoryRequirementsInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSparseMemoryRequirementsInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageSparseMemoryRequirementsInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryRequirements2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryRequirements2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->memoryRequirements = PreloadDecodeAllocator::Allocate(); + wrapper->memoryRequirements->decoded_value = &(value->memoryRequirements); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryRequirements); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageMemoryRequirements2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseImageMemoryRequirements2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->memoryRequirements = PreloadDecodeAllocator::Allocate(); + wrapper->memoryRequirements->decoded_value = &(value->memoryRequirements); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryRequirements); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFeatures2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFeatures2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->features = PreloadDecodeAllocator::Allocate(); + wrapper->features->decoded_value = &(value->features); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->features); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceProperties2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->properties = PreloadDecodeAllocator::Allocate(); + wrapper->properties->decoded_value = &(value->properties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->properties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFormatProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFormatProperties2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->formatProperties = PreloadDecodeAllocator::Allocate(); + wrapper->formatProperties->decoded_value = &(value->formatProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->formatProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageFormatProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageFormatProperties2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->imageFormatProperties = PreloadDecodeAllocator::Allocate(); + wrapper->imageFormatProperties->decoded_value = &(value->imageFormatProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageFormatProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageFormatInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceImageFormatInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tiling)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueueFamilyProperties2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->queueFamilyProperties = PreloadDecodeAllocator::Allocate(); + wrapper->queueFamilyProperties->decoded_value = &(value->queueFamilyProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->queueFamilyProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMemoryProperties2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->memoryProperties = PreloadDecodeAllocator::Allocate(); + wrapper->memoryProperties->decoded_value = &(value->memoryProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageFormatProperties2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSparseImageFormatProperties2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->properties = PreloadDecodeAllocator::Allocate(); + wrapper->properties->decoded_value = &(value->properties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->properties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSparseImageFormatInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSparseImageFormatInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->samples)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tiling)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePointClippingProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePointClippingProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pointClippingBehavior)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkInputAttachmentAspectReference* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkInputAttachmentAspectReference* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpass)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputAttachmentIndex)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassInputAttachmentAspectCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassInputAttachmentAspectCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->aspectReferenceCount)); + wrapper->pAspectReferences = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAspectReferences->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAspectReferences = wrapper->pAspectReferences->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewUsageCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageViewUsageCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->usage)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineTessellationDomainOriginStateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineTessellationDomainOriginStateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->domainOrigin)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassMultiviewCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassMultiviewCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->subpassCount)); + bytes_read += wrapper->pViewMasks.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewMasks = wrapper->pViewMasks.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyCount)); + bytes_read += wrapper->pViewOffsets.PreloadDecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewOffsets = wrapper->pViewOffsets.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->correlationMaskCount)); + bytes_read += wrapper->pCorrelationMasks.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCorrelationMasks = wrapper->pCorrelationMasks.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMultiviewFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->multiview)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewGeometryShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewTessellationShader)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMultiviewProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxMultiviewViewCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiviewInstanceIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVariablePointersFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVariablePointersFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->variablePointersStorageBuffer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variablePointers)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProtectedMemoryFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceProtectedMemoryFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->protectedMemory)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProtectedMemoryProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceProtectedMemoryProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->protectedNoFault)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceQueueInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->queueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkProtectedSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkProtectedSubmitInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->protectedSubmit)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerYcbcrConversionCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrModel)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrRange)); + wrapper->components = PreloadDecodeAllocator::Allocate(); + wrapper->components->decoded_value = &(value->components); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->components); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->xChromaOffset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->yChromaOffset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chromaFilter)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->forceExplicitReconstruction)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerYcbcrConversionInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->conversion)); + value->conversion = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImagePlaneMemoryInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindImagePlaneMemoryInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->planeAspect)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImagePlaneMemoryRequirementsInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImagePlaneMemoryRequirementsInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->planeAspect)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSamplerYcbcrConversionFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSamplerYcbcrConversionFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->samplerYcbcrConversion)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionImageFormatProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerYcbcrConversionImageFormatProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->combinedImageSamplerDescriptorCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorUpdateTemplateEntry* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorUpdateTemplateEntry* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBinding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstArrayElement)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorCount)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorType)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorUpdateTemplateCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorUpdateTemplateCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->descriptorUpdateEntryCount)); + wrapper->pDescriptorUpdateEntries = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDescriptorUpdateEntries->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDescriptorUpdateEntries = wrapper->pDescriptorUpdateEntries->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->templateType)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->descriptorSetLayout)); + value->descriptorSetLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineBindPoint)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipelineLayout)); + value->pipelineLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->set)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalMemoryProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalMemoryFeatures)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->exportFromImportedHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalImageFormatInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceExternalImageFormatInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalImageFormatProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalImageFormatProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->externalMemoryProperties = PreloadDecodeAllocator::Allocate(); + wrapper->externalMemoryProperties->decoded_value = &(value->externalMemoryProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->externalMemoryProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalBufferInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceExternalBufferInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->usage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalBufferProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalBufferProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->externalMemoryProperties = PreloadDecodeAllocator::Allocate(); + wrapper->externalMemoryProperties->decoded_value = &(value->externalMemoryProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->externalMemoryProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceIDProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceIDProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->deviceUUID.SetExternalMemory(value->deviceUUID, VK_UUID_SIZE); + bytes_read += wrapper->deviceUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->driverUUID.SetExternalMemory(value->driverUUID, VK_UUID_SIZE); + bytes_read += wrapper->driverUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->deviceLUID.SetExternalMemory(value->deviceLUID, VK_LUID_SIZE); + bytes_read += wrapper->deviceLUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceNodeMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceLUIDValid)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryImageCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalMemoryImageCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryBufferCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalMemoryBufferCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportMemoryAllocateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFenceInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceExternalFenceInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalFenceProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalFenceProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->exportFromImportedHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFenceFeatures)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportFenceCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportFenceCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportSemaphoreCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportSemaphoreCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalSemaphoreInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceExternalSemaphoreInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalSemaphoreProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalSemaphoreProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->exportFromImportedHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalSemaphoreFeatures)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance3Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance3Properties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxPerSetDescriptors)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMemoryAllocationSize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutSupport* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetLayoutSupport* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->supported)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderDrawParametersFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderDrawParametersFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderDrawParameters)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan11Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan11Features* 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->storageBuffer16BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer16BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageInputOutput16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiview)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewGeometryShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewTessellationShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variablePointersStorageBuffer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variablePointers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->protectedMemory)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerYcbcrConversion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDrawParameters)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan11Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan11Properties* 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->deviceUUID.SetExternalMemory(value->deviceUUID, VK_UUID_SIZE); + bytes_read += wrapper->deviceUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->driverUUID.SetExternalMemory(value->driverUUID, VK_UUID_SIZE); + bytes_read += wrapper->driverUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->deviceLUID.SetExternalMemory(value->deviceLUID, VK_LUID_SIZE); + bytes_read += wrapper->deviceLUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceNodeMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceLUIDValid)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSupportedStages)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSupportedOperations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupQuadOperationsInAllStages)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pointClippingBehavior)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiviewViewCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiviewInstanceIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->protectedNoFault)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerSetDescriptors)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMemoryAllocationSize)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan12Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan12Features* 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->samplerMirrorClampToEdge)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drawIndirectCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageBuffer8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant8)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInt8)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingSampledImageUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageImageUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformTexelBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageTexelBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUpdateUnusedWhilePending)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingPartiallyBound)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingVariableDescriptorCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->runtimeDescriptorArray)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerFilterMinmax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->scalarBlockLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imagelessFramebuffer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformBufferStandardLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupExtendedTypes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateDepthStencilLayouts)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hostQueryReset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timelineSemaphore)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressMultiDevice)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelDeviceScope)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelAvailabilityVisibilityChains)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderOutputViewportIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderOutputLayer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupBroadcastDynamicId)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkConformanceVersion* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkConformanceVersion* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->major)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minor)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subminor)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->patch)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan12Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan12Properties* 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->driverID)); + wrapper->driverName.SetExternalMemory(value->driverName, VK_MAX_DRIVER_NAME_SIZE); + bytes_read += wrapper->driverName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->driverInfo.SetExternalMemory(value->driverInfo, VK_MAX_DRIVER_INFO_SIZE); + bytes_read += wrapper->driverInfo.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->conformanceVersion = DecodeAllocator::Allocate(); + wrapper->conformanceVersion->decoded_value = &(value->conformanceVersion); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->conformanceVersion); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->denormBehaviorIndependence)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->roundingModeIndependence)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxUpdateAfterBindDescriptorsInAllPools)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustBufferAccessUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->quadDivergentImplicitLod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInputAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageUpdateAfterBindResources)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInputAttachments)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedDepthResolveModes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedStencilResolveModes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolveNone)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolve)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterMinmaxSingleComponentFormats)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterMinmaxImageComponentMapping)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTimelineSemaphoreValueDifference)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->framebufferIntegerColorSampleCounts)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageFormatListCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageFormatListCreateInfo* 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->viewFormatCount)); + bytes_read += wrapper->pViewFormats.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewFormats = wrapper->pViewFormats.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentDescription2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentDescription2* 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->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->samples)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->loadOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storeOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilLoadOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilStoreOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->finalLayout)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentReference2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentReference2* 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->attachment)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->layout)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDescription2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassDescription2* 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->pipelineBindPoint)); + 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->inputAttachmentCount)); + wrapper->pInputAttachments = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pInputAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pInputAttachments = wrapper->pInputAttachments->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentCount)); + wrapper->pColorAttachments = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pColorAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachments = wrapper->pColorAttachments->GetPointer(); + wrapper->pResolveAttachments = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pResolveAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pResolveAttachments = wrapper->pResolveAttachments->GetPointer(); + wrapper->pDepthStencilAttachment = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDepthStencilAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthStencilAttachment = wrapper->pDepthStencilAttachment->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preserveAttachmentCount)); + bytes_read += wrapper->pPreserveAttachments.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPreserveAttachments = wrapper->pPreserveAttachments.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDependency2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassDependency2* 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->srcSubpass)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstSubpass)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcStageMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyFlags)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewOffset)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreateInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassCreateInfo2* 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->attachmentCount)); + wrapper->pAttachments = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachments = wrapper->pAttachments->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassCount)); + wrapper->pSubpasses = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSubpasses->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSubpasses = wrapper->pSubpasses->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyCount)); + wrapper->pDependencies = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDependencies->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDependencies = wrapper->pDependencies->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->correlatedViewMaskCount)); + bytes_read += wrapper->pCorrelatedViewMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCorrelatedViewMasks = wrapper->pCorrelatedViewMasks.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassBeginInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassBeginInfo* 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->contents)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassEndInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassEndInfo* 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; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevice8BitStorageFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevice8BitStorageFeatures* 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->storageBuffer8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant8)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDriverProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDriverProperties* 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->driverID)); + wrapper->driverName.SetExternalMemory(value->driverName, VK_MAX_DRIVER_NAME_SIZE); + bytes_read += wrapper->driverName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->driverInfo.SetExternalMemory(value->driverInfo, VK_MAX_DRIVER_INFO_SIZE); + bytes_read += wrapper->driverInfo.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->conformanceVersion = DecodeAllocator::Allocate(); + wrapper->conformanceVersion->decoded_value = &(value->conformanceVersion); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->conformanceVersion); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicInt64Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderAtomicInt64Features* 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->shaderBufferInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedInt64Atomics)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderFloat16Int8Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderFloat16Int8Features* 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->shaderFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInt8)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFloatControlsProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFloatControlsProperties* 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->denormBehaviorIndependence)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->roundingModeIndependence)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat64)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutBindingFlagsCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetLayoutBindingFlagsCreateInfo* 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->bindingCount)); + bytes_read += wrapper->pBindingFlags.DecodeFlags((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBindingFlags = wrapper->pBindingFlags.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorIndexingFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDescriptorIndexingFeatures* 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->shaderInputAttachmentArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingSampledImageUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageImageUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformTexelBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageTexelBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUpdateUnusedWhilePending)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingPartiallyBound)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingVariableDescriptorCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->runtimeDescriptorArray)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorIndexingProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDescriptorIndexingProperties* 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->maxUpdateAfterBindDescriptorsInAllPools)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustBufferAccessUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->quadDivergentImplicitLod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInputAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageUpdateAfterBindResources)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInputAttachments)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetVariableDescriptorCountAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetVariableDescriptorCountAllocateInfo* 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->descriptorSetCount)); + bytes_read += wrapper->pDescriptorCounts.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDescriptorCounts = wrapper->pDescriptorCounts.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetVariableDescriptorCountLayoutSupport* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetVariableDescriptorCountLayoutSupport* 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->maxVariableDescriptorCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDescriptionDepthStencilResolve* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassDescriptionDepthStencilResolve* 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->depthResolveMode)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilResolveMode)); + wrapper->pDepthStencilResolveAttachment = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDepthStencilResolveAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthStencilResolveAttachment = wrapper->pDepthStencilResolveAttachment->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthStencilResolveProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDepthStencilResolveProperties* 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->supportedDepthResolveModes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedStencilResolveModes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolveNone)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolve)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceScalarBlockLayoutFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceScalarBlockLayoutFeatures* 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->scalarBlockLayout)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageStencilUsageCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageStencilUsageCreateInfo* 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->stencilUsage)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerReductionModeCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerReductionModeCreateInfo* 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->reductionMode)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSamplerFilterMinmaxProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSamplerFilterMinmaxProperties* 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->filterMinmaxSingleComponentFormats)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterMinmaxImageComponentMapping)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkanMemoryModelFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkanMemoryModelFeatures* 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->vulkanMemoryModel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelDeviceScope)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelAvailabilityVisibilityChains)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImagelessFramebufferFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceImagelessFramebufferFeatures* 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->imagelessFramebuffer)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFramebufferAttachmentImageInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFramebufferAttachmentImageInfo* 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->usage)); + 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->layerCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewFormatCount)); + bytes_read += wrapper->pViewFormats.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewFormats = wrapper->pViewFormats.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFramebufferAttachmentsCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFramebufferAttachmentsCreateInfo* 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->attachmentImageInfoCount)); + wrapper->pAttachmentImageInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttachmentImageInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachmentImageInfos = wrapper->pAttachmentImageInfos->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassAttachmentBeginInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassAttachmentBeginInfo* 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->attachmentCount)); + bytes_read += wrapper->pAttachments.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachments = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceUniformBufferStandardLayoutFeatures* 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->uniformBufferStandardLayout)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* 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->shaderSubgroupExtendedTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* 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->separateDepthStencilLayouts)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentReferenceStencilLayout* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentReferenceStencilLayout* 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->stencilLayout)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentDescriptionStencilLayout* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentDescriptionStencilLayout* 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->stencilInitialLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilFinalLayout)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostQueryResetFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceHostQueryResetFeatures* 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->hostQueryReset)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTimelineSemaphoreFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTimelineSemaphoreFeatures* 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->timelineSemaphore)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTimelineSemaphoreProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTimelineSemaphoreProperties* 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->maxTimelineSemaphoreValueDifference)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreTypeCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreTypeCreateInfo* 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->semaphoreType)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialValue)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTimelineSemaphoreSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkTimelineSemaphoreSubmitInfo* 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->waitSemaphoreValueCount)); + 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->signalSemaphoreValueCount)); + 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_VkSemaphoreWaitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreWaitInfo* 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->semaphoreCount)); + bytes_read += wrapper->pSemaphores.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSemaphores = nullptr; + bytes_read += wrapper->pValues.DecodeUInt64((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_VkSemaphoreSignalInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreSignalInfo* 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->value)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBufferDeviceAddressFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceBufferDeviceAddressFeatures* 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->bufferDeviceAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressMultiDevice)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferDeviceAddressInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferDeviceAddressInfo* 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->buffer)); + value->buffer = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferOpaqueCaptureAddressCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferOpaqueCaptureAddressCreateInfo* 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->opaqueCaptureAddress)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryOpaqueCaptureAddressAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryOpaqueCaptureAddressAllocateInfo* 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->opaqueCaptureAddress)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceMemoryOpaqueCaptureAddressInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceMemoryOpaqueCaptureAddressInfo* 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; + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan11Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan11Features* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->storageBuffer16BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer16BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageInputOutput16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiview)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewGeometryShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewTessellationShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variablePointersStorageBuffer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variablePointers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->protectedMemory)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerYcbcrConversion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDrawParameters)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan11Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan11Properties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->deviceUUID.SetExternalMemory(value->deviceUUID, VK_UUID_SIZE); + bytes_read += wrapper->deviceUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->driverUUID.SetExternalMemory(value->driverUUID, VK_UUID_SIZE); + bytes_read += wrapper->driverUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->deviceLUID.SetExternalMemory(value->deviceLUID, VK_LUID_SIZE); + bytes_read += wrapper->deviceLUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceNodeMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceLUIDValid)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSupportedStages)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSupportedOperations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupQuadOperationsInAllStages)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pointClippingBehavior)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiviewViewCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiviewInstanceIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->protectedNoFault)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerSetDescriptors)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMemoryAllocationSize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan12Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan12Features* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->samplerMirrorClampToEdge)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drawIndirectCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageBuffer8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant8)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInt8)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingSampledImageUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageImageUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformTexelBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageTexelBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUpdateUnusedWhilePending)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingPartiallyBound)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingVariableDescriptorCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->runtimeDescriptorArray)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerFilterMinmax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->scalarBlockLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imagelessFramebuffer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformBufferStandardLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupExtendedTypes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateDepthStencilLayouts)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hostQueryReset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timelineSemaphore)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressMultiDevice)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelDeviceScope)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelAvailabilityVisibilityChains)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderOutputViewportIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderOutputLayer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupBroadcastDynamicId)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkConformanceVersion* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkConformanceVersion* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->major)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minor)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subminor)); + bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->patch)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan12Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan12Properties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->driverID)); + wrapper->driverName.SetExternalMemory(value->driverName, VK_MAX_DRIVER_NAME_SIZE); + bytes_read += wrapper->driverName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->driverInfo.SetExternalMemory(value->driverInfo, VK_MAX_DRIVER_INFO_SIZE); + bytes_read += wrapper->driverInfo.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->conformanceVersion = PreloadDecodeAllocator::Allocate(); + wrapper->conformanceVersion->decoded_value = &(value->conformanceVersion); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->conformanceVersion); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->denormBehaviorIndependence)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->roundingModeIndependence)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxUpdateAfterBindDescriptorsInAllPools)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustBufferAccessUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->quadDivergentImplicitLod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInputAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageUpdateAfterBindResources)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInputAttachments)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedDepthResolveModes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedStencilResolveModes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolveNone)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolve)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterMinmaxSingleComponentFormats)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterMinmaxImageComponentMapping)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTimelineSemaphoreValueDifference)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->framebufferIntegerColorSampleCounts)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageFormatListCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageFormatListCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->viewFormatCount)); + bytes_read += wrapper->pViewFormats.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewFormats = wrapper->pViewFormats.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentDescription2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentDescription2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->samples)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->loadOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storeOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilLoadOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilStoreOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->finalLayout)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentReference2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentReference2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->attachment)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->layout)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDescription2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassDescription2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pipelineBindPoint)); + 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->inputAttachmentCount)); + wrapper->pInputAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pInputAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pInputAttachments = wrapper->pInputAttachments->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentCount)); + wrapper->pColorAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pColorAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachments = wrapper->pColorAttachments->GetPointer(); + wrapper->pResolveAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pResolveAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pResolveAttachments = wrapper->pResolveAttachments->GetPointer(); + wrapper->pDepthStencilAttachment = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDepthStencilAttachment->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthStencilAttachment = wrapper->pDepthStencilAttachment->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preserveAttachmentCount)); + bytes_read += wrapper->pPreserveAttachments.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPreserveAttachments = wrapper->pPreserveAttachments.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDependency2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassDependency2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcSubpass)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstSubpass)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcStageMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyFlags)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewOffset)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreateInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassCreateInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->attachmentCount)); + wrapper->pAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachments = wrapper->pAttachments->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassCount)); + wrapper->pSubpasses = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSubpasses->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSubpasses = wrapper->pSubpasses->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyCount)); + wrapper->pDependencies = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDependencies->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDependencies = wrapper->pDependencies->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->correlatedViewMaskCount)); + bytes_read += wrapper->pCorrelatedViewMasks.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCorrelatedViewMasks = wrapper->pCorrelatedViewMasks.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassBeginInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassBeginInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->contents)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassEndInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassEndInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevice8BitStorageFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevice8BitStorageFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->storageBuffer8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant8)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDriverProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDriverProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->driverID)); + wrapper->driverName.SetExternalMemory(value->driverName, VK_MAX_DRIVER_NAME_SIZE); + bytes_read += wrapper->driverName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->driverInfo.SetExternalMemory(value->driverInfo, VK_MAX_DRIVER_INFO_SIZE); + bytes_read += wrapper->driverInfo.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->conformanceVersion = PreloadDecodeAllocator::Allocate(); + wrapper->conformanceVersion->decoded_value = &(value->conformanceVersion); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->conformanceVersion); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicInt64Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderAtomicInt64Features* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderBufferInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedInt64Atomics)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderFloat16Int8Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderFloat16Int8Features* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInt8)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFloatControlsProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFloatControlsProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->denormBehaviorIndependence)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->roundingModeIndependence)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat64)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat16)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat32)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat64)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutBindingFlagsCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetLayoutBindingFlagsCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->bindingCount)); + bytes_read += wrapper->pBindingFlags.PreloadDecodeFlags((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBindingFlags = wrapper->pBindingFlags.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorIndexingFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDescriptorIndexingFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderInputAttachmentArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayDynamicIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayNonUniformIndexing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingSampledImageUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageImageUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformTexelBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageTexelBufferUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUpdateUnusedWhilePending)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingPartiallyBound)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingVariableDescriptorCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->runtimeDescriptorArray)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorIndexingProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDescriptorIndexingProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxUpdateAfterBindDescriptorsInAllPools)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexingNative)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustBufferAccessUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->quadDivergentImplicitLod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInputAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageUpdateAfterBindResources)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSampledImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInputAttachments)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetVariableDescriptorCountAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetVariableDescriptorCountAllocateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->descriptorSetCount)); + bytes_read += wrapper->pDescriptorCounts.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDescriptorCounts = wrapper->pDescriptorCounts.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetVariableDescriptorCountLayoutSupport* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorSetVariableDescriptorCountLayoutSupport* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxVariableDescriptorCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDescriptionDepthStencilResolve* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubpassDescriptionDepthStencilResolve* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->depthResolveMode)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilResolveMode)); + wrapper->pDepthStencilResolveAttachment = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDepthStencilResolveAttachment->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthStencilResolveAttachment = wrapper->pDepthStencilResolveAttachment->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthStencilResolveProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDepthStencilResolveProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->supportedDepthResolveModes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedStencilResolveModes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolveNone)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolve)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceScalarBlockLayoutFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceScalarBlockLayoutFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->scalarBlockLayout)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageStencilUsageCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageStencilUsageCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->stencilUsage)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerReductionModeCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerReductionModeCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->reductionMode)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSamplerFilterMinmaxProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSamplerFilterMinmaxProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->filterMinmaxSingleComponentFormats)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterMinmaxImageComponentMapping)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkanMemoryModelFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkanMemoryModelFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->vulkanMemoryModel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelDeviceScope)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelAvailabilityVisibilityChains)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImagelessFramebufferFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceImagelessFramebufferFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->imagelessFramebuffer)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFramebufferAttachmentImageInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFramebufferAttachmentImageInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->usage)); + 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->layerCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewFormatCount)); + bytes_read += wrapper->pViewFormats.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewFormats = wrapper->pViewFormats.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFramebufferAttachmentsCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFramebufferAttachmentsCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->attachmentImageInfoCount)); + wrapper->pAttachmentImageInfos = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttachmentImageInfos->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachmentImageInfos = wrapper->pAttachmentImageInfos->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassAttachmentBeginInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassAttachmentBeginInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->attachmentCount)); + bytes_read += wrapper->pAttachments.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachments = nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceUniformBufferStandardLayoutFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->uniformBufferStandardLayout)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderSubgroupExtendedTypes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->separateDepthStencilLayouts)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentReferenceStencilLayout* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentReferenceStencilLayout* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->stencilLayout)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentDescriptionStencilLayout* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAttachmentDescriptionStencilLayout* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->stencilInitialLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilFinalLayout)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostQueryResetFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceHostQueryResetFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->hostQueryReset)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTimelineSemaphoreFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTimelineSemaphoreFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->timelineSemaphore)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTimelineSemaphoreProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTimelineSemaphoreProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxTimelineSemaphoreValueDifference)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreTypeCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreTypeCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->semaphoreType)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialValue)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTimelineSemaphoreSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkTimelineSemaphoreSubmitInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->waitSemaphoreValueCount)); + bytes_read += wrapper->pWaitSemaphoreValues.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphoreValues = wrapper->pWaitSemaphoreValues.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreValueCount)); + bytes_read += wrapper->pSignalSemaphoreValues.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSignalSemaphoreValues = wrapper->pSignalSemaphoreValues.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreWaitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreWaitInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->semaphoreCount)); + bytes_read += wrapper->pSemaphores.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSemaphores = nullptr; + bytes_read += wrapper->pValues.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pValues = wrapper->pValues.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreSignalInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreSignalInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->value)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBufferDeviceAddressFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceBufferDeviceAddressFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->bufferDeviceAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressMultiDevice)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferDeviceAddressInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferDeviceAddressInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->buffer)); + value->buffer = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferOpaqueCaptureAddressCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferOpaqueCaptureAddressCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->opaqueCaptureAddress)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryOpaqueCaptureAddressAllocateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryOpaqueCaptureAddressAllocateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->opaqueCaptureAddress)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceMemoryOpaqueCaptureAddressInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceMemoryOpaqueCaptureAddressInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan13Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan13Features* 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->robustImageAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inlineUniformBlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingInlineUniformBlockUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineCreationCacheControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->privateData)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDemoteToHelperInvocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTerminateInvocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSizeControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeFullSubgroups)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->synchronization2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureCompressionASTC_HDR)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderZeroInitializeWorkgroupMemory)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicRendering)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderIntegerDotProduct)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maintenance4)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan13Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan13Properties* 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->minSubgroupSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubgroupSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxComputeWorkgroupSubgroups)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiredSubgroupSizeStages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInlineUniformBlockSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInlineUniformTotalSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageTexelBufferOffsetAlignmentBytes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageTexelBufferOffsetSingleTexelAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetAlignmentBytes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetSingleTexelAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBufferSize)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCreationFeedback* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineCreationFeedback* value = wrapper->decoded_value; + + 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->duration)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCreationFeedbackCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineCreationFeedbackCreateInfo* 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->pPipelineCreationFeedback = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pPipelineCreationFeedback->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPipelineCreationFeedback = wrapper->pPipelineCreationFeedback->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineStageCreationFeedbackCount)); + wrapper->pPipelineStageCreationFeedbacks = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pPipelineStageCreationFeedbacks->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPipelineStageCreationFeedbacks = wrapper->pPipelineStageCreationFeedbacks->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTerminateInvocationFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderTerminateInvocationFeatures* 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->shaderTerminateInvocation)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceToolProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceToolProperties* 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_EXTENSION_NAME_SIZE); + bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->version.SetExternalMemory(value->version, VK_MAX_EXTENSION_NAME_SIZE); + bytes_read += wrapper->version.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->purposes)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->layer.SetExternalMemory(value->layer, VK_MAX_EXTENSION_NAME_SIZE); + bytes_read += wrapper->layer.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* 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->shaderDemoteToHelperInvocation)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrivateDataFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePrivateDataFeatures* 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->privateData)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDevicePrivateDataCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDevicePrivateDataCreateInfo* 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->privateDataSlotRequestCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPrivateDataSlotCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPrivateDataSlotCreateInfo* 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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineCreationCacheControlFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePipelineCreationCacheControlFeatures* 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->pipelineCreationCacheControl)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryBarrier2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryBarrier2* 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->srcStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferMemoryBarrier2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferMemoryBarrier2* 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->srcStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageMemoryBarrier2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageMemoryBarrier2* 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->srcStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->oldLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->newLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); + value->image = VK_NULL_HANDLE; + wrapper->subresourceRange = DecodeAllocator::Allocate(); + wrapper->subresourceRange->decoded_value = &(value->subresourceRange); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceRange); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDependencyInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDependencyInfo* 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->dependencyFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryBarrierCount)); + wrapper->pMemoryBarriers = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pMemoryBarriers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMemoryBarriers = wrapper->pMemoryBarriers->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferMemoryBarrierCount)); + wrapper->pBufferMemoryBarriers = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pBufferMemoryBarriers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBufferMemoryBarriers = wrapper->pBufferMemoryBarriers->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageMemoryBarrierCount)); + wrapper->pImageMemoryBarriers = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pImageMemoryBarriers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImageMemoryBarriers = wrapper->pImageMemoryBarriers->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreSubmitInfo* 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->value)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceIndex)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCommandBufferSubmitInfo* 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->commandBuffer)); + value->commandBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceMask)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubmitInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubmitInfo2* 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->waitSemaphoreInfoCount)); + wrapper->pWaitSemaphoreInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pWaitSemaphoreInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphoreInfos = wrapper->pWaitSemaphoreInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->commandBufferInfoCount)); + wrapper->pCommandBufferInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pCommandBufferInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCommandBufferInfos = wrapper->pCommandBufferInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreInfoCount)); + wrapper->pSignalSemaphoreInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSignalSemaphoreInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSignalSemaphoreInfos = wrapper->pSignalSemaphoreInfos->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSynchronization2Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSynchronization2Features* 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->synchronization2)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* 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->shaderZeroInitializeWorkgroupMemory)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageRobustnessFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceImageRobustnessFeatures* 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->robustImageAccess)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferCopy2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferCopy2* 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->srcOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyBufferInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCopyBufferInfo2* 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->srcBuffer)); + value->srcBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstBuffer)); + value->dstBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + 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_VkImageCopy2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageCopy2* 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->srcSubresource = DecodeAllocator::Allocate(); + wrapper->srcSubresource->decoded_value = &(value->srcSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); + wrapper->srcOffset = DecodeAllocator::Allocate(); + wrapper->srcOffset->decoded_value = &(value->srcOffset); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcOffset); + wrapper->dstSubresource = DecodeAllocator::Allocate(); + wrapper->dstSubresource->decoded_value = &(value->dstSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); + wrapper->dstOffset = DecodeAllocator::Allocate(); + wrapper->dstOffset->decoded_value = &(value->dstOffset); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstOffset); + wrapper->extent = DecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCopyImageInfo2* 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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + 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_VkBufferImageCopy2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferImageCopy2* 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->bufferOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferRowLength)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferImageHeight)); + wrapper->imageSubresource = DecodeAllocator::Allocate(); + wrapper->imageSubresource->decoded_value = &(value->imageSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); + wrapper->imageOffset = DecodeAllocator::Allocate(); + wrapper->imageOffset->decoded_value = &(value->imageOffset); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); + wrapper->imageExtent = DecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyBufferToImageInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCopyBufferToImageInfo2* 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->srcBuffer)); + value->srcBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + 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_VkCopyImageToBufferInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCopyImageToBufferInfo2* 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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstBuffer)); + value->dstBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + 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_VkImageBlit2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageBlit2* 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->srcSubresource = DecodeAllocator::Allocate(); + wrapper->srcSubresource->decoded_value = &(value->srcSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); + wrapper->srcOffsets = DecodeAllocator::Allocate>(); + wrapper->srcOffsets->SetExternalMemory(value->srcOffsets, 2); + bytes_read += wrapper->srcOffsets->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->dstSubresource = DecodeAllocator::Allocate(); + wrapper->dstSubresource->decoded_value = &(value->dstSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); + wrapper->dstOffsets = DecodeAllocator::Allocate>(); + wrapper->dstOffsets->SetExternalMemory(value->dstOffsets, 2); + bytes_read += wrapper->dstOffsets->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBlitImageInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBlitImageInfo2* 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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRegions = wrapper->pRegions->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->filter)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageResolve2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageResolve2* 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->srcSubresource = DecodeAllocator::Allocate(); + wrapper->srcSubresource->decoded_value = &(value->srcSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); + wrapper->srcOffset = DecodeAllocator::Allocate(); + wrapper->srcOffset->decoded_value = &(value->srcOffset); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcOffset); + wrapper->dstSubresource = DecodeAllocator::Allocate(); + wrapper->dstSubresource->decoded_value = &(value->dstSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); + wrapper->dstOffset = DecodeAllocator::Allocate(); + wrapper->dstOffset->decoded_value = &(value->dstOffset); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstOffset); + wrapper->extent = DecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkResolveImageInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkResolveImageInfo2* 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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + 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_VkPhysicalDeviceSubgroupSizeControlFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSubgroupSizeControlFeatures* 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->subgroupSizeControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeFullSubgroups)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupSizeControlProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSubgroupSizeControlProperties* 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->minSubgroupSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubgroupSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxComputeWorkgroupSubgroups)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiredSubgroupSizeStages)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* 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->requiredSubgroupSize)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInlineUniformBlockFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceInlineUniformBlockFeatures* 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->inlineUniformBlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingInlineUniformBlockUpdateAfterBind)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInlineUniformBlockProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceInlineUniformBlockProperties* 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->maxInlineUniformBlockSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInlineUniformBlocks)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetInlineUniformBlock* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWriteDescriptorSetInlineUniformBlock* 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->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_VkDescriptorPoolInlineUniformBlockCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorPoolInlineUniformBlockCreateInfo* 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->maxInlineUniformBlockBindings)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTextureCompressionASTCHDRFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTextureCompressionASTCHDRFeatures* 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->textureCompressionASTC_HDR)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingAttachmentInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingAttachmentInfo* 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->resolveMode)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->resolveImageView)); + value->resolveImageView = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->resolveImageLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->loadOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storeOp)); + wrapper->clearValue = DecodeAllocator::Allocate(); + wrapper->clearValue->decoded_value = &(value->clearValue); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->clearValue); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingInfo* 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)); + wrapper->renderArea = DecodeAllocator::Allocate(); + wrapper->renderArea->decoded_value = &(value->renderArea); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderArea); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layerCount)); + 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)); + wrapper->pColorAttachments = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pColorAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachments = wrapper->pColorAttachments->GetPointer(); + wrapper->pDepthAttachment = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDepthAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthAttachment = wrapper->pDepthAttachment->GetPointer(); + wrapper->pStencilAttachment = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStencilAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStencilAttachment = wrapper->pStencilAttachment->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRenderingCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineRenderingCreateInfo* 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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDynamicRenderingFeatures* 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->dynamicRendering)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceRenderingInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCommandBufferInheritanceRenderingInfo* 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->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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationSamples)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerDotProductFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderIntegerDotProductFeatures* 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->shaderIntegerDotProduct)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerDotProductProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderIntegerDotProductProperties* 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->integerDotProduct8BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTexelBufferAlignmentProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTexelBufferAlignmentProperties* 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->storageTexelBufferOffsetAlignmentBytes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageTexelBufferOffsetSingleTexelAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetAlignmentBytes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetSingleTexelAlignment)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFormatProperties3* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFormatProperties3* 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->linearTilingFeatures)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimalTilingFeatures)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferFeatures)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance4Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance4Features* 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->maintenance4)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance4Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance4Properties* 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->maxBufferSize)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceBufferMemoryRequirements* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceBufferMemoryRequirements* 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(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceImageMemoryRequirements* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceImageMemoryRequirements* 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(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->planeAspect)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan13Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan13Features* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->robustImageAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inlineUniformBlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingInlineUniformBlockUpdateAfterBind)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineCreationCacheControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->privateData)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDemoteToHelperInvocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTerminateInvocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSizeControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeFullSubgroups)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->synchronization2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureCompressionASTC_HDR)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderZeroInitializeWorkgroupMemory)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicRendering)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderIntegerDotProduct)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maintenance4)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan13Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVulkan13Properties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->minSubgroupSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubgroupSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxComputeWorkgroupSubgroups)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiredSubgroupSizeStages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInlineUniformBlockSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInlineUniformTotalSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageTexelBufferOffsetAlignmentBytes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageTexelBufferOffsetSingleTexelAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetAlignmentBytes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetSingleTexelAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBufferSize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCreationFeedback* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineCreationFeedback* value = wrapper->decoded_value; + + 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->duration)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCreationFeedbackCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineCreationFeedbackCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pPipelineCreationFeedback = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPipelineCreationFeedback->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPipelineCreationFeedback = wrapper->pPipelineCreationFeedback->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineStageCreationFeedbackCount)); + wrapper->pPipelineStageCreationFeedbacks = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPipelineStageCreationFeedbacks->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPipelineStageCreationFeedbacks = wrapper->pPipelineStageCreationFeedbacks->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTerminateInvocationFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderTerminateInvocationFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderTerminateInvocation)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceToolProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceToolProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->name.SetExternalMemory(value->name, VK_MAX_EXTENSION_NAME_SIZE); + bytes_read += wrapper->name.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->version.SetExternalMemory(value->version, VK_MAX_EXTENSION_NAME_SIZE); + bytes_read += wrapper->version.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->purposes)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->layer.SetExternalMemory(value->layer, VK_MAX_EXTENSION_NAME_SIZE); + bytes_read += wrapper->layer.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderDemoteToHelperInvocation)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrivateDataFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePrivateDataFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->privateData)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDevicePrivateDataCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDevicePrivateDataCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->privateDataSlotRequestCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPrivateDataSlotCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPrivateDataSlotCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineCreationCacheControlFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePipelineCreationCacheControlFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pipelineCreationCacheControl)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryBarrier2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryBarrier2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferMemoryBarrier2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferMemoryBarrier2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageMemoryBarrier2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageMemoryBarrier2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->oldLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->newLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstQueueFamilyIndex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); + value->image = VK_NULL_HANDLE; + wrapper->subresourceRange = PreloadDecodeAllocator::Allocate(); + wrapper->subresourceRange->decoded_value = &(value->subresourceRange); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceRange); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDependencyInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDependencyInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dependencyFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryBarrierCount)); + wrapper->pMemoryBarriers = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pMemoryBarriers->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMemoryBarriers = wrapper->pMemoryBarriers->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferMemoryBarrierCount)); + wrapper->pBufferMemoryBarriers = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pBufferMemoryBarriers->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBufferMemoryBarriers = wrapper->pBufferMemoryBarriers->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageMemoryBarrierCount)); + wrapper->pImageMemoryBarriers = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pImageMemoryBarriers->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImageMemoryBarriers = wrapper->pImageMemoryBarriers->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreSubmitInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->value)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferSubmitInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCommandBufferSubmitInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->commandBuffer)); + value->commandBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceMask)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubmitInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubmitInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->waitSemaphoreInfoCount)); + wrapper->pWaitSemaphoreInfos = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pWaitSemaphoreInfos->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphoreInfos = wrapper->pWaitSemaphoreInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->commandBufferInfoCount)); + wrapper->pCommandBufferInfos = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pCommandBufferInfos->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCommandBufferInfos = wrapper->pCommandBufferInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreInfoCount)); + wrapper->pSignalSemaphoreInfos = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSignalSemaphoreInfos->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSignalSemaphoreInfos = wrapper->pSignalSemaphoreInfos->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSynchronization2Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSynchronization2Features* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->synchronization2)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderZeroInitializeWorkgroupMemory)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageRobustnessFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceImageRobustnessFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->robustImageAccess)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferCopy2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferCopy2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyBufferInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCopyBufferInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcBuffer)); + value->srcBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstBuffer)); + value->dstBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRegions = wrapper->pRegions->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCopy2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageCopy2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->srcSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->srcSubresource->decoded_value = &(value->srcSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); + wrapper->srcOffset = PreloadDecodeAllocator::Allocate(); + wrapper->srcOffset->decoded_value = &(value->srcOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcOffset); + wrapper->dstSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->dstSubresource->decoded_value = &(value->dstSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); + wrapper->dstOffset = PreloadDecodeAllocator::Allocate(); + wrapper->dstOffset->decoded_value = &(value->dstOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstOffset); + wrapper->extent = PreloadDecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCopyImageInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRegions = wrapper->pRegions->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferImageCopy2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferImageCopy2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->bufferOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferRowLength)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferImageHeight)); + wrapper->imageSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->imageSubresource->decoded_value = &(value->imageSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); + wrapper->imageOffset = PreloadDecodeAllocator::Allocate(); + wrapper->imageOffset->decoded_value = &(value->imageOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); + wrapper->imageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyBufferToImageInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCopyBufferToImageInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcBuffer)); + value->srcBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRegions = wrapper->pRegions->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageToBufferInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCopyImageToBufferInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstBuffer)); + value->dstBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRegions = wrapper->pRegions->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageBlit2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageBlit2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->srcSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->srcSubresource->decoded_value = &(value->srcSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); + wrapper->srcOffsets = PreloadDecodeAllocator::Allocate>(); + wrapper->srcOffsets->SetExternalMemory(value->srcOffsets, 2); + bytes_read += wrapper->srcOffsets->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->dstSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->dstSubresource->decoded_value = &(value->dstSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); + wrapper->dstOffsets = PreloadDecodeAllocator::Allocate>(); + wrapper->dstOffsets->SetExternalMemory(value->dstOffsets, 2); + bytes_read += wrapper->dstOffsets->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBlitImageInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBlitImageInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRegions = wrapper->pRegions->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->filter)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageResolve2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageResolve2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->srcSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->srcSubresource->decoded_value = &(value->srcSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); + wrapper->srcOffset = PreloadDecodeAllocator::Allocate(); + wrapper->srcOffset->decoded_value = &(value->srcOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcOffset); + wrapper->dstSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->dstSubresource->decoded_value = &(value->dstSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); + wrapper->dstOffset = PreloadDecodeAllocator::Allocate(); + wrapper->dstOffset->decoded_value = &(value->dstOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstOffset); + wrapper->extent = PreloadDecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->extent); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkResolveImageInfo2* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkResolveImageInfo2* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRegions = wrapper->pRegions->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupSizeControlFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSubgroupSizeControlFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->subgroupSizeControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeFullSubgroups)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupSizeControlProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSubgroupSizeControlProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->minSubgroupSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubgroupSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxComputeWorkgroupSubgroups)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiredSubgroupSizeStages)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->requiredSubgroupSize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInlineUniformBlockFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceInlineUniformBlockFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->inlineUniformBlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingInlineUniformBlockUpdateAfterBind)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInlineUniformBlockProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceInlineUniformBlockProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxInlineUniformBlockSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInlineUniformBlocks)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetInlineUniformBlock* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWriteDescriptorSetInlineUniformBlock* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dataSize)); + bytes_read += wrapper->pData.PreloadDecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pData = wrapper->pData.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorPoolInlineUniformBlockCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDescriptorPoolInlineUniformBlockCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxInlineUniformBlockBindings)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTextureCompressionASTCHDRFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTextureCompressionASTCHDRFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->textureCompressionASTC_HDR)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingAttachmentInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingAttachmentInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->resolveMode)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->resolveImageView)); + value->resolveImageView = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->resolveImageLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->loadOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storeOp)); + wrapper->clearValue = PreloadDecodeAllocator::Allocate(); + wrapper->clearValue->decoded_value = &(value->clearValue); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->clearValue); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + wrapper->renderArea = PreloadDecodeAllocator::Allocate(); + wrapper->renderArea->decoded_value = &(value->renderArea); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderArea); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layerCount)); + 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)); + wrapper->pColorAttachments = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pColorAttachments->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachments = wrapper->pColorAttachments->GetPointer(); + wrapper->pDepthAttachment = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDepthAttachment->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthAttachment = wrapper->pDepthAttachment->GetPointer(); + wrapper->pStencilAttachment = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStencilAttachment->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStencilAttachment = wrapper->pStencilAttachment->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRenderingCreateInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineRenderingCreateInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecodeEnum((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDynamicRenderingFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dynamicRendering)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceRenderingInfo* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCommandBufferInheritanceRenderingInfo* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->viewMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentCount)); + bytes_read += wrapper->pColorAttachmentFormats.PreloadDecodeEnum((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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationSamples)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerDotProductFeatures* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderIntegerDotProductFeatures* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderIntegerDotProduct)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerDotProductProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderIntegerDotProductProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->integerDotProduct8BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitSignedAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTexelBufferAlignmentProperties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTexelBufferAlignmentProperties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->storageTexelBufferOffsetAlignmentBytes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageTexelBufferOffsetSingleTexelAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetAlignmentBytes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetSingleTexelAlignment)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFormatProperties3* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFormatProperties3* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->linearTilingFeatures)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimalTilingFeatures)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferFeatures)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance4Features* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance4Features* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maintenance4)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance4Properties* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance4Properties* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxBufferSize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceBufferMemoryRequirements* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceBufferMemoryRequirements* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pCreateInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pCreateInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCreateInfo = wrapper->pCreateInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceImageMemoryRequirements* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceImageMemoryRequirements* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pCreateInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pCreateInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCreateInfo = wrapper->pCreateInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->planeAspect)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSurfaceCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImageCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageCount)); + wrapper->currentExtent = DecodeAllocator::Allocate(); + wrapper->currentExtent->decoded_value = &(value->currentExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->currentExtent); + wrapper->minImageExtent = DecodeAllocator::Allocate(); + wrapper->minImageExtent->decoded_value = &(value->minImageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minImageExtent); + wrapper->maxImageExtent = DecodeAllocator::Allocate(); + wrapper->maxImageExtent->decoded_value = &(value->maxImageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxImageExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageArrayLayers)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedTransforms)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->currentTransform)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedCompositeAlpha)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedUsageFlags)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFormatKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSurfaceFormatKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorSpace)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSurfaceCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImageCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageCount)); + wrapper->currentExtent = PreloadDecodeAllocator::Allocate(); + wrapper->currentExtent->decoded_value = &(value->currentExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->currentExtent); + wrapper->minImageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->minImageExtent->decoded_value = &(value->minImageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minImageExtent); + wrapper->maxImageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->maxImageExtent->decoded_value = &(value->maxImageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxImageExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageArrayLayers)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedTransforms)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->currentTransform)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedCompositeAlpha)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedUsageFlags)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFormatKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSurfaceFormatKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorSpace)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSwapchainCreateInfoKHR* 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->surface)); + value->surface = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImageCount)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageFormat)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageColorSpace)); + wrapper->imageExtent = DecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageArrayLayers)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageUsage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageSharingMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndexCount)); + bytes_read += wrapper->pQueueFamilyIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueueFamilyIndices = wrapper->pQueueFamilyIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->preTransform)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compositeAlpha)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clipped)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->oldSwapchain)); + value->oldSwapchain = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPresentInfoKHR* 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->waitSemaphoreCount)); + bytes_read += wrapper->pWaitSemaphores.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphores = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); + bytes_read += wrapper->pSwapchains.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSwapchains = nullptr; + bytes_read += wrapper->pImageIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImageIndices = wrapper->pImageIndices.GetPointer(); + bytes_read += wrapper->pResults.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pResults = wrapper->pResults.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSwapchainCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageSwapchainCreateInfoKHR* 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->swapchain)); + value->swapchain = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImageMemorySwapchainInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindImageMemorySwapchainInfoKHR* 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->swapchain)); + value->swapchain = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageIndex)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcquireNextImageInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAcquireNextImageInfoKHR* 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->swapchain)); + value->swapchain = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); + value->semaphore = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); + value->fence = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceMask)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupPresentCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupPresentCapabilitiesKHR* 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->presentMask.SetExternalMemory(value->presentMask, VK_MAX_DEVICE_GROUP_SIZE); + bytes_read += wrapper->presentMask.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->modes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupPresentInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupPresentInfoKHR* 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->pDeviceMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceMasks = wrapper->pDeviceMasks.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupSwapchainCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupSwapchainCreateInfoKHR* 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->modes)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSwapchainCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->surface)); + value->surface = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImageCount)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageFormat)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageColorSpace)); + wrapper->imageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageArrayLayers)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageUsage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageSharingMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndexCount)); + bytes_read += wrapper->pQueueFamilyIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueueFamilyIndices = wrapper->pQueueFamilyIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->preTransform)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compositeAlpha)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clipped)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->oldSwapchain)); + value->oldSwapchain = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPresentInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->waitSemaphoreCount)); + bytes_read += wrapper->pWaitSemaphores.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pWaitSemaphores = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); + bytes_read += wrapper->pSwapchains.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSwapchains = nullptr; + bytes_read += wrapper->pImageIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImageIndices = wrapper->pImageIndices.GetPointer(); + bytes_read += wrapper->pResults.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pResults = wrapper->pResults.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSwapchainCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageSwapchainCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->swapchain)); + value->swapchain = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImageMemorySwapchainInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindImageMemorySwapchainInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->swapchain)); + value->swapchain = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcquireNextImageInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAcquireNextImageInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->swapchain)); + value->swapchain = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); + value->semaphore = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); + value->fence = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceMask)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupPresentCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupPresentCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->presentMask.SetExternalMemory(value->presentMask, VK_MAX_DEVICE_GROUP_SIZE); + bytes_read += wrapper->presentMask.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->modes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupPresentInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupPresentInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pDeviceMasks.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceMasks = wrapper->pDeviceMasks.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupSwapchainCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceGroupSwapchainCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->modes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModeParametersKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayModeParametersKHR* value = wrapper->decoded_value; + + wrapper->visibleRegion = DecodeAllocator::Allocate(); + wrapper->visibleRegion->decoded_value = &(value->visibleRegion); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->visibleRegion); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refreshRate)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModeCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayModeCreateInfoKHR* 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)); + wrapper->parameters = DecodeAllocator::Allocate(); + wrapper->parameters->decoded_value = &(value->parameters); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->parameters); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModePropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayModePropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->displayMode)); + value->displayMode = VK_NULL_HANDLE; + wrapper->parameters = DecodeAllocator::Allocate(); + wrapper->parameters->decoded_value = &(value->parameters); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->parameters); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPlaneCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedAlpha)); + wrapper->minSrcPosition = DecodeAllocator::Allocate(); + wrapper->minSrcPosition->decoded_value = &(value->minSrcPosition); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minSrcPosition); + wrapper->maxSrcPosition = DecodeAllocator::Allocate(); + wrapper->maxSrcPosition->decoded_value = &(value->maxSrcPosition); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSrcPosition); + wrapper->minSrcExtent = DecodeAllocator::Allocate(); + wrapper->minSrcExtent->decoded_value = &(value->minSrcExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minSrcExtent); + wrapper->maxSrcExtent = DecodeAllocator::Allocate(); + wrapper->maxSrcExtent->decoded_value = &(value->maxSrcExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSrcExtent); + wrapper->minDstPosition = DecodeAllocator::Allocate(); + wrapper->minDstPosition->decoded_value = &(value->minDstPosition); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minDstPosition); + wrapper->maxDstPosition = DecodeAllocator::Allocate(); + wrapper->maxDstPosition->decoded_value = &(value->maxDstPosition); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxDstPosition); + wrapper->minDstExtent = DecodeAllocator::Allocate(); + wrapper->minDstExtent->decoded_value = &(value->minDstExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minDstExtent); + wrapper->maxDstExtent = DecodeAllocator::Allocate(); + wrapper->maxDstExtent->decoded_value = &(value->maxDstExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxDstExtent); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlanePropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPlanePropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->currentDisplay)); + value->currentDisplay = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->currentStackIndex)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->display)); + value->display = VK_NULL_HANDLE; + bytes_read += wrapper->displayName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->displayName = wrapper->displayName.GetPointer(); + wrapper->physicalDimensions = DecodeAllocator::Allocate(); + wrapper->physicalDimensions->decoded_value = &(value->physicalDimensions); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->physicalDimensions); + wrapper->physicalResolution = DecodeAllocator::Allocate(); + wrapper->physicalResolution->decoded_value = &(value->physicalResolution); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->physicalResolution); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedTransforms)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->planeReorderPossible)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->persistentContent)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplaySurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplaySurfaceCreateInfoKHR* 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->displayMode)); + value->displayMode = 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->planeStackIndex)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transform)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalAlpha)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaMode)); + wrapper->imageExtent = DecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModeParametersKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayModeParametersKHR* value = wrapper->decoded_value; + + wrapper->visibleRegion = PreloadDecodeAllocator::Allocate(); + wrapper->visibleRegion->decoded_value = &(value->visibleRegion); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->visibleRegion); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refreshRate)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModeCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayModeCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + wrapper->parameters = PreloadDecodeAllocator::Allocate(); + wrapper->parameters->decoded_value = &(value->parameters); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->parameters); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModePropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayModePropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->displayMode)); + value->displayMode = VK_NULL_HANDLE; + wrapper->parameters = PreloadDecodeAllocator::Allocate(); + wrapper->parameters->decoded_value = &(value->parameters); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->parameters); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPlaneCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedAlpha)); + wrapper->minSrcPosition = PreloadDecodeAllocator::Allocate(); + wrapper->minSrcPosition->decoded_value = &(value->minSrcPosition); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minSrcPosition); + wrapper->maxSrcPosition = PreloadDecodeAllocator::Allocate(); + wrapper->maxSrcPosition->decoded_value = &(value->maxSrcPosition); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSrcPosition); + wrapper->minSrcExtent = PreloadDecodeAllocator::Allocate(); + wrapper->minSrcExtent->decoded_value = &(value->minSrcExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minSrcExtent); + wrapper->maxSrcExtent = PreloadDecodeAllocator::Allocate(); + wrapper->maxSrcExtent->decoded_value = &(value->maxSrcExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSrcExtent); + wrapper->minDstPosition = PreloadDecodeAllocator::Allocate(); + wrapper->minDstPosition->decoded_value = &(value->minDstPosition); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minDstPosition); + wrapper->maxDstPosition = PreloadDecodeAllocator::Allocate(); + wrapper->maxDstPosition->decoded_value = &(value->maxDstPosition); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxDstPosition); + wrapper->minDstExtent = PreloadDecodeAllocator::Allocate(); + wrapper->minDstExtent->decoded_value = &(value->minDstExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minDstExtent); + wrapper->maxDstExtent = PreloadDecodeAllocator::Allocate(); + wrapper->maxDstExtent->decoded_value = &(value->maxDstExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxDstExtent); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlanePropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPlanePropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->currentDisplay)); + value->currentDisplay = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->currentStackIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->display)); + value->display = VK_NULL_HANDLE; + bytes_read += wrapper->displayName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->displayName = wrapper->displayName.GetPointer(); + wrapper->physicalDimensions = PreloadDecodeAllocator::Allocate(); + wrapper->physicalDimensions->decoded_value = &(value->physicalDimensions); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->physicalDimensions); + wrapper->physicalResolution = PreloadDecodeAllocator::Allocate(); + wrapper->physicalResolution->decoded_value = &(value->physicalResolution); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->physicalResolution); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedTransforms)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->planeReorderPossible)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->persistentContent)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplaySurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplaySurfaceCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->displayMode)); + value->displayMode = 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->planeStackIndex)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transform)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalAlpha)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaMode)); + wrapper->imageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPresentInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPresentInfoKHR* 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->srcRect = DecodeAllocator::Allocate(); + wrapper->srcRect->decoded_value = &(value->srcRect); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcRect); + wrapper->dstRect = DecodeAllocator::Allocate(); + wrapper->dstRect->decoded_value = &(value->dstRect); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstRect); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->persistent)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPresentInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPresentInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->srcRect = PreloadDecodeAllocator::Allocate(); + wrapper->srcRect->decoded_value = &(value->srcRect); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcRect); + wrapper->dstRect = PreloadDecodeAllocator::Allocate(); + wrapper->dstRect->decoded_value = &(value->dstRect); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstRect); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->persistent)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkXlibSurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkXlibSurfaceCreateInfoKHR* 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->dpy)); + value->dpy = nullptr; + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->window)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkXlibSurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkXlibSurfaceCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dpy)); + value->dpy = nullptr; + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->window)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkXcbSurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkXcbSurfaceCreateInfoKHR* 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->connection)); + value->connection = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->window)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkXcbSurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkXcbSurfaceCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->connection)); + value->connection = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->window)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWaylandSurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWaylandSurfaceCreateInfoKHR* 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->display)); + value->display = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->surface)); + value->surface = nullptr; + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWaylandSurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWaylandSurfaceCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->display)); + value->display = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->surface)); + value->surface = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidSurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAndroidSurfaceCreateInfoKHR* 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->window)); + value->window = nullptr; + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidSurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAndroidSurfaceCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->window)); + value->window = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32SurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWin32SurfaceCreateInfoKHR* 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->hinstance)); + value->hinstance = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->hwnd)); + value->hwnd = nullptr; + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32SurfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWin32SurfaceCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->hinstance)); + value->hinstance = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->hwnd)); + value->hwnd = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyQueryResultStatusPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueueFamilyQueryResultStatusPropertiesKHR* 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->queryResultStatusSupport)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyVideoPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueueFamilyVideoPropertiesKHR* 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->videoCodecOperations)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoProfileInfoKHR* 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->videoCodecOperation)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chromaSubsampling)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->lumaBitDepth)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chromaBitDepth)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoProfileListInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoProfileListInfoKHR* 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->profileCount)); + wrapper->pProfiles = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pProfiles->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pProfiles = wrapper->pProfiles->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoCapabilitiesKHR* 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->minBitstreamBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minBitstreamBufferSizeAlignment)); + wrapper->pictureAccessGranularity = DecodeAllocator::Allocate(); + wrapper->pictureAccessGranularity->decoded_value = &(value->pictureAccessGranularity); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->pictureAccessGranularity); + wrapper->minCodedExtent = DecodeAllocator::Allocate(); + wrapper->minCodedExtent->decoded_value = &(value->minCodedExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minCodedExtent); + wrapper->maxCodedExtent = DecodeAllocator::Allocate(); + wrapper->maxCodedExtent->decoded_value = &(value->maxCodedExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxCodedExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDpbSlots)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxActiveReferencePictures)); + wrapper->stdHeaderVersion = DecodeAllocator::Allocate(); + wrapper->stdHeaderVersion->decoded_value = &(value->stdHeaderVersion); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->stdHeaderVersion); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoFormatInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVideoFormatInfoKHR* 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->imageUsage)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoFormatPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoFormatPropertiesKHR* 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->format)); + wrapper->componentMapping = DecodeAllocator::Allocate(); + wrapper->componentMapping->decoded_value = &(value->componentMapping); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->componentMapping); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCreateFlags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageTiling)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageUsageFlags)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoPictureResourceInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoPictureResourceInfoKHR* 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->codedOffset = DecodeAllocator::Allocate(); + wrapper->codedOffset->decoded_value = &(value->codedOffset); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->codedOffset); + wrapper->codedExtent = DecodeAllocator::Allocate(); + wrapper->codedExtent->decoded_value = &(value->codedExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->codedExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseArrayLayer)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->imageViewBinding)); + value->imageViewBinding = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoReferenceSlotInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoReferenceSlotInfoKHR* 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->slotIndex)); + wrapper->pPictureResource = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pPictureResource->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPictureResource = wrapper->pPictureResource->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionMemoryRequirementsKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoSessionMemoryRequirementsKHR* 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->memoryBindIndex)); + wrapper->memoryRequirements = DecodeAllocator::Allocate(); + wrapper->memoryRequirements->decoded_value = &(value->memoryRequirements); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryRequirements); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindVideoSessionMemoryInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindVideoSessionMemoryInfoKHR* 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->memoryBindIndex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memorySize)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoSessionCreateInfoKHR* 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + wrapper->pVideoProfile = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pVideoProfile->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVideoProfile = wrapper->pVideoProfile->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pictureFormat)); + wrapper->maxCodedExtent = DecodeAllocator::Allocate(); + wrapper->maxCodedExtent->decoded_value = &(value->maxCodedExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxCodedExtent); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->referencePictureFormat)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDpbSlots)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxActiveReferencePictures)); + wrapper->pStdHeaderVersion = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdHeaderVersion->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdHeaderVersion = wrapper->pStdHeaderVersion->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoSessionParametersCreateInfoKHR* 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->videoSessionParametersTemplate)); + value->videoSessionParametersTemplate = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->videoSession)); + value->videoSession = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionParametersUpdateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoSessionParametersUpdateInfoKHR* 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->updateSequenceCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoBeginCodingInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoBeginCodingInfoKHR* 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->videoSession)); + value->videoSession = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->videoSessionParameters)); + value->videoSessionParameters = VK_NULL_HANDLE; + 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(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEndCodingInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEndCodingInfoKHR* 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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoCodingControlInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoCodingControlInfoKHR* 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)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyQueryResultStatusPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueueFamilyQueryResultStatusPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->queryResultStatusSupport)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyVideoPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueueFamilyVideoPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->videoCodecOperations)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoProfileInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->videoCodecOperation)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chromaSubsampling)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->lumaBitDepth)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chromaBitDepth)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoProfileListInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoProfileListInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->profileCount)); + wrapper->pProfiles = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pProfiles->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pProfiles = wrapper->pProfiles->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->minBitstreamBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minBitstreamBufferSizeAlignment)); + wrapper->pictureAccessGranularity = PreloadDecodeAllocator::Allocate(); + wrapper->pictureAccessGranularity->decoded_value = &(value->pictureAccessGranularity); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->pictureAccessGranularity); + wrapper->minCodedExtent = PreloadDecodeAllocator::Allocate(); + wrapper->minCodedExtent->decoded_value = &(value->minCodedExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minCodedExtent); + wrapper->maxCodedExtent = PreloadDecodeAllocator::Allocate(); + wrapper->maxCodedExtent->decoded_value = &(value->maxCodedExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxCodedExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDpbSlots)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxActiveReferencePictures)); + wrapper->stdHeaderVersion = PreloadDecodeAllocator::Allocate(); + wrapper->stdHeaderVersion->decoded_value = &(value->stdHeaderVersion); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->stdHeaderVersion); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoFormatInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVideoFormatInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->imageUsage)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoFormatPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoFormatPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->format)); + wrapper->componentMapping = PreloadDecodeAllocator::Allocate(); + wrapper->componentMapping->decoded_value = &(value->componentMapping); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->componentMapping); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCreateFlags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageTiling)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageUsageFlags)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoPictureResourceInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoPictureResourceInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->codedOffset = PreloadDecodeAllocator::Allocate(); + wrapper->codedOffset->decoded_value = &(value->codedOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->codedOffset); + wrapper->codedExtent = PreloadDecodeAllocator::Allocate(); + wrapper->codedExtent->decoded_value = &(value->codedExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->codedExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseArrayLayer)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->imageViewBinding)); + value->imageViewBinding = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoReferenceSlotInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoReferenceSlotInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->slotIndex)); + wrapper->pPictureResource = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPictureResource->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPictureResource = wrapper->pPictureResource->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionMemoryRequirementsKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoSessionMemoryRequirementsKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->memoryBindIndex)); + wrapper->memoryRequirements = PreloadDecodeAllocator::Allocate(); + wrapper->memoryRequirements->decoded_value = &(value->memoryRequirements); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryRequirements); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindVideoSessionMemoryInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindVideoSessionMemoryInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->memoryBindIndex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memorySize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoSessionCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + wrapper->pVideoProfile = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pVideoProfile->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVideoProfile = wrapper->pVideoProfile->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pictureFormat)); + wrapper->maxCodedExtent = PreloadDecodeAllocator::Allocate(); + wrapper->maxCodedExtent->decoded_value = &(value->maxCodedExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxCodedExtent); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->referencePictureFormat)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDpbSlots)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxActiveReferencePictures)); + wrapper->pStdHeaderVersion = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdHeaderVersion->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdHeaderVersion = wrapper->pStdHeaderVersion->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoSessionParametersCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->videoSessionParametersTemplate)); + value->videoSessionParametersTemplate = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->videoSession)); + value->videoSession = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionParametersUpdateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoSessionParametersUpdateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->updateSequenceCount)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoBeginCodingInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoBeginCodingInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->videoSession)); + value->videoSession = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->videoSessionParameters)); + value->videoSessionParameters = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->referenceSlotCount)); + wrapper->pReferenceSlots = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pReferenceSlots->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pReferenceSlots = wrapper->pReferenceSlots->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEndCodingInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEndCodingInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoCodingControlInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoCodingControlInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeCapabilitiesKHR* 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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeUsageInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeUsageInfoKHR* 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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeInfoKHR* 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->srcBuffer)); + value->srcBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcBufferOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcBufferRange)); + wrapper->dstPictureResource = DecodeAllocator::Allocate(); + wrapper->dstPictureResource->decoded_value = &(value->dstPictureResource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstPictureResource); + 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(); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeUsageInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeUsageInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->srcBuffer)); + value->srcBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcBufferOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcBufferRange)); + wrapper->dstPictureResource = PreloadDecodeAllocator::Allocate(); + wrapper->dstPictureResource->decoded_value = &(value->dstPictureResource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstPictureResource); + wrapper->pSetupReferenceSlot = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSetupReferenceSlot->PreloadDecode((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pReferenceSlots->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pReferenceSlots = wrapper->pReferenceSlots->GetPointer(); + + return bytes_read; +} + +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; + 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::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::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeUInt32Value((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_VkVideoEncodeH264QpKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeUInt32Value((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::DecodeUInt32Value((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_VkVideoEncodeH264SessionParametersAddInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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)); + 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(); + + return bytes_read; +} + +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; + 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>(); + 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_VkVideoEncodeH264SessionParametersGetInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdSPS)); + bytes_read += ValueDecoder::DecodeUInt32Value((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_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdSPSOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); + + return bytes_read; +} + +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; + 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::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_VkVideoEncodeH264PictureInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->generatePrefixNalu)); + + return bytes_read; +} + +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; + 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; + 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_VkVideoEncodeH264ProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoEncodeH264RateControlInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoEncodeH264FrameSizeKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264FrameSizeKHR* 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_VkVideoEncodeH264RateControlLayerInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->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::DecodeUInt32Value((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::DecodeUInt32Value((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_VkVideoEncodeH264GopRemainingFrameInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeUInt32Value((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264CapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264CapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeUInt32Value((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QpKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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 PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate(); + wrapper->preferredConstantQp->decoded_value = &(value->preferredConstantQp); + bytes_read += PreloadDecodeStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredStdEntropyCodingModeFlag)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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->useMaxLevelIdc)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersAddInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264SessionParametersAddInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSPSs->PreloadDecode((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPPSs->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pParametersAddInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersGetInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264SessionParametersGetInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->writeStdSPS)); + bytes_read += ValueDecoder::DecodeUInt32Value((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264SessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->hasStdSPSOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264NaluSliceInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264NaluSliceInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSliceHeader->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdSliceHeader = wrapper->pStdSliceHeader->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264PictureInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264PictureInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pNaluSliceEntries->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pNaluSliceEntries = wrapper->pNaluSliceEntries->GetPointer(); + wrapper->pStdPictureInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPictureInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->generatePrefixNalu)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264DpbSlotInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264DpbSlotInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdReferenceInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdReferenceInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264ProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264ProfileInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264RateControlInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264FrameSizeKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264FrameSizeKHR* 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlLayerInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264RateControlLayerInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->useMinQp)); + wrapper->minQp = PreloadDecodeAllocator::Allocate(); + wrapper->minQp->decoded_value = &(value->minQp); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minQp); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxQp)); + wrapper->maxQp = PreloadDecodeAllocator::Allocate(); + wrapper->maxQp->decoded_value = &(value->maxQp); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxQp); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxFrameSize)); + wrapper->maxFrameSize = PreloadDecodeAllocator::Allocate(); + wrapper->maxFrameSize->decoded_value = &(value->maxFrameSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFrameSize); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264GopRemainingFrameInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH264GopRemainingFrameInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->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_VkVideoEncodeH265CapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeUInt32Value((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_VkVideoEncodeH265SessionCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->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_VkVideoEncodeH265QpKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265QpKHR* 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_VkVideoEncodeH265QualityLevelPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoEncodeH265SessionParametersAddInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoEncodeH265SessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkVideoEncodeH265SessionParametersGetInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->writeStdVPS)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdSPS)); + bytes_read += ValueDecoder::DecodeUInt32Value((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_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdVPSOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdSPSOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); + + return bytes_read; +} + +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; + 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::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)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((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::DecodeUInt32Value((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::DecodeUInt32Value((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_VkVideoEncodeH265GopRemainingFrameInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265CapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265CapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate(); + wrapper->maxTiles->decoded_value = &(value->maxTiles); + bytes_read += PreloadDecodeStruct((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::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); + bytes_read += ValueDecoder::DecodeUInt32Value((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265SessionCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->useMaxLevelIdc)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QpKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265QpKHR* 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265QualityLevelPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate(); + wrapper->preferredConstantQp->decoded_value = &(value->preferredConstantQp); + bytes_read += PreloadDecodeStruct((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265SessionParametersAddInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdVPSs->PreloadDecode((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSPSs->PreloadDecode((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPPSs->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pParametersAddInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265SessionParametersGetInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->writeStdVPS)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdSPS)); + bytes_read += ValueDecoder::DecodeUInt32Value((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265SessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->hasStdVPSOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdSPSOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265NaluSliceSegmentInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSliceSegmentHeader->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdSliceSegmentHeader = wrapper->pStdSliceSegmentHeader->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pNaluSliceSegmentEntries->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pNaluSliceSegmentEntries = wrapper->pNaluSliceSegmentEntries->GetPointer(); + wrapper->pStdPictureInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPictureInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdReferenceInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdReferenceInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdReferenceInfo = wrapper->pStdReferenceInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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 PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265FrameSizeKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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 PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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->useMinQp)); + wrapper->minQp = PreloadDecodeAllocator::Allocate(); + wrapper->minQp->decoded_value = &(value->minQp); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minQp); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxQp)); + wrapper->maxQp = PreloadDecodeAllocator::Allocate(); + wrapper->maxQp->decoded_value = &(value->maxQp); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxQp); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->useMaxFrameSize)); + wrapper->maxFrameSize = PreloadDecodeAllocator::Allocate(); + wrapper->maxFrameSize->decoded_value = &(value->maxFrameSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFrameSize); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeH265GopRemainingFrameInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->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_VkVideoDecodeH264ProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH264ProfileInfoKHR* 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)); + + return bytes_read; +} + +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; + VkVideoDecodeH264CapabilitiesKHR* 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)); + 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) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->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_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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264ProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH264ProfileInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264CapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH264CapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate(); + wrapper->fieldOffsetGranularity->decoded_value = &(value->fieldOffsetGranularity); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fieldOffsetGranularity); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH264SessionParametersAddInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSPSs->PreloadDecode((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPPSs->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pParametersAddInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdPictureInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPictureInfo->PreloadDecode((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.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSliceOffsets = wrapper->pSliceOffsets.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdReferenceInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdReferenceInfo->PreloadDecode((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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewAttributes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewAttributesPositionXOnly)); + + return bytes_read; +} +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate(); + wrapper->shadingRateAttachmentTexelSize->decoded_value = &(value->shadingRateAttachmentTexelSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->shadingRateAttachmentTexelSize); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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 PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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.PreloadDecodeEnum((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiviewPerViewAttributesInfoNVX* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMultiviewPerViewAttributesInfoNVX* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->perViewAttributes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewAttributesPositionXOnly)); + + return bytes_read; +} + +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; + 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::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_VkExportMemoryWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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)); + 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(); + + return bytes_read; +} + +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; + 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::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_VkMemoryGetWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImportMemoryWin32HandleInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->name = wrapper->name.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportMemoryWin32HandleInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pAttributes = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttributes->PreloadDecode((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->name = wrapper->name.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryWin32HandlePropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryWin32HandlePropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryGetWin32HandleInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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::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_VkMemoryFdPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkMemoryGetFdInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryFdInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImportMemoryFdInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryFdPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryFdPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetFdInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryGetFdInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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::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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWin32KeyedMutexAcquireReleaseInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAcquireSyncs = nullptr; + bytes_read += wrapper->pAcquireKeys.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAcquireKeys = wrapper->pAcquireKeys.GetPointer(); + bytes_read += wrapper->pAcquireTimeouts.PreloadDecodeUInt32((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pReleaseSyncs = nullptr; + bytes_read += wrapper->pReleaseKeys.PreloadDecodeUInt64((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_VkImportSemaphoreWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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)); + 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_VkExportSemaphoreWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkD3D12FenceSubmitInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkSemaphoreGetWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportSemaphoreWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImportSemaphoreWin32HandleInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->name = wrapper->name.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportSemaphoreWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportSemaphoreWin32HandleInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pAttributes = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttributes->PreloadDecode((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->name = wrapper->name.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkD3D12FenceSubmitInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkD3D12FenceSubmitInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecodeUInt64((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.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSignalSemaphoreValues = wrapper->pSignalSemaphoreValues.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreGetWin32HandleInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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; + 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_VkSemaphoreGetFdInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportSemaphoreFdInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImportSemaphoreFdInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetFdInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSemaphoreGetFdInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPushDescriptors)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePushDescriptorPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + VkRectLayerKHR* 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)); + + return bytes_read; +} + +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; + VkPresentRegionKHR* 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(); + + return bytes_read; +} + +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; + 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; + 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRectLayerKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRectLayerKHR* value = wrapper->decoded_value; + + wrapper->offset = PreloadDecodeAllocator::Allocate(); + wrapper->offset->decoded_value = &(value->offset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->offset); + wrapper->extent = PreloadDecodeAllocator::Allocate(); + wrapper->extent->decoded_value = &(value->extent); + bytes_read += PreloadDecodeStruct((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentRegionKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPresentRegionKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rectangleCount)); + wrapper->pRectangles = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRectangles->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRectangles = wrapper->pRectangles->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentRegionsKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPresentRegionsKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((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_VkSharedPresentSurfaceCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sharedPresentSupportedUsageFlags)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSharedPresentSurfaceCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSharedPresentSurfaceCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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::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_VkExportFenceWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkFenceGetWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportFenceWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImportFenceWin32HandleInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + bytes_read += wrapper->name.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->name = wrapper->name.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportFenceWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportFenceWin32HandleInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pAttributes = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttributes->PreloadDecode((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->name = wrapper->name.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFenceGetWin32HandleInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFenceGetWin32HandleInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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::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_VkFenceGetFdInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportFenceFdInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImportFenceFdInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fd)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFenceGetFdInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFenceGetFdInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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->performanceCounterQueryPools)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceCounterMultipleQueryPools)); + + return bytes_read; +} + +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; + 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; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->allowCommandBufferQueryCopies)); + + return bytes_read; +} + +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; + 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; + 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_VkPerformanceCounterDescriptionKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_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)); + + return bytes_read; +} + +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; + 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; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->counterPassIndex)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePerformanceQueryFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->performanceCounterQueryPools)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceCounterMultipleQueryPools)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePerformanceQueryPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->allowCommandBufferQueryCopies)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceCounterKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPerformanceCounterKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceCounterDescriptionKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPerformanceCounterDescriptionKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + wrapper->name.SetExternalMemory(value->name, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->name.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->category.SetExternalMemory(value->category, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->category.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCounterIndices = wrapper->pCounterIndices.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(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 += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceQuerySubmitInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPerformanceQuerySubmitInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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; + 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_VkSurfaceCapabilities2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkSurfaceFormat2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSurfaceInfo2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSurfaceInfo2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilities2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSurfaceCapabilities2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->surfaceCapabilities = PreloadDecodeAllocator::Allocate(); + wrapper->surfaceCapabilities->decoded_value = &(value->surfaceCapabilities); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->surfaceCapabilities); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFormat2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSurfaceFormat2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->surfaceFormat = PreloadDecodeAllocator::Allocate(); + wrapper->surfaceFormat->decoded_value = &(value->surfaceFormat); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->surfaceFormat); + + return bytes_read; +} + +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; + 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; + 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_VkDisplayPlaneProperties2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkDisplayModeProperties2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkDisplayPlaneInfo2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkDisplayPlaneCapabilities2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayProperties2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayProperties2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->displayProperties = PreloadDecodeAllocator::Allocate(); + wrapper->displayProperties->decoded_value = &(value->displayProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneProperties2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPlaneProperties2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->displayPlaneProperties = PreloadDecodeAllocator::Allocate(); + wrapper->displayPlaneProperties->decoded_value = &(value->displayPlaneProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPlaneProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModeProperties2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayModeProperties2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->displayModeProperties = PreloadDecodeAllocator::Allocate(); + wrapper->displayModeProperties->decoded_value = &(value->displayModeProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayModeProperties); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneInfo2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPlaneInfo2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneCapabilities2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDisplayPlaneCapabilities2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->capabilities = PreloadDecodeAllocator::Allocate(); + wrapper->capabilities->decoded_value = &(value->capabilities); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->capabilities); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->constantAlphaColorBlendFactors)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->events)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatReinterpretation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatSwizzle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageView2DOn3DImage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multisampleArrayImage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mutableComparisonSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pointPolygons)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerMipLodBias)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateStencilMaskRef)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampleRateInterpolationFunctions)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationIsolines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationPointMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triangleFans)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeAccessBeyondStride)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minVertexInputBindingStrideAlignment)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePortabilitySubsetFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->constantAlphaColorBlendFactors)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->events)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatReinterpretation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatSwizzle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageView2DOn3DImage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multisampleArrayImage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mutableComparisonSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pointPolygons)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerMipLodBias)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateStencilMaskRef)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampleRateInterpolationFunctions)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationIsolines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationPointMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triangleFans)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeAccessBeyondStride)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePortabilitySubsetPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupClock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDeviceClock)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderClockFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderClockFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderSubgroupClock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDeviceClock)); + + return bytes_read; +} + +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; + 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; + 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_VkVideoDecodeH265CapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoDecodeH265SessionParametersAddInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoDecodeH265SessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->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_VkVideoDecodeH265PictureInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkVideoDecodeH265DpbSlotInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265ProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH265ProfileInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265CapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH265CapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265SessionParametersAddInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH265SessionParametersAddInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdVPSs->PreloadDecode((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSPSs->PreloadDecode((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPPSs->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPPSs = wrapper->pStdPPSs->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265SessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH265SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pParametersAddInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pParametersAddInfo = wrapper->pParametersAddInfo->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265PictureInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH265PictureInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdPictureInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPictureInfo->PreloadDecode((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.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSliceSegmentOffsets = wrapper->pSliceSegmentOffsets.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265DpbSlotInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeH265DpbSlotInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdReferenceInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdReferenceInfo->PreloadDecode((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_VkDeviceQueueGlobalPriorityCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalPriorityQuery)); + + return bytes_read; +} + +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; + 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::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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceQueueGlobalPriorityCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->globalPriorityQuery)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueueFamilyGlobalPriorityPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +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; + 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; + 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_VkPipelineFragmentShadingRateStateCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineFragmentShadingRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentFragmentShadingRate)); + + return bytes_read; +} + +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; + 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->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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRateWithMultipleViewports)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layeredShadingRateAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderDepthStencilWrites)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithSampleMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderSampleMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithConservativeRasterization)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithFragmentShaderInterlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithCustomSampleLocations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateStrictMultiplyCombiner)); + + return bytes_read; +} + +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; + 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::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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFragmentShadingRateAttachmentInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkFragmentShadingRateAttachmentInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pFragmentShadingRateAttachment = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pFragmentShadingRateAttachment->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pFragmentShadingRateAttachment = wrapper->pFragmentShadingRateAttachment->GetPointer(); + wrapper->shadingRateAttachmentTexelSize = PreloadDecodeAllocator::Allocate(); + wrapper->shadingRateAttachmentTexelSize->decoded_value = &(value->shadingRateAttachmentTexelSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->shadingRateAttachmentTexelSize); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineFragmentShadingRateStateCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineFragmentShadingRateStateCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->fragmentSize = PreloadDecodeAllocator::Allocate(); + wrapper->fragmentSize->decoded_value = &(value->fragmentSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentSize); + wrapper->combinerOps.SetExternalMemory(value->combinerOps, 2); + bytes_read += wrapper->combinerOps.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFragmentShadingRateFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pipelineFragmentShadingRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentFragmentShadingRate)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFragmentShadingRatePropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->minFragmentShadingRateAttachmentTexelSize = PreloadDecodeAllocator::Allocate(); + wrapper->minFragmentShadingRateAttachmentTexelSize->decoded_value = &(value->minFragmentShadingRateAttachmentTexelSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minFragmentShadingRateAttachmentTexelSize); + wrapper->maxFragmentShadingRateAttachmentTexelSize = PreloadDecodeAllocator::Allocate(); + wrapper->maxFragmentShadingRateAttachmentTexelSize->decoded_value = &(value->maxFragmentShadingRateAttachmentTexelSize); + bytes_read += PreloadDecodeStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRateWithMultipleViewports)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layeredShadingRateAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateNonTrivialCombinerOps)); + wrapper->maxFragmentSize = PreloadDecodeAllocator::Allocate(); + wrapper->maxFragmentSize->decoded_value = &(value->maxFragmentSize); + bytes_read += PreloadDecodeStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderDepthStencilWrites)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithSampleMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderSampleMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithConservativeRasterization)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithFragmentShaderInterlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithCustomSampleLocations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateStrictMultiplyCombiner)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFragmentShadingRateKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate(); + wrapper->fragmentSize->decoded_value = &(value->fragmentSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentSize); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* 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->dynamicRenderingLocalRead)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingAttachmentLocationInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingAttachmentLocationInfoKHR* 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->pColorAttachmentLocations.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachmentLocations = wrapper->pColorAttachmentLocations.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingInputAttachmentIndexInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingInputAttachmentIndexInfoKHR* 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->pColorAttachmentInputIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachmentInputIndices = wrapper->pColorAttachmentInputIndices.GetPointer(); + bytes_read += wrapper->pDepthInputAttachmentIndex.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthInputAttachmentIndex = wrapper->pDepthInputAttachmentIndex.GetPointer(); + bytes_read += wrapper->pStencilInputAttachmentIndex.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStencilInputAttachmentIndex = wrapper->pStencilInputAttachmentIndex.GetPointer(); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dynamicRenderingLocalRead)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingAttachmentLocationInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingAttachmentLocationInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pColorAttachmentLocations.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachmentLocations = wrapper->pColorAttachmentLocations.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingInputAttachmentIndexInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingInputAttachmentIndexInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pColorAttachmentInputIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorAttachmentInputIndices = wrapper->pColorAttachmentInputIndices.GetPointer(); + bytes_read += wrapper->pDepthInputAttachmentIndex.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthInputAttachmentIndex = wrapper->pDepthInputAttachmentIndex.GetPointer(); + bytes_read += wrapper->pStencilInputAttachmentIndex.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStencilInputAttachmentIndex = wrapper->pStencilInputAttachmentIndex.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderQuadControlFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderQuadControlFeaturesKHR* 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->shaderQuadControl)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderQuadControlFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderQuadControlFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderQuadControl)); + + return bytes_read; +} + +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; + 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->supportsProtected)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceProtectedCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSurfaceProtectedCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->supportsProtected)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentWait)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentWaitFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePresentWaitFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->presentWait)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineExecutableInfo)); + + return bytes_read; +} + +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; + 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::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_VkPipelineExecutablePropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkPipelineExecutableInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkPipelineExecutableStatisticKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkPipelineExecutableInternalRepresentationKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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->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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pipelineExecutableInfo)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutablePropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineExecutablePropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.PreloadDecode((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineExecutableInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableStatisticKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineExecutableStatisticKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + wrapper->value = PreloadDecodeAllocator::Allocate(); + wrapper->value->decoded_value = &(value->value); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->value); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableInternalRepresentationKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineExecutableInternalRepresentationKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((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.PreloadDecodeVoid((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_VkMemoryMapInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +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; + 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::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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryMapInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryMapInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryUnmapInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkMemoryUnmapInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +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; + VkPipelineLibraryCreateInfoKHR* 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; + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineLibraryCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineLibraryCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((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_VkPresentIdKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkPhysicalDevicePresentIdFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentId)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentIdKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPresentIdKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentIds = wrapper->pPresentIds.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentIdFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePresentIdFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->presentId)); + + return bytes_read; +} + +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; + 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::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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBufferOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((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_VkVideoEncodeCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkVideoEncodeUsageInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkVideoEncodeRateControlLayerInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoEncodeRateControlInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkVideoEncodeQualityLevelPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoEncodeQualityLevelInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoEncodeSessionParametersGetInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkVideoEncodeSessionParametersFeedbackInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->hasOverrides)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBufferOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBufferRange)); + wrapper->srcPictureResource = PreloadDecodeAllocator::Allocate(); + wrapper->srcPictureResource->decoded_value = &(value->srcPictureResource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcPictureResource); + wrapper->pSetupReferenceSlot = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSetupReferenceSlot->PreloadDecode((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pReferenceSlots->PreloadDecode((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeCapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeCapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate(); + wrapper->encodeInputPictureGranularity->decoded_value = &(value->encodeInputPictureGranularity); + bytes_read += PreloadDecodeStruct((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeUsageInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeUsageInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeRateControlLayerInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeRateControlLayerInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeRateControlInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeRateControlInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pLayers->PreloadDecode((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pVideoProfile = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pVideoProfile->PreloadDecode((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeQualityLevelPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeQualityLevelInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersGetInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeSessionParametersGetInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersFeedbackInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoEncodeSessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->hasOverrides)); + + return bytes_read; +} + +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; + VkQueueFamilyCheckpointProperties2NV* 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)); + + return bytes_read; +} + +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; + 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::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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointProperties2NV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkQueueFamilyCheckpointProperties2NV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCheckpointData2NV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCheckpointData2NV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderBarycentric)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triStripVertexOrderIndependentOfProvokingVertex)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->fragmentShaderBarycentric)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->triStripVertexOrderIndependentOfProvokingVertex)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupUniformControlFlow)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderSubgroupUniformControlFlow)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayoutScalarBlockLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout16BitAccess)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->workgroupMemoryExplicitLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayoutScalarBlockLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout8BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout16BitAccess)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingMaintenance1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPipelineTraceRaysIndirect2)); + + return bytes_read; +} + +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; + VkTraceRaysIndirectCommand2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableStride)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableStride)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->rayTracingMaintenance1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPipelineTraceRaysIndirect2)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTraceRaysIndirectCommand2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkTraceRaysIndirectCommand2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableStride)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableStride)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((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_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* 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->shaderSubgroupRotate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupRotateClustered)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderSubgroupRotate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupRotateClustered)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* 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->shaderMaximalReconvergence)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderMaximalReconvergence)); + + return bytes_read; +} + +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; + 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 += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maintenance5)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentMultisampleCoverageAfterSampleCounting)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentSampleMaskTestBeforeSampleCounting)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilSwizzleOneSupport)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->polygonModePointSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictSinglePixelWideLinesUseParallelogram)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictWideLinesUseParallelogram)); + + return bytes_read; +} + +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; + 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::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_VkImageSubresource2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkDeviceImageSubresourceInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkSubresourceLayout2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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; + 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_VkPipelineCreateFlags2CreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkBufferUsageFlags2CreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance5FeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maintenance5)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance5PropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->earlyFragmentMultisampleCoverageAfterSampleCounting)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentSampleMaskTestBeforeSampleCounting)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilSwizzleOneSupport)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->polygonModePointSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictSinglePixelWideLinesUseParallelogram)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictWideLinesUseParallelogram)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingAreaInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderingAreaInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecodeEnum((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSubresource2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageSubresource2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->imageSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->imageSubresource->decoded_value = &(value->imageSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceImageSubresourceInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceImageSubresourceInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pCreateInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pCreateInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCreateInfo = wrapper->pCreateInfo->GetPointer(); + wrapper->pSubresource = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSubresource->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSubresource = wrapper->pSubresource->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubresourceLayout2KHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSubresourceLayout2KHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->subresourceLayout = PreloadDecodeAllocator::Allocate(); + wrapper->subresourceLayout->decoded_value = &(value->subresourceLayout); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceLayout); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCreateFlags2CreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineCreateFlags2CreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferUsageFlags2CreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBufferUsageFlags2CreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPositionFetch)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->rayTracingPositionFetch)); + + return bytes_read; +} + +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; + 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::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::DecodeUInt32Value((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_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceCooperativeMatrixFeaturesKHR* 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->cooperativeMatrix)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixRobustBufferAccess)); + + return bytes_read; +} + +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; + 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->cooperativeMatrixSupportedStages)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCooperativeMatrixPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCooperativeMatrixPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceCooperativeMatrixFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->cooperativeMatrix)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixRobustBufferAccess)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceCooperativeMatrixPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1ProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1ProfileInfoKHR* 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->stdProfile)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filmGrainSupport)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1CapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1CapabilitiesKHR* 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->maxLevel)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1SessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1SessionParametersCreateInfoKHR* 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->pStdSequenceHeader = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSequenceHeader->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdSequenceHeader = wrapper->pStdSequenceHeader->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1PictureInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1PictureInfoKHR* 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(); + wrapper->referenceNameSlotIndices.SetExternalMemory(value->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR); + bytes_read += wrapper->referenceNameSlotIndices.DecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameHeaderOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tileCount)); + bytes_read += wrapper->pTileOffsets.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTileOffsets = wrapper->pTileOffsets.GetPointer(); + bytes_read += wrapper->pTileSizes.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTileSizes = wrapper->pTileSizes.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1DpbSlotInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1DpbSlotInfoKHR* 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1ProfileInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1ProfileInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->stdProfile)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filmGrainSupport)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1CapabilitiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1CapabilitiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxLevel)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1SessionParametersCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdSequenceHeader = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdSequenceHeader->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdSequenceHeader = wrapper->pStdSequenceHeader->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1PictureInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1PictureInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdPictureInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdPictureInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStdPictureInfo = wrapper->pStdPictureInfo->GetPointer(); + wrapper->referenceNameSlotIndices.SetExternalMemory(value->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR); + bytes_read += wrapper->referenceNameSlotIndices.PreloadDecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameHeaderOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tileCount)); + bytes_read += wrapper->pTileOffsets.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTileOffsets = wrapper->pTileOffsets.GetPointer(); + bytes_read += wrapper->pTileSizes.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTileSizes = wrapper->pTileSizes.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1DpbSlotInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoDecodeAV1DpbSlotInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pStdReferenceInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStdReferenceInfo->PreloadDecode((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_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->videoMaintenance1)); + + return bytes_read; +} + +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; + 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::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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVideoMaintenance1FeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->videoMaintenance1)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoInlineQueryInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVideoInlineQueryInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->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_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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->maxVertexAttribDivisor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportsNonZeroFirstInstance)); + + return bytes_read; +} + +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; + VkVertexInputBindingDivisorDescriptionKHR* 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)); + + return bytes_read; +} + +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; + 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::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_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateDivisor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateZeroDivisor)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportsNonZeroFirstInstance)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDivisorDescriptionKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVertexInputBindingDivisorDescriptionKHR* 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)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineVertexInputDivisorStateCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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 = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pVertexBindingDivisors->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVertexBindingDivisors = wrapper->pVertexBindingDivisors->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->vertexAttributeInstanceRateDivisor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateZeroDivisor)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderFloatControls2FeaturesKHR* 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->shaderFloatControls2)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderFloatControls2FeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderFloatControls2)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceIndexTypeUint8FeaturesKHR* 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->indexTypeUint8)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceIndexTypeUint8FeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->indexTypeUint8)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLineRasterizationFeaturesKHR* 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->rectangularLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bresenhamLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->smoothLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledRectangularLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledBresenhamLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledSmoothLines)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLineRasterizationPropertiesKHR* 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->lineSubPixelPrecisionBits)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationLineStateCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineRasterizationLineStateCreateInfoKHR* 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->lineRasterizationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledLineEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lineStippleFactor)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lineStipplePattern)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLineRasterizationFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->rectangularLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bresenhamLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->smoothLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledRectangularLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledBresenhamLines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledSmoothLines)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLineRasterizationPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->lineSubPixelPrecisionBits)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationLineStateCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineRasterizationLineStateCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->lineRasterizationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledLineEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lineStippleFactor)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lineStipplePattern)); + + return bytes_read; +} + +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; + 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeDomain)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCalibratedTimestampInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* 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->shaderExpectAssume)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderExpectAssume)); + + return bytes_read; +} + +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; + 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; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maintenance6)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateClampCombinerInputs)); + + return bytes_read; +} + +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; + 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 += 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_VkBindDescriptorSetsInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindDescriptorSetsInfoKHR* 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->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_VkPushConstantsInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkPushDescriptorSetInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkSetDescriptorBufferOffsetsInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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.DecodeUInt64((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_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindDescriptorBufferEmbeddedSamplersInfoEXT* 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->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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance6FeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maintenance6)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance6PropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->blockTexelViewCompatibleMultipleLayers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxCombinedImageSamplerDescriptorCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateClampCombinerInputs)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindMemoryStatusKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindMemoryStatusKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += wrapper->pResult.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pResult = wrapper->pResult.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindDescriptorSetsInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindDescriptorSetsInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((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.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDynamicOffsets = wrapper->pDynamicOffsets.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushConstantsInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPushConstantsInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->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.PreloadDecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pValues = wrapper->pValues.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushDescriptorSetInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPushDescriptorSetInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorWriteCount)); + wrapper->pDescriptorWrites = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDescriptorWrites->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDescriptorWrites = wrapper->pDescriptorWrites->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSetDescriptorBufferOffsetsInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSetDescriptorBufferOffsetsInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->setCount)); + bytes_read += wrapper->pBufferIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBufferIndices = wrapper->pBufferIndices.GetPointer(); + bytes_read += wrapper->pOffsets.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pOffsets = wrapper->pOffsets.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindDescriptorBufferEmbeddedSamplersInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* 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->shaderRelaxedExtendedInstruction)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderRelaxedExtendedInstruction)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance7FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance7FeaturesKHR* 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->maintenance7)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance7PropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance7PropertiesKHR* 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->robustFragmentShadingRateAttachmentAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateDepthStencilAttachmentAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetTotalUniformBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetTotalStorageBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetTotalBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindTotalBuffersDynamic)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLayeredApiPropertiesKHR* 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->vendorID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceID)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->layeredAPI)); + wrapper->deviceName.SetExternalMemory(value->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); + bytes_read += wrapper->deviceName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiPropertiesListKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLayeredApiPropertiesListKHR* 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->layeredApiCount)); + wrapper->pLayeredApis = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pLayeredApis->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLayeredApis = wrapper->pLayeredApis->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* 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->properties = DecodeAllocator::Allocate(); + wrapper->properties->decoded_value = &(value->properties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->properties); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance7FeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance7FeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maintenance7)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance7PropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMaintenance7PropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->robustFragmentShadingRateAttachmentAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateDepthStencilAttachmentAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetTotalUniformBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetTotalStorageBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetTotalBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindTotalBuffersDynamic)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLayeredApiPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->vendorID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceID)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->layeredAPI)); + wrapper->deviceName.SetExternalMemory(value->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); + bytes_read += wrapper->deviceName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiPropertiesListKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLayeredApiPropertiesListKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->layeredApiCount)); + wrapper->pLayeredApis = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pLayeredApis->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLayeredApis = wrapper->pLayeredApis->GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->properties = PreloadDecodeAllocator::Allocate(); + wrapper->properties->decoded_value = &(value->properties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->properties); + + return bytes_read; +} + +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; + 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->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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugReportCallbackCreateInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDebugReportCallbackCreateInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +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; + 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrder)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateRasterizationOrderAMD* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineRasterizationStateRasterizationOrderAMD* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); + + return bytes_read; +} + +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; + 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::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_VkDebugMarkerObjectTagInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkDebugMarkerMarkerInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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 += 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDebugMarkerObjectNameInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pObjectName = wrapper->pObjectName.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectTagInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDebugMarkerObjectTagInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTag = wrapper->pTag.GetPointer(); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerMarkerInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDebugMarkerMarkerInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += wrapper->pMarkerName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMarkerName = wrapper->pMarkerName.GetPointer(); + wrapper->color.SetExternalMemory(value->color, 4); + bytes_read += wrapper->color.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dedicatedAllocation)); + + return bytes_read; +} + +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; + 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->dedicatedAllocation)); + + return bytes_read; +} + +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; + 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; + 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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationImageCreateInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDedicatedAllocationImageCreateInfoNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dedicatedAllocation)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationBufferCreateInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDedicatedAllocationBufferCreateInfoNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dedicatedAllocation)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationMemoryAllocateInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDedicatedAllocationMemoryAllocateInfoNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +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; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedback)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryStreams)); + + return bytes_read; +} + +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; + 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::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::DecodeUInt64Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackQueries)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackStreamsLinesTriangles)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackRasterizationStreamSelect)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackDraw)); + + return bytes_read; +} + +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; + VkPipelineRasterizationStateStreamCreateInfoEXT* 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)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTransformFeedbackFeaturesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->transformFeedback)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryStreams)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceTransformFeedbackPropertiesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt64Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackQueries)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackStreamsLinesTriangles)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackRasterizationStreamSelect)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackDraw)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineRasterizationStateStreamCreateInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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_VkImageViewHandleInfoNVX* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::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_VkImageViewAddressPropertiesNVX* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewHandleInfoNVX* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageViewHandleInfoNVX* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewAddressPropertiesNVX* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageViewAddressPropertiesNVX* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->deviceAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTextureLODGatherFormatPropertiesAMD* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkTextureLODGatherFormatPropertiesAMD* 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->supportsTextureGatherLODBiasAMD)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTextureLODGatherFormatPropertiesAMD* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkTextureLODGatherFormatPropertiesAMD* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->supportsTextureGatherLODBiasAMD)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderResourceUsageAMD* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkShaderResourceUsageAMD* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numUsedVgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numUsedSgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ldsSizePerLocalWorkGroup)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ldsUsageSizeInBytes)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scratchMemUsageInBytes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderStatisticsInfoAMD* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkShaderStatisticsInfoAMD* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStageMask)); + wrapper->resourceUsage = DecodeAllocator::Allocate(); + wrapper->resourceUsage->decoded_value = &(value->resourceUsage); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->resourceUsage); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numPhysicalVgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numPhysicalSgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numAvailableVgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numAvailableSgprs)); + wrapper->computeWorkGroupSize.SetExternalMemory(value->computeWorkGroupSize, 3); + bytes_read += wrapper->computeWorkGroupSize.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderResourceUsageAMD* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkShaderResourceUsageAMD* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numUsedVgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numUsedSgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ldsSizePerLocalWorkGroup)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ldsUsageSizeInBytes)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scratchMemUsageInBytes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderStatisticsInfoAMD* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkShaderStatisticsInfoAMD* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStageMask)); + wrapper->resourceUsage = PreloadDecodeAllocator::Allocate(); + wrapper->resourceUsage->decoded_value = &(value->resourceUsage); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->resourceUsage); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numPhysicalVgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numPhysicalSgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numAvailableVgprs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numAvailableSgprs)); + wrapper->computeWorkGroupSize.SetExternalMemory(value->computeWorkGroupSize, 3); + bytes_read += wrapper->computeWorkGroupSize.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkStreamDescriptorSurfaceCreateInfoGGP* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkStreamDescriptorSurfaceCreateInfoGGP* 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->streamDescriptor)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkStreamDescriptorSurfaceCreateInfoGGP* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkStreamDescriptorSurfaceCreateInfoGGP* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->streamDescriptor)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCornerSampledImageFeaturesNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceCornerSampledImageFeaturesNV* 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->cornerSampledImage)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCornerSampledImageFeaturesNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceCornerSampledImageFeaturesNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->cornerSampledImage)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalImageFormatPropertiesNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalImageFormatPropertiesNV* value = wrapper->decoded_value; + + wrapper->imageFormatProperties = DecodeAllocator::Allocate(); + wrapper->imageFormatProperties->decoded_value = &(value->imageFormatProperties); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageFormatProperties); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalMemoryFeatures)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->exportFromImportedHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalImageFormatPropertiesNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalImageFormatPropertiesNV* value = wrapper->decoded_value; + + wrapper->imageFormatProperties = PreloadDecodeAllocator::Allocate(); + wrapper->imageFormatProperties->decoded_value = &(value->imageFormatProperties); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageFormatProperties); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalMemoryFeatures)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->exportFromImportedHandleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryImageCreateInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalMemoryImageCreateInfoNV* 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->handleTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryAllocateInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportMemoryAllocateInfoNV* 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->handleTypes)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryImageCreateInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExternalMemoryImageCreateInfoNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryAllocateInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportMemoryAllocateInfoNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryWin32HandleInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImportMemoryWin32HandleInfoNV* 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->handleType)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->handle)); + value->handle = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportMemoryWin32HandleInfoNV* 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)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryWin32HandleInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImportMemoryWin32HandleInfoNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->handleType)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->handle)); + value->handle = nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkExportMemoryWin32HandleInfoNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->pAttributes = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttributes->PreloadDecode((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)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWin32KeyedMutexAcquireReleaseInfoNV* 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->deviceMask)); + 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->pAcquireTimeoutMilliseconds.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAcquireTimeoutMilliseconds = wrapper->pAcquireTimeoutMilliseconds.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 PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupSubmitInfo* wrapper) + size_t bytes_read = 0; + VkWin32KeyedMutexAcquireReleaseInfoNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAcquireSyncs = nullptr; + bytes_read += wrapper->pAcquireKeys.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAcquireKeys = wrapper->pAcquireKeys.GetPointer(); + bytes_read += wrapper->pAcquireTimeoutMilliseconds.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAcquireTimeoutMilliseconds = wrapper->pAcquireTimeoutMilliseconds.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->releaseCount)); + bytes_read += wrapper->pReleaseSyncs.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pReleaseSyncs = nullptr; + bytes_read += wrapper->pReleaseKeys.PreloadDecodeUInt64((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_VkValidationFlagsEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceGroupSubmitInfo* value = wrapper->decoded_value; + VkValidationFlagsEXT* 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->waitSemaphoreCount)); - bytes_read += wrapper->pWaitSemaphoreDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pWaitSemaphoreDeviceIndices = wrapper->pWaitSemaphoreDeviceIndices.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->commandBufferCount)); - bytes_read += wrapper->pCommandBufferDeviceMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCommandBufferDeviceMasks = wrapper->pCommandBufferDeviceMasks.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreCount)); - bytes_read += wrapper->pSignalSemaphoreDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSignalSemaphoreDeviceIndices = wrapper->pSignalSemaphoreDeviceIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->disabledValidationCheckCount)); + bytes_read += wrapper->pDisabledValidationChecks.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDisabledValidationChecks = wrapper->pDisabledValidationChecks.GetPointer(); return bytes_read; } +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkValidationFlagsEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupBindSparseInfo* wrapper) + size_t bytes_read = 0; + VkValidationFlagsEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->disabledValidationCheckCount)); + bytes_read += wrapper->pDisabledValidationChecks.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDisabledValidationChecks = wrapper->pDisabledValidationChecks.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViSurfaceCreateInfoNN* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkViSurfaceCreateInfoNN* 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->window)); + value->window = nullptr; + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViSurfaceCreateInfoNN* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkViSurfaceCreateInfoNN* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->window)); + value->window = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewASTCDecodeModeEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageViewASTCDecodeModeEXT* 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->decodeMode)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceASTCDecodeFeaturesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceASTCDecodeFeaturesEXT* 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->decodeModeSharedExponent)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewASTCDecodeModeEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkImageViewASTCDecodeModeEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->decodeMode)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceASTCDecodeFeaturesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceASTCDecodeFeaturesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->decodeModeSharedExponent)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessFeaturesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePipelineRobustnessFeaturesEXT* 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->pipelineRobustness)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessPropertiesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePipelineRobustnessPropertiesEXT* 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->defaultRobustnessStorageBuffers)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessUniformBuffers)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessVertexInputs)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessImages)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRobustnessCreateInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineRobustnessCreateInfoEXT* 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->storageBuffers)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformBuffers)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexInputs)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->images)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessFeaturesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDevicePipelineRobustnessFeaturesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pipelineRobustness)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceGroupBindSparseInfo* value = wrapper->decoded_value; + VkPhysicalDevicePipelineRobustnessPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->resourceDeviceIndex)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryDeviceIndex)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessStorageBuffers)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessUniformBuffers)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessVertexInputs)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessImages)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindBufferMemoryDeviceGroupInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRobustnessCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindBufferMemoryDeviceGroupInfo* value = wrapper->decoded_value; + VkPipelineRobustnessCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->deviceIndexCount)); - bytes_read += wrapper->pDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDeviceIndices = wrapper->pDeviceIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageBuffers)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformBuffers)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexInputs)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->images)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImageMemoryDeviceGroupInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkConditionalRenderingBeginInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindImageMemoryDeviceGroupInfo* value = wrapper->decoded_value; + VkConditionalRenderingBeginInfoEXT* 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->deviceIndexCount)); - bytes_read += wrapper->pDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDeviceIndices = wrapper->pDeviceIndices.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->splitInstanceBindRegionCount)); - wrapper->pSplitInstanceBindRegions = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSplitInstanceBindRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSplitInstanceBindRegions = wrapper->pSplitInstanceBindRegions->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGroupProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConditionalRenderingFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceGroupProperties* value = wrapper->decoded_value; + VkPhysicalDeviceConditionalRenderingFeaturesEXT* 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->physicalDeviceCount)); - wrapper->physicalDevices.SetExternalMemory(value->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE); - bytes_read += wrapper->physicalDevices.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsetAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conditionalRendering)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inheritedConditionalRendering)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupDeviceCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceConditionalRenderingInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceGroupDeviceCreateInfo* value = wrapper->decoded_value; + VkCommandBufferInheritanceConditionalRenderingInfoEXT* 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->physicalDeviceCount)); - bytes_read += wrapper->pPhysicalDevices.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPhysicalDevices = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conditionalRenderingEnable)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferMemoryRequirementsInfo2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkConditionalRenderingBeginInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBufferMemoryRequirementsInfo2* value = wrapper->decoded_value; + VkConditionalRenderingBeginInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->buffer)); value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageMemoryRequirementsInfo2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConditionalRenderingFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageMemoryRequirementsInfo2* value = wrapper->decoded_value; + VkPhysicalDeviceConditionalRenderingFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conditionalRendering)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inheritedConditionalRendering)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSparseMemoryRequirementsInfo2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceConditionalRenderingInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageSparseMemoryRequirementsInfo2* value = wrapper->decoded_value; + VkCommandBufferInheritanceConditionalRenderingInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conditionalRenderingEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryRequirements2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViewportWScalingNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryRequirements2* value = wrapper->decoded_value; + VkViewportWScalingNV* 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->memoryRequirements = DecodeAllocator::Allocate(); - wrapper->memoryRequirements->decoded_value = &(value->memoryRequirements); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryRequirements); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->xcoeff)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycoeff)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageMemoryRequirements2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportWScalingStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSparseImageMemoryRequirements2* value = wrapper->decoded_value; + VkPipelineViewportWScalingStateCreateInfoNV* 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->memoryRequirements = DecodeAllocator::Allocate(); - wrapper->memoryRequirements->decoded_value = &(value->memoryRequirements); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryRequirements); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportWScalingEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportCount)); + wrapper->pViewportWScalings = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pViewportWScalings->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewportWScalings = wrapper->pViewportWScalings->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFeatures2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViewportWScalingNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFeatures2* value = wrapper->decoded_value; + VkViewportWScalingNV* 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->features = DecodeAllocator::Allocate(); - wrapper->features->decoded_value = &(value->features); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->features); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->xcoeff)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycoeff)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProperties2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportWScalingStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceProperties2* value = wrapper->decoded_value; + VkPipelineViewportWScalingStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->properties = DecodeAllocator::Allocate(); - wrapper->properties->decoded_value = &(value->properties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->properties); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportWScalingEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportCount)); + wrapper->pViewportWScalings = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pViewportWScalings->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewportWScalings = wrapper->pViewportWScalings->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFormatProperties2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilities2EXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFormatProperties2* value = wrapper->decoded_value; + VkSurfaceCapabilities2EXT* 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->formatProperties = DecodeAllocator::Allocate(); - wrapper->formatProperties->decoded_value = &(value->formatProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->formatProperties); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImageCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageCount)); + wrapper->currentExtent = DecodeAllocator::Allocate(); + wrapper->currentExtent->decoded_value = &(value->currentExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->currentExtent); + wrapper->minImageExtent = DecodeAllocator::Allocate(); + wrapper->minImageExtent->decoded_value = &(value->minImageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minImageExtent); + wrapper->maxImageExtent = DecodeAllocator::Allocate(); + wrapper->maxImageExtent->decoded_value = &(value->maxImageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxImageExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageArrayLayers)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedTransforms)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->currentTransform)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedCompositeAlpha)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedUsageFlags)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedSurfaceCounters)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageFormatProperties2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilities2EXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageFormatProperties2* value = wrapper->decoded_value; + VkSurfaceCapabilities2EXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->imageFormatProperties = DecodeAllocator::Allocate(); - wrapper->imageFormatProperties->decoded_value = &(value->imageFormatProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageFormatProperties); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImageCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageCount)); + wrapper->currentExtent = PreloadDecodeAllocator::Allocate(); + wrapper->currentExtent->decoded_value = &(value->currentExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->currentExtent); + wrapper->minImageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->minImageExtent->decoded_value = &(value->minImageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minImageExtent); + wrapper->maxImageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->maxImageExtent->decoded_value = &(value->maxImageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxImageExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageArrayLayers)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedTransforms)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->currentTransform)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedCompositeAlpha)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedUsageFlags)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedSurfaceCounters)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageFormatInfo2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPowerInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageFormatInfo2* value = wrapper->decoded_value; + VkDisplayPowerInfoEXT* 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->format)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tiling)); - bytes_read += ValueDecoder::DecodeFlagsValue((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->powerState)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyProperties2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceEventInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueueFamilyProperties2* value = wrapper->decoded_value; + VkDeviceEventInfoEXT* 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->queueFamilyProperties = DecodeAllocator::Allocate(); - wrapper->queueFamilyProperties->decoded_value = &(value->queueFamilyProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->queueFamilyProperties); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceEvent)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryProperties2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayEventInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMemoryProperties2* value = wrapper->decoded_value; + VkDisplayEventInfoEXT* 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->memoryProperties = DecodeAllocator::Allocate(); - wrapper->memoryProperties->decoded_value = &(value->memoryProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryProperties); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->displayEvent)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSparseImageFormatProperties2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainCounterCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSparseImageFormatProperties2* value = wrapper->decoded_value; + VkSwapchainCounterCreateInfoEXT* 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->properties = DecodeAllocator::Allocate(); - wrapper->properties->decoded_value = &(value->properties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->properties); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->surfaceCounters)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSparseImageFormatInfo2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPowerInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSparseImageFormatInfo2* value = wrapper->decoded_value; + VkDisplayPowerInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->format)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->samples)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tiling)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->powerState)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePointClippingProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceEventInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePointClippingProperties* value = wrapper->decoded_value; + VkDeviceEventInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pointClippingBehavior)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceEvent)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkInputAttachmentAspectReference* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayEventInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkInputAttachmentAspectReference* value = wrapper->decoded_value; + VkDisplayEventInfoEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpass)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputAttachmentIndex)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->displayEvent)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassInputAttachmentAspectCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainCounterCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassInputAttachmentAspectCreateInfo* value = wrapper->decoded_value; + VkSwapchainCounterCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->aspectReferenceCount)); - wrapper->pAspectReferences = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pAspectReferences->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAspectReferences = wrapper->pAspectReferences->GetPointer(); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->surfaceCounters)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewUsageCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRefreshCycleDurationGOOGLE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageViewUsageCreateInfo* value = wrapper->decoded_value; + VkRefreshCycleDurationGOOGLE* 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->usage)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refreshDuration)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineTessellationDomainOriginStateCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPastPresentationTimingGOOGLE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineTessellationDomainOriginStateCreateInfo* value = wrapper->decoded_value; + VkPastPresentationTimingGOOGLE* 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->domainOrigin)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->desiredPresentTime)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->actualPresentTime)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earliestPresentTime)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentMargin)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassMultiviewCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentTimeGOOGLE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassMultiviewCreateInfo* value = wrapper->decoded_value; + VkPresentTimeGOOGLE* 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->subpassCount)); - bytes_read += wrapper->pViewMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pViewMasks = wrapper->pViewMasks.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyCount)); - bytes_read += wrapper->pViewOffsets.DecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pViewOffsets = wrapper->pViewOffsets.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->correlationMaskCount)); - bytes_read += wrapper->pCorrelationMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCorrelationMasks = wrapper->pCorrelationMasks.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->desiredPresentTime)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentTimesInfoGOOGLE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMultiviewFeatures* value = wrapper->decoded_value; + VkPresentTimesInfoGOOGLE* 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->multiview)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewGeometryShader)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewTessellationShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); + wrapper->pTimes = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pTimes->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTimes = wrapper->pTimes->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRefreshCycleDurationGOOGLE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMultiviewProperties* value = wrapper->decoded_value; + VkRefreshCycleDurationGOOGLE* 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->maxMultiviewViewCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiviewInstanceIndex)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refreshDuration)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVariablePointersFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPastPresentationTimingGOOGLE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVariablePointersFeatures* value = wrapper->decoded_value; + VkPastPresentationTimingGOOGLE* 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->variablePointersStorageBuffer)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variablePointers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->desiredPresentTime)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->actualPresentTime)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earliestPresentTime)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentMargin)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProtectedMemoryFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentTimeGOOGLE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceProtectedMemoryFeatures* value = wrapper->decoded_value; + VkPresentTimeGOOGLE* 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->protectedMemory)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->desiredPresentTime)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProtectedMemoryProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentTimesInfoGOOGLE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceProtectedMemoryProperties* value = wrapper->decoded_value; + VkPresentTimesInfoGOOGLE* 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)); + bytes_read += PreloadDecodePNextStruct((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->protectedNoFault)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); + wrapper->pTimes = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pTimes->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTimes = wrapper->pTimes->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueInfo2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceQueueInfo2* value = wrapper->decoded_value; + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* 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->queueFamilyIndex)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewPositionAllComponents)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkProtectedSubmitInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkProtectedSubmitInfo* value = wrapper->decoded_value; + VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* 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)); + bytes_read += PreloadDecodePNextStruct((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->protectedSubmit)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewPositionAllComponents)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViewportSwizzleNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSamplerYcbcrConversionCreateInfo* value = wrapper->decoded_value; + VkViewportSwizzleNV* 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->format)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrModel)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrRange)); - wrapper->components = DecodeAllocator::Allocate(); - wrapper->components->decoded_value = &(value->components); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->components); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->xChromaOffset)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->yChromaOffset)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chromaFilter)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->forceExplicitReconstruction)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->z)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->w)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportSwizzleStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSamplerYcbcrConversionInfo* value = wrapper->decoded_value; + VkPipelineViewportSwizzleStateCreateInfoNV* 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->conversion)); - value->conversion = VK_NULL_HANDLE; + 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->viewportCount)); + wrapper->pViewportSwizzles = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pViewportSwizzles->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewportSwizzles = wrapper->pViewportSwizzles->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImagePlaneMemoryInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViewportSwizzleNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindImagePlaneMemoryInfo* value = wrapper->decoded_value; + VkViewportSwizzleNV* 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->planeAspect)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->z)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->w)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImagePlaneMemoryRequirementsInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportSwizzleStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImagePlaneMemoryRequirementsInfo* value = wrapper->decoded_value; + VkPipelineViewportSwizzleStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->planeAspect)); + 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->viewportCount)); + wrapper->pViewportSwizzles = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pViewportSwizzles->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewportSwizzles = wrapper->pViewportSwizzles->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSamplerYcbcrConversionFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiscardRectanglePropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSamplerYcbcrConversionFeatures* value = wrapper->decoded_value; + VkPhysicalDeviceDiscardRectanglePropertiesEXT* 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->samplerYcbcrConversion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDiscardRectangles)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionImageFormatProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineDiscardRectangleStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSamplerYcbcrConversionImageFormatProperties* value = wrapper->decoded_value; + VkPipelineDiscardRectangleStateCreateInfoEXT* 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->combinedImageSamplerDescriptorCount)); + 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->discardRectangleMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->discardRectangleCount)); + wrapper->pDiscardRectangles = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDiscardRectangles->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDiscardRectangles = wrapper->pDiscardRectangles->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorUpdateTemplateEntry* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiscardRectanglePropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDescriptorUpdateTemplateEntry* value = wrapper->decoded_value; + VkPhysicalDeviceDiscardRectanglePropertiesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBinding)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstArrayElement)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorCount)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorType)); - bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); - bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxDiscardRectangles)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorUpdateTemplateCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineDiscardRectangleStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDescriptorUpdateTemplateCreateInfo* value = wrapper->decoded_value; + VkPipelineDiscardRectangleStateCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->descriptorUpdateEntryCount)); - wrapper->pDescriptorUpdateEntries = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDescriptorUpdateEntries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDescriptorUpdateEntries = wrapper->pDescriptorUpdateEntries->GetPointer(); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->templateType)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->descriptorSetLayout)); - value->descriptorSetLayout = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineBindPoint)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipelineLayout)); - value->pipelineLayout = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->set)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->discardRectangleMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->discardRectangleCount)); + wrapper->pDiscardRectangles = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDiscardRectangles->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDiscardRectangles = wrapper->pDiscardRectangles->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalMemoryProperties* value = wrapper->decoded_value; + VkPhysicalDeviceConservativeRasterizationPropertiesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalMemoryFeatures)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->exportFromImportedHandleTypes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + 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::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveOverestimationSize)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxExtraPrimitiveOverestimationSize)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extraPrimitiveOverestimationSizeGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveUnderestimation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conservativePointAndLineRasterization)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->degenerateTrianglesRasterized)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->degenerateLinesRasterized)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fullyCoveredFragmentShaderInputVariable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conservativeRasterizationPostDepthCoverage)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalImageFormatInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationConservativeStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExternalImageFormatInfo* value = wrapper->decoded_value; + VkPipelineRasterizationConservativeStateCreateInfoEXT* 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->conservativeRasterizationMode)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extraPrimitiveOverestimationSize)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalImageFormatProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalImageFormatProperties* value = wrapper->decoded_value; + VkPhysicalDeviceConservativeRasterizationPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->externalMemoryProperties = DecodeAllocator::Allocate(); - wrapper->externalMemoryProperties->decoded_value = &(value->externalMemoryProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->externalMemoryProperties); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveOverestimationSize)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxExtraPrimitiveOverestimationSize)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extraPrimitiveOverestimationSizeGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveUnderestimation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conservativePointAndLineRasterization)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->degenerateTrianglesRasterized)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->degenerateLinesRasterized)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fullyCoveredFragmentShaderInputVariable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conservativeRasterizationPostDepthCoverage)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalBufferInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationConservativeStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExternalBufferInfo* value = wrapper->decoded_value; + VkPipelineRasterizationConservativeStateCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->usage)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->handleType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->conservativeRasterizationMode)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extraPrimitiveOverestimationSize)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalBufferProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipEnableFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalBufferProperties* value = wrapper->decoded_value; + VkPhysicalDeviceDepthClipEnableFeaturesEXT* 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->externalMemoryProperties = DecodeAllocator::Allocate(); - wrapper->externalMemoryProperties->decoded_value = &(value->externalMemoryProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->externalMemoryProperties); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthClipEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceIDProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationDepthClipStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceIDProperties* value = wrapper->decoded_value; + VkPipelineRasterizationDepthClipStateCreateInfoEXT* 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->deviceUUID.SetExternalMemory(value->deviceUUID, VK_UUID_SIZE); - bytes_read += wrapper->deviceUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->driverUUID.SetExternalMemory(value->driverUUID, VK_UUID_SIZE); - bytes_read += wrapper->driverUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->deviceLUID.SetExternalMemory(value->deviceLUID, VK_LUID_SIZE); - bytes_read += wrapper->deviceLUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceNodeMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceLUIDValid)); + 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->depthClipEnable)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryImageCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipEnableFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalMemoryImageCreateInfo* value = wrapper->decoded_value; + VkPhysicalDeviceDepthClipEnableFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthClipEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryBufferCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationDepthClipStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalMemoryBufferCreateInfo* value = wrapper->decoded_value; + VkPipelineRasterizationDepthClipStateCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + 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->depthClipEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryAllocateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkXYColorEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportMemoryAllocateInfo* value = wrapper->decoded_value; + VkXYColorEXT* 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->handleTypes)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFenceInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHdrMetadataEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExternalFenceInfo* value = wrapper->decoded_value; + VkHdrMetadataEXT* 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)); + wrapper->displayPrimaryRed = DecodeAllocator::Allocate(); + wrapper->displayPrimaryRed->decoded_value = &(value->displayPrimaryRed); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPrimaryRed); + wrapper->displayPrimaryGreen = DecodeAllocator::Allocate(); + wrapper->displayPrimaryGreen->decoded_value = &(value->displayPrimaryGreen); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPrimaryGreen); + wrapper->displayPrimaryBlue = DecodeAllocator::Allocate(); + wrapper->displayPrimaryBlue->decoded_value = &(value->displayPrimaryBlue); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPrimaryBlue); + wrapper->whitePoint = DecodeAllocator::Allocate(); + wrapper->whitePoint->decoded_value = &(value->whitePoint); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->whitePoint); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLuminance)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minLuminance)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxContentLightLevel)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFrameAverageLightLevel)); return bytes_read; } +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkXYColorEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalFenceProperties* wrapper) + size_t bytes_read = 0; + VkXYColorEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHdrMetadataEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalFenceProperties* value = wrapper->decoded_value; + VkHdrMetadataEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->exportFromImportedHandleTypes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFenceFeatures)); + wrapper->displayPrimaryRed = PreloadDecodeAllocator::Allocate(); + wrapper->displayPrimaryRed->decoded_value = &(value->displayPrimaryRed); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPrimaryRed); + wrapper->displayPrimaryGreen = PreloadDecodeAllocator::Allocate(); + wrapper->displayPrimaryGreen->decoded_value = &(value->displayPrimaryGreen); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPrimaryGreen); + wrapper->displayPrimaryBlue = PreloadDecodeAllocator::Allocate(); + wrapper->displayPrimaryBlue->decoded_value = &(value->displayPrimaryBlue); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPrimaryBlue); + wrapper->whitePoint = PreloadDecodeAllocator::Allocate(); + wrapper->whitePoint->decoded_value = &(value->whitePoint); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->whitePoint); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLuminance)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minLuminance)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxContentLightLevel)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFrameAverageLightLevel)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportFenceCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportFenceCreateInfo* value = wrapper->decoded_value; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* 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->handleTypes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->relaxedLineRasterization)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportSemaphoreCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportSemaphoreCreateInfo* value = wrapper->decoded_value; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* 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)); + bytes_read += PreloadDecodePNextStruct((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->handleTypes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->relaxedLineRasterization)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalSemaphoreInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIOSSurfaceCreateInfoMVK* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExternalSemaphoreInfo* value = wrapper->decoded_value; + VkIOSSurfaceCreateInfoMVK* 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pView)); + value->pView = nullptr; return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalSemaphoreProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIOSSurfaceCreateInfoMVK* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalSemaphoreProperties* value = wrapper->decoded_value; + VkIOSSurfaceCreateInfoMVK* 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)); + bytes_read += PreloadDecodePNextStruct((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->exportFromImportedHandleTypes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalSemaphoreFeatures)); + 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->pView)); + value->pView = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance3Properties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMacOSSurfaceCreateInfoMVK* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance3Properties* value = wrapper->decoded_value; + VkMacOSSurfaceCreateInfoMVK* 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->maxPerSetDescriptors)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMemoryAllocationSize)); + 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->pView)); + value->pView = nullptr; return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutSupport* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMacOSSurfaceCreateInfoMVK* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDescriptorSetLayoutSupport* value = wrapper->decoded_value; + VkMacOSSurfaceCreateInfoMVK* 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)); + bytes_read += PreloadDecodePNextStruct((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->supported)); + 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->pView)); + value->pView = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderDrawParametersFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsLabelEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderDrawParametersFeatures* value = wrapper->decoded_value; + VkDebugUtilsLabelEXT* 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->shaderDrawParameters)); + bytes_read += wrapper->pLabelName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLabelName = wrapper->pLabelName.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_VkPhysicalDeviceVulkan11Features* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsObjectNameInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVulkan11Features* value = wrapper->decoded_value; + VkDebugUtilsObjectNameInfoEXT* 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->storageBuffer16BitAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer16BitAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageInputOutput16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiview)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewGeometryShader)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewTessellationShader)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variablePointersStorageBuffer)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variablePointers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->protectedMemory)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerYcbcrConversion)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDrawParameters)); + 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->objectHandle)); + value->objectHandle = 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_VkPhysicalDeviceVulkan11Properties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsMessengerCallbackDataEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVulkan11Properties* value = wrapper->decoded_value; + VkDebugUtilsMessengerCallbackDataEXT* 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->deviceUUID.SetExternalMemory(value->deviceUUID, VK_UUID_SIZE); - bytes_read += wrapper->deviceUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->driverUUID.SetExternalMemory(value->driverUUID, VK_UUID_SIZE); - bytes_read += wrapper->driverUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->deviceLUID.SetExternalMemory(value->deviceLUID, VK_LUID_SIZE); - bytes_read += wrapper->deviceLUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceNodeMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceLUIDValid)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSize)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSupportedStages)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSupportedOperations)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupQuadOperationsInAllStages)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pointClippingBehavior)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiviewViewCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiviewInstanceIndex)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->protectedNoFault)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerSetDescriptors)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMemoryAllocationSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += wrapper->pMessageIdName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMessageIdName = wrapper->pMessageIdName.GetPointer(); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->messageIdNumber)); + bytes_read += wrapper->pMessage.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMessage = wrapper->pMessage.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueLabelCount)); + wrapper->pQueueLabels = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pQueueLabels->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueueLabels = wrapper->pQueueLabels->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cmdBufLabelCount)); + wrapper->pCmdBufLabels = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pCmdBufLabels->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCmdBufLabels = wrapper->pCmdBufLabels->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectCount)); + wrapper->pObjects = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pObjects->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pObjects = wrapper->pObjects->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan12Features* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsMessengerCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVulkan12Features* value = wrapper->decoded_value; + VkDebugUtilsMessengerCreateInfoEXT* 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->samplerMirrorClampToEdge)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drawIndirectCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageBuffer8BitAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer8BitAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant8)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferInt64Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedInt64Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInt8)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayDynamicIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayDynamicIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayDynamicIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformBufferUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingSampledImageUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageImageUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageBufferUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformTexelBufferUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageTexelBufferUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUpdateUnusedWhilePending)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingPartiallyBound)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingVariableDescriptorCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->runtimeDescriptorArray)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerFilterMinmax)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->scalarBlockLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imagelessFramebuffer)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformBufferStandardLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupExtendedTypes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateDepthStencilLayouts)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hostQueryReset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timelineSemaphore)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddress)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressCaptureReplay)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressMultiDevice)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModel)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelDeviceScope)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelAvailabilityVisibilityChains)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderOutputViewportIndex)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderOutputLayer)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupBroadcastDynamicId)); + 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->messageSeverity)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->messageType)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnUserCallback)); + value->pfnUserCallback = 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_VkDebugUtilsObjectTagInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDebugUtilsObjectTagInfoEXT* 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->objectHandle)); + value->objectHandle = 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_VkConformanceVersion* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsLabelEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkConformanceVersion* value = wrapper->decoded_value; + VkDebugUtilsLabelEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->major)); - bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minor)); - bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subminor)); - bytes_read += ValueDecoder::DecodeUInt8Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->patch)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += wrapper->pLabelName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLabelName = wrapper->pLabelName.GetPointer(); + wrapper->color.SetExternalMemory(value->color, 4); + bytes_read += wrapper->color.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan12Properties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsObjectNameInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVulkan12Properties* value = wrapper->decoded_value; + VkDebugUtilsObjectNameInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->driverID)); - wrapper->driverName.SetExternalMemory(value->driverName, VK_MAX_DRIVER_NAME_SIZE); - bytes_read += wrapper->driverName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->driverInfo.SetExternalMemory(value->driverInfo, VK_MAX_DRIVER_INFO_SIZE); - bytes_read += wrapper->driverInfo.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->conformanceVersion = DecodeAllocator::Allocate(); - wrapper->conformanceVersion->decoded_value = &(value->conformanceVersion); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->conformanceVersion); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->denormBehaviorIndependence)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->roundingModeIndependence)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat64)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat64)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat64)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat64)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat64)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxUpdateAfterBindDescriptorsInAllPools)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustBufferAccessUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->quadDivergentImplicitLod)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSamplers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindUniformBuffers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageBuffers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSampledImages)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageImages)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInputAttachments)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageUpdateAfterBindResources)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSamplers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSampledImages)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageImages)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInputAttachments)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedDepthResolveModes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedStencilResolveModes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolveNone)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolve)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterMinmaxSingleComponentFormats)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterMinmaxImageComponentMapping)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTimelineSemaphoreValueDifference)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->framebufferIntegerColorSampleCounts)); + 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->objectHandle)); + value->objectHandle = 0; + bytes_read += wrapper->pObjectName.PreloadDecode((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_VkImageFormatListCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsMessengerCallbackDataEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageFormatListCreateInfo* value = wrapper->decoded_value; + VkDebugUtilsMessengerCallbackDataEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->viewFormatCount)); - bytes_read += wrapper->pViewFormats.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pViewFormats = wrapper->pViewFormats.GetPointer(); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += wrapper->pMessageIdName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMessageIdName = wrapper->pMessageIdName.GetPointer(); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->messageIdNumber)); + bytes_read += wrapper->pMessage.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMessage = wrapper->pMessage.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueLabelCount)); + wrapper->pQueueLabels = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pQueueLabels->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueueLabels = wrapper->pQueueLabels->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cmdBufLabelCount)); + wrapper->pCmdBufLabels = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pCmdBufLabels->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCmdBufLabels = wrapper->pCmdBufLabels->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectCount)); + wrapper->pObjects = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pObjects->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pObjects = wrapper->pObjects->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentDescription2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsMessengerCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAttachmentDescription2* value = wrapper->decoded_value; + VkDebugUtilsMessengerCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->format)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->samples)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->loadOp)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storeOp)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilLoadOp)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilStoreOp)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialLayout)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->finalLayout)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->messageSeverity)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->messageType)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnUserCallback)); + value->pfnUserCallback = 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_VkAttachmentReference2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsObjectTagInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAttachmentReference2* value = wrapper->decoded_value; + VkDebugUtilsObjectTagInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->attachment)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->layout)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->aspectMask)); + 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->objectHandle)); + value->objectHandle = 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.PreloadDecodeVoid((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_VkSubpassDescription2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferUsageANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubpassDescription2* value = wrapper->decoded_value; + VkAndroidHardwareBufferUsageANDROID* 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->pipelineBindPoint)); - 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->inputAttachmentCount)); - wrapper->pInputAttachments = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pInputAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pInputAttachments = wrapper->pInputAttachments->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentCount)); - wrapper->pColorAttachments = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pColorAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pColorAttachments = wrapper->pColorAttachments->GetPointer(); - wrapper->pResolveAttachments = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pResolveAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pResolveAttachments = wrapper->pResolveAttachments->GetPointer(); - wrapper->pDepthStencilAttachment = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDepthStencilAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDepthStencilAttachment = wrapper->pDepthStencilAttachment->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preserveAttachmentCount)); - bytes_read += wrapper->pPreserveAttachments.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPreserveAttachments = wrapper->pPreserveAttachments.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->androidHardwareBufferUsage)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDependency2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferPropertiesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubpassDependency2* value = wrapper->decoded_value; + VkAndroidHardwareBufferPropertiesANDROID* 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->srcSubpass)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstSubpass)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcStageMask)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyFlags)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->allocationSize)); + 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_VkRenderPassCreateInfo2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatPropertiesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassCreateInfo2* value = wrapper->decoded_value; + VkAndroidHardwareBufferFormatPropertiesANDROID* 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->attachmentCount)); - wrapper->pAttachments = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAttachments = wrapper->pAttachments->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassCount)); - wrapper->pSubpasses = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSubpasses->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSubpasses = wrapper->pSubpasses->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dependencyCount)); - wrapper->pDependencies = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDependencies->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDependencies = wrapper->pDependencies->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->correlatedViewMaskCount)); - bytes_read += wrapper->pCorrelatedViewMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCorrelatedViewMasks = wrapper->pCorrelatedViewMasks.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormat)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatFeatures)); + wrapper->samplerYcbcrConversionComponents = DecodeAllocator::Allocate(); + wrapper->samplerYcbcrConversionComponents->decoded_value = &(value->samplerYcbcrConversionComponents); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->samplerYcbcrConversionComponents); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrModel)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrRange)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedXChromaOffset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYChromaOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassBeginInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportAndroidHardwareBufferInfoANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubpassBeginInfo* value = wrapper->decoded_value; + VkImportAndroidHardwareBufferInfoANDROID* 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->contents)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassEndInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetAndroidHardwareBufferInfoANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubpassEndInfo* value = wrapper->decoded_value; + VkMemoryGetAndroidHardwareBufferInfoANDROID* 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; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevice8BitStorageFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalFormatANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevice8BitStorageFeatures* value = wrapper->decoded_value; + VkExternalFormatANDROID* 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->storageBuffer8BitAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformAndStorageBuffer8BitAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storagePushConstant8)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormat)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDriverProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatProperties2ANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDriverProperties* value = wrapper->decoded_value; + VkAndroidHardwareBufferFormatProperties2ANDROID* 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->driverID)); - wrapper->driverName.SetExternalMemory(value->driverName, VK_MAX_DRIVER_NAME_SIZE); - bytes_read += wrapper->driverName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->driverInfo.SetExternalMemory(value->driverInfo, VK_MAX_DRIVER_INFO_SIZE); - bytes_read += wrapper->driverInfo.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->conformanceVersion = DecodeAllocator::Allocate(); - wrapper->conformanceVersion->decoded_value = &(value->conformanceVersion); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->conformanceVersion); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormat)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatFeatures)); + wrapper->samplerYcbcrConversionComponents = DecodeAllocator::Allocate(); + wrapper->samplerYcbcrConversionComponents->decoded_value = &(value->samplerYcbcrConversionComponents); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->samplerYcbcrConversionComponents); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrModel)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrRange)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedXChromaOffset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYChromaOffset)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferUsageANDROID* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkAndroidHardwareBufferUsageANDROID* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->androidHardwareBufferUsage)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicInt64Features* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferPropertiesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderAtomicInt64Features* value = wrapper->decoded_value; + VkAndroidHardwareBufferPropertiesANDROID* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderBufferInt64Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->allocationSize)); + 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_VkPhysicalDeviceShaderFloat16Int8Features* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatPropertiesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderFloat16Int8Features* value = wrapper->decoded_value; + VkAndroidHardwareBufferFormatPropertiesANDROID* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInt8)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormat)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatFeatures)); + wrapper->samplerYcbcrConversionComponents = PreloadDecodeAllocator::Allocate(); + wrapper->samplerYcbcrConversionComponents->decoded_value = &(value->samplerYcbcrConversionComponents); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->samplerYcbcrConversionComponents); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrModel)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrRange)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedXChromaOffset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYChromaOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFloatControlsProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportAndroidHardwareBufferInfoANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFloatControlsProperties* value = wrapper->decoded_value; + VkImportAndroidHardwareBufferInfoANDROID* 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)); + bytes_read += PreloadDecodePNextStruct((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->denormBehaviorIndependence)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->roundingModeIndependence)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSignedZeroInfNanPreserveFloat64)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormPreserveFloat64)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDenormFlushToZeroFloat64)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTEFloat64)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat16)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat32)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRoundingModeRTZFloat64)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutBindingFlagsCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetAndroidHardwareBufferInfoANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDescriptorSetLayoutBindingFlagsCreateInfo* value = wrapper->decoded_value; + VkMemoryGetAndroidHardwareBufferInfoANDROID* 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)); + bytes_read += PreloadDecodePNextStruct((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->bindingCount)); - bytes_read += wrapper->pBindingFlags.DecodeFlags((buffer + bytes_read), (buffer_size - bytes_read)); - value->pBindingFlags = wrapper->pBindingFlags.GetPointer(); + 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_VkPhysicalDeviceDescriptorIndexingFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalFormatANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDescriptorIndexingFeatures* value = wrapper->decoded_value; + VkExternalFormatANDROID* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderInputAttachmentArrayDynamicIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayDynamicIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayDynamicIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformTexelBufferArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageTexelBufferArrayNonUniformIndexing)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformBufferUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingSampledImageUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageImageUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageBufferUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUniformTexelBufferUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingStorageTexelBufferUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingUpdateUnusedWhilePending)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingPartiallyBound)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingVariableDescriptorCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->runtimeDescriptorArray)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormat)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorIndexingProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatProperties2ANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDescriptorIndexingProperties* value = wrapper->decoded_value; + VkAndroidHardwareBufferFormatProperties2ANDROID* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxUpdateAfterBindDescriptorsInAllPools)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderUniformBufferArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampledImageArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageBufferArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStorageImageArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderInputAttachmentArrayNonUniformIndexingNative)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustBufferAccessUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->quadDivergentImplicitLod)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSamplers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindUniformBuffers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageBuffers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindSampledImages)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindStorageImages)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInputAttachments)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageUpdateAfterBindResources)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSamplers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindSampledImages)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindStorageImages)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInputAttachments)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormat)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatFeatures)); + wrapper->samplerYcbcrConversionComponents = PreloadDecodeAllocator::Allocate(); + wrapper->samplerYcbcrConversionComponents->decoded_value = &(value->samplerYcbcrConversionComponents); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->samplerYcbcrConversionComponents); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrModel)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrRange)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedXChromaOffset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYChromaOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetVariableDescriptorCountAllocateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSampleLocationEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDescriptorSetVariableDescriptorCountAllocateInfo* value = wrapper->decoded_value; + VkSampleLocationEXT* 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->descriptorSetCount)); - bytes_read += wrapper->pDescriptorCounts.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDescriptorCounts = wrapper->pDescriptorCounts.GetPointer(); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetVariableDescriptorCountLayoutSupport* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSampleLocationsInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDescriptorSetVariableDescriptorCountLayoutSupport* value = wrapper->decoded_value; + VkSampleLocationsInfoEXT* 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->maxVariableDescriptorCount)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationsPerPixel)); + wrapper->sampleLocationGridSize = DecodeAllocator::Allocate(); + wrapper->sampleLocationGridSize->decoded_value = &(value->sampleLocationGridSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationGridSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationsCount)); + wrapper->pSampleLocations = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSampleLocations->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSampleLocations = wrapper->pSampleLocations->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassDescriptionDepthStencilResolve* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentSampleLocationsEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubpassDescriptionDepthStencilResolve* value = wrapper->decoded_value; + VkAttachmentSampleLocationsEXT* 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->depthResolveMode)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilResolveMode)); - wrapper->pDepthStencilResolveAttachment = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDepthStencilResolveAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDepthStencilResolveAttachment = wrapper->pDepthStencilResolveAttachment->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentIndex)); + wrapper->sampleLocationsInfo = DecodeAllocator::Allocate(); + wrapper->sampleLocationsInfo->decoded_value = &(value->sampleLocationsInfo); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationsInfo); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthStencilResolveProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassSampleLocationsEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDepthStencilResolveProperties* value = wrapper->decoded_value; + VkSubpassSampleLocationsEXT* 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->supportedDepthResolveModes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedStencilResolveModes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolveNone)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->independentResolve)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassIndex)); + wrapper->sampleLocationsInfo = DecodeAllocator::Allocate(); + wrapper->sampleLocationsInfo->decoded_value = &(value->sampleLocationsInfo); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationsInfo); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceScalarBlockLayoutFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassSampleLocationsBeginInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceScalarBlockLayoutFeatures* value = wrapper->decoded_value; + VkRenderPassSampleLocationsBeginInfoEXT* 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->scalarBlockLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentInitialSampleLocationsCount)); + wrapper->pAttachmentInitialSampleLocations = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttachmentInitialSampleLocations->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachmentInitialSampleLocations = wrapper->pAttachmentInitialSampleLocations->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->postSubpassSampleLocationsCount)); + wrapper->pPostSubpassSampleLocations = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pPostSubpassSampleLocations->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPostSubpassSampleLocations = wrapper->pPostSubpassSampleLocations->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageStencilUsageCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineSampleLocationsStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageStencilUsageCreateInfo* value = wrapper->decoded_value; + VkPipelineSampleLocationsStateCreateInfoEXT* 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->stencilUsage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationsEnable)); + wrapper->sampleLocationsInfo = DecodeAllocator::Allocate(); + wrapper->sampleLocationsInfo->decoded_value = &(value->sampleLocationsInfo); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationsInfo); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerReductionModeCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSampleLocationsPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSamplerReductionModeCreateInfo* value = wrapper->decoded_value; + VkPhysicalDeviceSampleLocationsPropertiesEXT* 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->reductionMode)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationSampleCounts)); + wrapper->maxSampleLocationGridSize = DecodeAllocator::Allocate(); + wrapper->maxSampleLocationGridSize->decoded_value = &(value->maxSampleLocationGridSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSampleLocationGridSize); + wrapper->sampleLocationCoordinateRange.SetExternalMemory(value->sampleLocationCoordinateRange, 2); + bytes_read += wrapper->sampleLocationCoordinateRange.DecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationSubPixelBits)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variableSampleLocations)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSamplerFilterMinmaxProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultisamplePropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSamplerFilterMinmaxProperties* value = wrapper->decoded_value; + VkMultisamplePropertiesEXT* 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->filterMinmaxSingleComponentFormats)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterMinmaxImageComponentMapping)); + wrapper->maxSampleLocationGridSize = DecodeAllocator::Allocate(); + wrapper->maxSampleLocationGridSize->decoded_value = &(value->maxSampleLocationGridSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSampleLocationGridSize); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkanMemoryModelFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSampleLocationEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVulkanMemoryModelFeatures* value = wrapper->decoded_value; + VkSampleLocationEXT* 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->vulkanMemoryModel)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelDeviceScope)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vulkanMemoryModelAvailabilityVisibilityChains)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImagelessFramebufferFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSampleLocationsInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImagelessFramebufferFeatures* value = wrapper->decoded_value; + VkSampleLocationsInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->imagelessFramebuffer)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationsPerPixel)); + wrapper->sampleLocationGridSize = PreloadDecodeAllocator::Allocate(); + wrapper->sampleLocationGridSize->decoded_value = &(value->sampleLocationGridSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationGridSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationsCount)); + wrapper->pSampleLocations = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSampleLocations->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSampleLocations = wrapper->pSampleLocations->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFramebufferAttachmentImageInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentSampleLocationsEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFramebufferAttachmentImageInfo* 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->usage)); - 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->layerCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewFormatCount)); - bytes_read += wrapper->pViewFormats.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pViewFormats = wrapper->pViewFormats.GetPointer(); + VkAttachmentSampleLocationsEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentIndex)); + wrapper->sampleLocationsInfo = PreloadDecodeAllocator::Allocate(); + wrapper->sampleLocationsInfo->decoded_value = &(value->sampleLocationsInfo); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationsInfo); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFramebufferAttachmentsCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassSampleLocationsEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFramebufferAttachmentsCreateInfo* value = wrapper->decoded_value; + VkSubpassSampleLocationsEXT* 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->attachmentImageInfoCount)); - wrapper->pAttachmentImageInfos = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pAttachmentImageInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAttachmentImageInfos = wrapper->pAttachmentImageInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassIndex)); + wrapper->sampleLocationsInfo = PreloadDecodeAllocator::Allocate(); + wrapper->sampleLocationsInfo->decoded_value = &(value->sampleLocationsInfo); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationsInfo); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassAttachmentBeginInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassSampleLocationsBeginInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassAttachmentBeginInfo* value = wrapper->decoded_value; + VkRenderPassSampleLocationsBeginInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->attachmentCount)); - bytes_read += wrapper->pAttachments.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAttachments = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentInitialSampleLocationsCount)); + wrapper->pAttachmentInitialSampleLocations = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAttachmentInitialSampleLocations->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAttachmentInitialSampleLocations = wrapper->pAttachmentInitialSampleLocations->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->postSubpassSampleLocationsCount)); + wrapper->pPostSubpassSampleLocations = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPostSubpassSampleLocations->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPostSubpassSampleLocations = wrapper->pPostSubpassSampleLocations->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineSampleLocationsStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceUniformBufferStandardLayoutFeatures* value = wrapper->decoded_value; + VkPipelineSampleLocationsStateCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->uniformBufferStandardLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationsEnable)); + wrapper->sampleLocationsInfo = PreloadDecodeAllocator::Allocate(); + wrapper->sampleLocationsInfo->decoded_value = &(value->sampleLocationsInfo); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationsInfo); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSampleLocationsPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* value = wrapper->decoded_value; + VkPhysicalDeviceSampleLocationsPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderSubgroupExtendedTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationSampleCounts)); + wrapper->maxSampleLocationGridSize = PreloadDecodeAllocator::Allocate(); + wrapper->maxSampleLocationGridSize->decoded_value = &(value->maxSampleLocationGridSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSampleLocationGridSize); + wrapper->sampleLocationCoordinateRange.SetExternalMemory(value->sampleLocationCoordinateRange, 2); + bytes_read += wrapper->sampleLocationCoordinateRange.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationSubPixelBits)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variableSampleLocations)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultisamplePropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* value = wrapper->decoded_value; + VkMultisamplePropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->separateDepthStencilLayouts)); + wrapper->maxSampleLocationGridSize = PreloadDecodeAllocator::Allocate(); + wrapper->maxSampleLocationGridSize->decoded_value = &(value->maxSampleLocationGridSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSampleLocationGridSize); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentReferenceStencilLayout* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAttachmentReferenceStencilLayout* value = wrapper->decoded_value; + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* 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->stencilLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendCoherentOperations)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentDescriptionStencilLayout* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAttachmentDescriptionStencilLayout* value = wrapper->decoded_value; + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* 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->stencilInitialLayout)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->stencilFinalLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendMaxColorAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendIndependentBlend)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendNonPremultipliedSrcColor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendNonPremultipliedDstColor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendCorrelatedOverlap)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendAllOperations)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostQueryResetFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineColorBlendAdvancedStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceHostQueryResetFeatures* value = wrapper->decoded_value; + VkPipelineColorBlendAdvancedStateCreateInfoEXT* 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->hostQueryReset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcPremultiplied)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstPremultiplied)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->blendOverlap)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTimelineSemaphoreFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTimelineSemaphoreFeatures* value = wrapper->decoded_value; + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->timelineSemaphore)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendCoherentOperations)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTimelineSemaphoreProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTimelineSemaphoreProperties* value = wrapper->decoded_value; + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxTimelineSemaphoreValueDifference)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendMaxColorAttachments)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendIndependentBlend)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendNonPremultipliedSrcColor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendNonPremultipliedDstColor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendCorrelatedOverlap)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendAllOperations)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreTypeCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineColorBlendAdvancedStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSemaphoreTypeCreateInfo* value = wrapper->decoded_value; + VkPipelineColorBlendAdvancedStateCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->semaphoreType)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialValue)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcPremultiplied)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstPremultiplied)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->blendOverlap)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTimelineSemaphoreSubmitInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCoverageToColorStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkTimelineSemaphoreSubmitInfo* value = wrapper->decoded_value; + VkPipelineCoverageToColorStateCreateInfoNV* 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->waitSemaphoreValueCount)); - 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->signalSemaphoreValueCount)); - bytes_read += wrapper->pSignalSemaphoreValues.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSignalSemaphoreValues = wrapper->pSignalSemaphoreValues.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->coverageToColorEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageToColorLocation)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreWaitInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCoverageToColorStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSemaphoreWaitInfo* value = wrapper->decoded_value; + VkPipelineCoverageToColorStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->semaphoreCount)); - bytes_read += wrapper->pSemaphores.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSemaphores = nullptr; - bytes_read += wrapper->pValues.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - value->pValues = wrapper->pValues.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageToColorEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageToColorLocation)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreSignalInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCoverageModulationStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSemaphoreSignalInfo* value = wrapper->decoded_value; + VkPipelineCoverageModulationStateCreateInfoNV* 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->value)); + 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->coverageModulationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageModulationTableEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageModulationTableCount)); + bytes_read += wrapper->pCoverageModulationTable.DecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCoverageModulationTable = wrapper->pCoverageModulationTable.GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBufferDeviceAddressFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCoverageModulationStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceBufferDeviceAddressFeatures* value = wrapper->decoded_value; + VkPipelineCoverageModulationStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->bufferDeviceAddress)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressCaptureReplay)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressMultiDevice)); + 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->coverageModulationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageModulationTableEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageModulationTableCount)); + bytes_read += wrapper->pCoverageModulationTable.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCoverageModulationTable = wrapper->pCoverageModulationTable.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferDeviceAddressInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBufferDeviceAddressInfo* value = wrapper->decoded_value; + VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* 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->buffer)); - value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSMCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderWarpsPerSM)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferOpaqueCaptureAddressCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBufferOpaqueCaptureAddressCreateInfo* value = wrapper->decoded_value; + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* 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->opaqueCaptureAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSMBuiltins)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryOpaqueCaptureAddressAllocateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryOpaqueCaptureAddressAllocateInfo* value = wrapper->decoded_value; + VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->opaqueCaptureAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSMCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderWarpsPerSM)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceMemoryOpaqueCaptureAddressInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceMemoryOpaqueCaptureAddressInfo* value = wrapper->decoded_value; + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSMBuiltins)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan13Features* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVulkan13Features* value = wrapper->decoded_value; + VkDrmFormatModifierPropertiesEXT* 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->robustImageAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inlineUniformBlock)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingInlineUniformBlockUpdateAfterBind)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineCreationCacheControl)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->privateData)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDemoteToHelperInvocation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTerminateInvocation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subgroupSizeControl)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeFullSubgroups)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->synchronization2)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureCompressionASTC_HDR)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderZeroInitializeWorkgroupMemory)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicRendering)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderIntegerDotProduct)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maintenance4)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierPlaneCount)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierTilingFeatures)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan13Properties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesListEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVulkan13Properties* value = wrapper->decoded_value; + VkDrmFormatModifierPropertiesListEXT* 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->minSubgroupSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubgroupSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxComputeWorkgroupSubgroups)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiredSubgroupSizeStages)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInlineUniformBlockSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorInlineUniformBlocks)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetInlineUniformBlocks)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInlineUniformBlocks)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInlineUniformTotalSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageTexelBufferOffsetAlignmentBytes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageTexelBufferOffsetSingleTexelAlignment)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetAlignmentBytes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetSingleTexelAlignment)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxBufferSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierCount)); + wrapper->pDrmFormatModifierProperties = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDrmFormatModifierProperties->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDrmFormatModifierProperties = wrapper->pDrmFormatModifierProperties->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCreationFeedback* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineCreationFeedback* value = wrapper->decoded_value; + VkPhysicalDeviceImageDrmFormatModifierInfoEXT* value = wrapper->decoded_value; - 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->duration)); + 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->drmFormatModifier)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sharingMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndexCount)); + bytes_read += wrapper->pQueueFamilyIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueueFamilyIndices = wrapper->pQueueFamilyIndices.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCreationFeedbackCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierListCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineCreationFeedbackCreateInfo* value = wrapper->decoded_value; + VkImageDrmFormatModifierListCreateInfoEXT* 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->pPipelineCreationFeedback = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pPipelineCreationFeedback->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPipelineCreationFeedback = wrapper->pPipelineCreationFeedback->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineStageCreationFeedbackCount)); - wrapper->pPipelineStageCreationFeedbacks = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pPipelineStageCreationFeedbacks->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPipelineStageCreationFeedbacks = wrapper->pPipelineStageCreationFeedbacks->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierCount)); + bytes_read += wrapper->pDrmFormatModifiers.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDrmFormatModifiers = wrapper->pDrmFormatModifiers.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTerminateInvocationFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierExplicitCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderTerminateInvocationFeatures* value = wrapper->decoded_value; + VkImageDrmFormatModifierExplicitCreateInfoEXT* 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->shaderTerminateInvocation)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierPlaneCount)); + wrapper->pPlaneLayouts = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pPlaneLayouts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPlaneLayouts = wrapper->pPlaneLayouts->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceToolProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceToolProperties* value = wrapper->decoded_value; + VkImageDrmFormatModifierPropertiesEXT* 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_EXTENSION_NAME_SIZE); - bytes_read += wrapper->name.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->version.SetExternalMemory(value->version, VK_MAX_EXTENSION_NAME_SIZE); - bytes_read += wrapper->version.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->purposes)); - wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->layer.SetExternalMemory(value->layer, VK_MAX_EXTENSION_NAME_SIZE); - bytes_read += wrapper->layer.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierProperties2EXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* value = wrapper->decoded_value; + VkDrmFormatModifierProperties2EXT* 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->shaderDemoteToHelperInvocation)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierPlaneCount)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierTilingFeatures)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrivateDataFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesList2EXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePrivateDataFeatures* value = wrapper->decoded_value; + VkDrmFormatModifierPropertiesList2EXT* 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->privateData)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierCount)); + wrapper->pDrmFormatModifierProperties = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDrmFormatModifierProperties->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDrmFormatModifierProperties = wrapper->pDrmFormatModifierProperties->GetPointer(); return bytes_read; } +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDevicePrivateDataCreateInfo* wrapper) + size_t bytes_read = 0; + VkDrmFormatModifierPropertiesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierPlaneCount)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierTilingFeatures)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesListEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDevicePrivateDataCreateInfo* value = wrapper->decoded_value; + VkDrmFormatModifierPropertiesListEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->privateDataSlotRequestCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierCount)); + wrapper->pDrmFormatModifierProperties = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDrmFormatModifierProperties->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDrmFormatModifierProperties = wrapper->pDrmFormatModifierProperties->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPrivateDataSlotCreateInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPrivateDataSlotCreateInfo* value = wrapper->decoded_value; + VkPhysicalDeviceImageDrmFormatModifierInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->drmFormatModifier)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sharingMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndexCount)); + bytes_read += wrapper->pQueueFamilyIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pQueueFamilyIndices = wrapper->pQueueFamilyIndices.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineCreationCacheControlFeatures* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierListCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePipelineCreationCacheControlFeatures* value = wrapper->decoded_value; + VkImageDrmFormatModifierListCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pipelineCreationCacheControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierCount)); + bytes_read += wrapper->pDrmFormatModifiers.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDrmFormatModifiers = wrapper->pDrmFormatModifiers.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryBarrier2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierExplicitCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryBarrier2* value = wrapper->decoded_value; + VkImageDrmFormatModifierExplicitCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->srcStageMask)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierPlaneCount)); + wrapper->pPlaneLayouts = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPlaneLayouts->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPlaneLayouts = wrapper->pPlaneLayouts->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferMemoryBarrier2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBufferMemoryBarrier2* value = wrapper->decoded_value; + VkImageDrmFormatModifierPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->srcStageMask)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcQueueFamilyIndex)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstQueueFamilyIndex)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); - value->buffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageMemoryBarrier2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierProperties2EXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageMemoryBarrier2* value = wrapper->decoded_value; + VkDrmFormatModifierProperties2EXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierPlaneCount)); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierTilingFeatures)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesList2EXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDrmFormatModifierPropertiesList2EXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->srcStageMask)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAccessMask)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstStageMask)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAccessMask)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->oldLayout)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->newLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcQueueFamilyIndex)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstQueueFamilyIndex)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); - value->image = VK_NULL_HANDLE; - wrapper->subresourceRange = DecodeAllocator::Allocate(); - wrapper->subresourceRange->decoded_value = &(value->subresourceRange); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceRange); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierCount)); + wrapper->pDrmFormatModifierProperties = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDrmFormatModifierProperties->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDrmFormatModifierProperties = wrapper->pDrmFormatModifierProperties->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDependencyInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkValidationCacheCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDependencyInfo* value = wrapper->decoded_value; + VkValidationCacheCreateInfoEXT* 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->dependencyFlags)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryBarrierCount)); - wrapper->pMemoryBarriers = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pMemoryBarriers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pMemoryBarriers = wrapper->pMemoryBarriers->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferMemoryBarrierCount)); - wrapper->pBufferMemoryBarriers = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pBufferMemoryBarriers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pBufferMemoryBarriers = wrapper->pBufferMemoryBarriers->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageMemoryBarrierCount)); - wrapper->pImageMemoryBarriers = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pImageMemoryBarriers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pImageMemoryBarriers = wrapper->pImageMemoryBarriers->GetPointer(); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialDataSize)); + bytes_read += wrapper->pInitialData.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pInitialData = wrapper->pInitialData.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreSubmitInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderModuleValidationCacheCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSemaphoreSubmitInfo* value = wrapper->decoded_value; + VkShaderModuleValidationCacheCreateInfoEXT* 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->value)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceIndex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->validationCache)); + value->validationCache = VK_NULL_HANDLE; return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferSubmitInfo* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkValidationCacheCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCommandBufferSubmitInfo* value = wrapper->decoded_value; + VkValidationCacheCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->commandBuffer)); - value->commandBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceMask)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialDataSize)); + bytes_read += wrapper->pInitialData.PreloadDecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pInitialData = wrapper->pInitialData.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubmitInfo2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderModuleValidationCacheCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubmitInfo2* value = wrapper->decoded_value; + VkShaderModuleValidationCacheCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->waitSemaphoreInfoCount)); - wrapper->pWaitSemaphoreInfos = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pWaitSemaphoreInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pWaitSemaphoreInfos = wrapper->pWaitSemaphoreInfos->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->commandBufferInfoCount)); - wrapper->pCommandBufferInfos = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pCommandBufferInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCommandBufferInfos = wrapper->pCommandBufferInfos->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->signalSemaphoreInfoCount)); - wrapper->pSignalSemaphoreInfos = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSignalSemaphoreInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSignalSemaphoreInfos = wrapper->pSignalSemaphoreInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->validationCache)); + value->validationCache = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSynchronization2Features* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShadingRatePaletteNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSynchronization2Features* value = wrapper->decoded_value; + VkShadingRatePaletteNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRatePaletteEntryCount)); + bytes_read += wrapper->pShadingRatePaletteEntries.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pShadingRatePaletteEntries = wrapper->pShadingRatePaletteEntries.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportShadingRateImageStateCreateInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineViewportShadingRateImageStateCreateInfoNV* 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->synchronization2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateImageEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportCount)); + wrapper->pShadingRatePalettes = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pShadingRatePalettes->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pShadingRatePalettes = wrapper->pShadingRatePalettes->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShadingRateImageFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* value = wrapper->decoded_value; + VkPhysicalDeviceShadingRateImageFeaturesNV* 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->shaderZeroInitializeWorkgroupMemory)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateImage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateCoarseSampleOrder)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageRobustnessFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShadingRateImagePropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageRobustnessFeatures* value = wrapper->decoded_value; + VkPhysicalDeviceShadingRateImagePropertiesNV* 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->robustImageAccess)); + wrapper->shadingRateTexelSize = DecodeAllocator::Allocate(); + wrapper->shadingRateTexelSize->decoded_value = &(value->shadingRateTexelSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->shadingRateTexelSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRatePaletteSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateMaxCoarseSamples)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferCopy2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCoarseSampleLocationNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBufferCopy2* value = wrapper->decoded_value; + VkCoarseSampleLocationNV* 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->srcOffset)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstOffset)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pixelX)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pixelY)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sample)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyBufferInfo2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCoarseSampleOrderCustomNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyBufferInfo2* value = wrapper->decoded_value; + VkCoarseSampleOrderCustomNV* 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->srcBuffer)); - value->srcBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstBuffer)); - value->dstBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); - wrapper->pRegions = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRegions = wrapper->pRegions->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationCount)); + wrapper->pSampleLocations = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSampleLocations->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSampleLocations = wrapper->pSampleLocations->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCopy2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageCopy2* value = wrapper->decoded_value; + VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* 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->srcSubresource = DecodeAllocator::Allocate(); - wrapper->srcSubresource->decoded_value = &(value->srcSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); - wrapper->srcOffset = DecodeAllocator::Allocate(); - wrapper->srcOffset->decoded_value = &(value->srcOffset); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcOffset); - wrapper->dstSubresource = DecodeAllocator::Allocate(); - wrapper->dstSubresource->decoded_value = &(value->dstSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); - wrapper->dstOffset = DecodeAllocator::Allocate(); - wrapper->dstOffset->decoded_value = &(value->dstOffset); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstOffset); - 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleOrderType)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->customSampleOrderCount)); + wrapper->pCustomSampleOrders = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pCustomSampleOrders->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCustomSampleOrders = wrapper->pCustomSampleOrders->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageInfo2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShadingRatePaletteNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyImageInfo2* value = wrapper->decoded_value; + VkShadingRatePaletteNV* 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->srcImage)); - value->srcImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); - value->dstImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); - 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->shadingRatePaletteEntryCount)); + bytes_read += wrapper->pShadingRatePaletteEntries.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pShadingRatePaletteEntries = wrapper->pShadingRatePaletteEntries.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferImageCopy2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportShadingRateImageStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBufferImageCopy2* value = wrapper->decoded_value; + VkPipelineViewportShadingRateImageStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->bufferOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferRowLength)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferImageHeight)); - wrapper->imageSubresource = DecodeAllocator::Allocate(); - wrapper->imageSubresource->decoded_value = &(value->imageSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); - wrapper->imageOffset = DecodeAllocator::Allocate(); - wrapper->imageOffset->decoded_value = &(value->imageOffset); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); - wrapper->imageExtent = DecodeAllocator::Allocate(); - wrapper->imageExtent->decoded_value = &(value->imageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateImageEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportCount)); + wrapper->pShadingRatePalettes = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pShadingRatePalettes->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pShadingRatePalettes = wrapper->pShadingRatePalettes->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyBufferToImageInfo2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShadingRateImageFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyBufferToImageInfo2* value = wrapper->decoded_value; + VkPhysicalDeviceShadingRateImageFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->srcBuffer)); - value->srcBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); - value->dstImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); - 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->shadingRateImage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateCoarseSampleOrder)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageToBufferInfo2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShadingRateImagePropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyImageToBufferInfo2* value = wrapper->decoded_value; + VkPhysicalDeviceShadingRateImagePropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->srcImage)); - value->srcImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstBuffer)); - value->dstBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); - wrapper->pRegions = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRegions = wrapper->pRegions->GetPointer(); + wrapper->shadingRateTexelSize = PreloadDecodeAllocator::Allocate(); + wrapper->shadingRateTexelSize->decoded_value = &(value->shadingRateTexelSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->shadingRateTexelSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRatePaletteSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateMaxCoarseSamples)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageBlit2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCoarseSampleLocationNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageBlit2* value = wrapper->decoded_value; + VkCoarseSampleLocationNV* 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->srcSubresource = DecodeAllocator::Allocate(); - wrapper->srcSubresource->decoded_value = &(value->srcSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); - wrapper->srcOffsets = DecodeAllocator::Allocate>(); - wrapper->srcOffsets->SetExternalMemory(value->srcOffsets, 2); - bytes_read += wrapper->srcOffsets->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->dstSubresource = DecodeAllocator::Allocate(); - wrapper->dstSubresource->decoded_value = &(value->dstSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); - wrapper->dstOffsets = DecodeAllocator::Allocate>(); - wrapper->dstOffsets->SetExternalMemory(value->dstOffsets, 2); - bytes_read += wrapper->dstOffsets->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pixelX)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pixelY)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sample)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBlitImageInfo2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCoarseSampleOrderCustomNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBlitImageInfo2* value = wrapper->decoded_value; + VkCoarseSampleOrderCustomNV* 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->srcImage)); - value->srcImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); - value->dstImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); - wrapper->pRegions = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRegions = wrapper->pRegions->GetPointer(); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->filter)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationCount)); + wrapper->pSampleLocations = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSampleLocations->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSampleLocations = wrapper->pSampleLocations->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageResolve2* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageResolve2* value = wrapper->decoded_value; + VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->srcSubresource = DecodeAllocator::Allocate(); - wrapper->srcSubresource->decoded_value = &(value->srcSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcSubresource); - wrapper->srcOffset = DecodeAllocator::Allocate(); - wrapper->srcOffset->decoded_value = &(value->srcOffset); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcOffset); - wrapper->dstSubresource = DecodeAllocator::Allocate(); - wrapper->dstSubresource->decoded_value = &(value->dstSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstSubresource); - wrapper->dstOffset = DecodeAllocator::Allocate(); - wrapper->dstOffset->decoded_value = &(value->dstOffset); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstOffset); - 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleOrderType)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->customSampleOrderCount)); + wrapper->pCustomSampleOrders = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pCustomSampleOrders->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCustomSampleOrders = wrapper->pCustomSampleOrders->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkResolveImageInfo2* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRayTracingShaderGroupCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkResolveImageInfo2* value = wrapper->decoded_value; + VkRayTracingShaderGroupCreateInfoNV* 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->srcImage)); - value->srcImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); - value->dstImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); - wrapper->pRegions = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRegions = wrapper->pRegions->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->generalShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->closestHitShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->anyHitShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->intersectionShader)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupSizeControlFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRayTracingPipelineCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSubgroupSizeControlFeatures* value = wrapper->decoded_value; + VkRayTracingPipelineCreateInfoNV* 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->subgroupSizeControl)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeFullSubgroups)); + 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->stageCount)); + wrapper->pStages = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStages->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStages = wrapper->pStages->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupCount)); + wrapper->pGroups = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pGroups->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pGroups = wrapper->pGroups->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRecursionDepth)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->basePipelineHandle)); + value->basePipelineHandle = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->basePipelineIndex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupSizeControlProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryTrianglesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSubgroupSizeControlProperties* value = wrapper->decoded_value; + VkGeometryTrianglesNV* 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->minSubgroupSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubgroupSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxComputeWorkgroupSubgroups)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->requiredSubgroupSizeStages)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->vertexData)); + value->vertexData = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexStride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexFormat)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indexData)); + value->indexData = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexCount)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->transformData)); + value->transformData = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryAABBNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* value = wrapper->decoded_value; + VkGeometryAABBNV* 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->requiredSubgroupSize)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->aabbData)); + value->aabbData = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numAABBs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInlineUniformBlockFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryDataNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceInlineUniformBlockFeatures* value = wrapper->decoded_value; + VkGeometryDataNV* 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->inlineUniformBlock)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingInlineUniformBlockUpdateAfterBind)); + wrapper->triangles = DecodeAllocator::Allocate(); + wrapper->triangles->decoded_value = &(value->triangles); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->triangles); + wrapper->aabbs = DecodeAllocator::Allocate(); + wrapper->aabbs->decoded_value = &(value->aabbs); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->aabbs); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInlineUniformBlockProperties* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceInlineUniformBlockProperties* value = wrapper->decoded_value; + VkGeometryNV* 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->maxInlineUniformBlockSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorInlineUniformBlocks)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetInlineUniformBlocks)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindInlineUniformBlocks)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryType)); + wrapper->geometry = DecodeAllocator::Allocate(); + wrapper->geometry->decoded_value = &(value->geometry); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->geometry); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetInlineUniformBlock* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkWriteDescriptorSetInlineUniformBlock* value = wrapper->decoded_value; + VkAccelerationStructureInfoNV* 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->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->type)); + 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->instanceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryCount)); + wrapper->pGeometries = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pGeometries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pGeometries = wrapper->pGeometries->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorPoolInlineUniformBlockCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDescriptorPoolInlineUniformBlockCreateInfo* value = wrapper->decoded_value; + VkAccelerationStructureCreateInfoNV* 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->maxInlineUniformBlockBindings)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->compactedSize)); + wrapper->info = DecodeAllocator::Allocate(); + wrapper->info->decoded_value = &(value->info); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->info); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTextureCompressionASTCHDRFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindAccelerationStructureMemoryInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTextureCompressionASTCHDRFeatures* value = wrapper->decoded_value; + VkBindAccelerationStructureMemoryInfoNV* 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->textureCompressionASTC_HDR)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->accelerationStructure)); + value->accelerationStructure = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceIndexCount)); + bytes_read += wrapper->pDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceIndices = wrapper->pDeviceIndices.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingAttachmentInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetAccelerationStructureNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingAttachmentInfo* value = wrapper->decoded_value; + VkWriteDescriptorSetAccelerationStructureNV* 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->resolveMode)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->resolveImageView)); - value->resolveImageView = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->resolveImageLayout)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->loadOp)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->storeOp)); - wrapper->clearValue = DecodeAllocator::Allocate(); - wrapper->clearValue->decoded_value = &(value->clearValue); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->clearValue); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureCount)); + bytes_read += wrapper->pAccelerationStructures.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAccelerationStructures = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureMemoryRequirementsInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingInfo* value = wrapper->decoded_value; + VkAccelerationStructureMemoryRequirementsInfoNV* 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)); - wrapper->renderArea = DecodeAllocator::Allocate(); - wrapper->renderArea->decoded_value = &(value->renderArea); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderArea); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layerCount)); - 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)); - wrapper->pColorAttachments = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pColorAttachments->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pColorAttachments = wrapper->pColorAttachments->GetPointer(); - wrapper->pDepthAttachment = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDepthAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDepthAttachment = wrapper->pDepthAttachment->GetPointer(); - wrapper->pStencilAttachment = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStencilAttachment->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStencilAttachment = wrapper->pStencilAttachment->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->accelerationStructure)); + value->accelerationStructure = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRenderingCreateInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRenderingCreateInfo* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingPropertiesNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderGroupHandleSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRecursionDepth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxShaderGroupStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderGroupBaseAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGeometryCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInstanceCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTriangleCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetAccelerationStructures)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTransformMatrixKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDynamicRenderingFeatures* value = wrapper->decoded_value; + VkTransformMatrixKHR* 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->dynamicRendering)); + wrapper->matrix.SetExternalMemory(value->matrix, 3, 4); + bytes_read += wrapper->matrix.DecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceRenderingInfo* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAabbPositionsKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCommandBufferInheritanceRenderingInfo* value = wrapper->decoded_value; + VkAabbPositionsKHR* 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->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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationSamples)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minX)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minY)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minZ)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxX)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxY)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxZ)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerDotProductFeatures* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureInstanceKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderIntegerDotProductFeatures* value = wrapper->decoded_value; + VkAccelerationStructureInstanceKHR* 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->shaderIntegerDotProduct)); + wrapper->transform = DecodeAllocator::Allocate(); + wrapper->transform->decoded_value = &(value->transform); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transform); + uint32_t temp_instanceCustomIndex; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceCustomIndex); + value->instanceCustomIndex = temp_instanceCustomIndex; + uint32_t temp_mask; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mask); + value->mask = temp_mask; + uint32_t temp_instanceShaderBindingTableRecordOffset; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceShaderBindingTableRecordOffset); + value->instanceShaderBindingTableRecordOffset = temp_instanceShaderBindingTableRecordOffset; + VkGeometryInstanceFlagsKHR temp_flags; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &temp_flags); + value->flags = temp_flags; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureReference)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerDotProductProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRayTracingShaderGroupCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderIntegerDotProductProperties* value = wrapper->decoded_value; + VkRayTracingShaderGroupCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->integerDotProduct8BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct8BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct4x8BitPackedMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct16BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct32BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProduct64BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitSignedAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->generalShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->closestHitShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->anyHitShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->intersectionShader)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTexelBufferAlignmentProperties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRayTracingPipelineCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTexelBufferAlignmentProperties* value = wrapper->decoded_value; + VkRayTracingPipelineCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->storageTexelBufferOffsetAlignmentBytes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->storageTexelBufferOffsetSingleTexelAlignment)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetAlignmentBytes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformTexelBufferOffsetSingleTexelAlignment)); + 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->stageCount)); + wrapper->pStages = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStages->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStages = wrapper->pStages->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupCount)); + wrapper->pGroups = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pGroups->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pGroups = wrapper->pGroups->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRecursionDepth)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->basePipelineHandle)); + value->basePipelineHandle = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->basePipelineIndex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFormatProperties3* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryTrianglesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFormatProperties3* value = wrapper->decoded_value; + VkGeometryTrianglesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->linearTilingFeatures)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimalTilingFeatures)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferFeatures)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->vertexData)); + value->vertexData = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexStride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexFormat)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indexData)); + value->indexData = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexCount)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->transformData)); + value->transformData = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance4Features* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryAABBNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance4Features* value = wrapper->decoded_value; + VkGeometryAABBNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->maintenance4)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->aabbData)); + value->aabbData = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numAABBs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance4Properties* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryDataNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance4Properties* value = wrapper->decoded_value; + VkGeometryDataNV* 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->maxBufferSize)); + wrapper->triangles = PreloadDecodeAllocator::Allocate(); + wrapper->triangles->decoded_value = &(value->triangles); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->triangles); + wrapper->aabbs = PreloadDecodeAllocator::Allocate(); + wrapper->aabbs->decoded_value = &(value->aabbs); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->aabbs); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceBufferMemoryRequirements* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceBufferMemoryRequirements* value = wrapper->decoded_value; + VkGeometryNV* 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)); + bytes_read += PreloadDecodePNextStruct((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(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryType)); + wrapper->geometry = PreloadDecodeAllocator::Allocate(); + wrapper->geometry->decoded_value = &(value->geometry); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->geometry); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceImageMemoryRequirements* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceImageMemoryRequirements* value = wrapper->decoded_value; + VkAccelerationStructureInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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(); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->planeAspect)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + 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->instanceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryCount)); + wrapper->pGeometries = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pGeometries->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pGeometries = wrapper->pGeometries->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceCapabilitiesKHR* value = wrapper->decoded_value; + VkAccelerationStructureCreateInfoNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImageCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageCount)); - wrapper->currentExtent = DecodeAllocator::Allocate(); - wrapper->currentExtent->decoded_value = &(value->currentExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->currentExtent); - wrapper->minImageExtent = DecodeAllocator::Allocate(); - wrapper->minImageExtent->decoded_value = &(value->minImageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minImageExtent); - wrapper->maxImageExtent = DecodeAllocator::Allocate(); - wrapper->maxImageExtent->decoded_value = &(value->maxImageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxImageExtent); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageArrayLayers)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedTransforms)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->currentTransform)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedCompositeAlpha)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedUsageFlags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->compactedSize)); + wrapper->info = PreloadDecodeAllocator::Allocate(); + wrapper->info->decoded_value = &(value->info); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->info); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFormatKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindAccelerationStructureMemoryInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceFormatKHR* value = wrapper->decoded_value; + VkBindAccelerationStructureMemoryInfoNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorSpace)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->accelerationStructure)); + value->accelerationStructure = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); + value->memory = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceIndexCount)); + bytes_read += wrapper->pDeviceIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDeviceIndices = wrapper->pDeviceIndices.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetAccelerationStructureNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSwapchainCreateInfoKHR* value = wrapper->decoded_value; + VkWriteDescriptorSetAccelerationStructureNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->surface)); - value->surface = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImageCount)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageFormat)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageColorSpace)); - wrapper->imageExtent = DecodeAllocator::Allocate(); - wrapper->imageExtent->decoded_value = &(value->imageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageArrayLayers)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageUsage)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageSharingMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndexCount)); - bytes_read += wrapper->pQueueFamilyIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pQueueFamilyIndices = wrapper->pQueueFamilyIndices.GetPointer(); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->preTransform)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compositeAlpha)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clipped)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->oldSwapchain)); - value->oldSwapchain = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureCount)); + bytes_read += wrapper->pAccelerationStructures.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAccelerationStructures = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureMemoryRequirementsInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentInfoKHR* value = wrapper->decoded_value; + VkAccelerationStructureMemoryRequirementsInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->waitSemaphoreCount)); - bytes_read += wrapper->pWaitSemaphores.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pWaitSemaphores = nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); - bytes_read += wrapper->pSwapchains.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSwapchains = nullptr; - bytes_read += wrapper->pImageIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pImageIndices = wrapper->pImageIndices.GetPointer(); - bytes_read += wrapper->pResults.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pResults = wrapper->pResults.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->accelerationStructure)); + value->accelerationStructure = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageSwapchainCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageSwapchainCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->swapchain)); - value->swapchain = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderGroupHandleSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRecursionDepth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxShaderGroupStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderGroupBaseAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGeometryCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInstanceCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTriangleCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetAccelerationStructures)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindImageMemorySwapchainInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTransformMatrixKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindImageMemorySwapchainInfoKHR* value = wrapper->decoded_value; + VkTransformMatrixKHR* 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->swapchain)); - value->swapchain = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageIndex)); + wrapper->matrix.SetExternalMemory(value->matrix, 3, 4); + bytes_read += wrapper->matrix.PreloadDecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcquireNextImageInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAabbPositionsKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAcquireNextImageInfoKHR* value = wrapper->decoded_value; + VkAabbPositionsKHR* 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->swapchain)); - value->swapchain = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeout)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->semaphore)); - value->semaphore = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->fence)); - value->fence = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceMask)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minX)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minY)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minZ)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxX)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxY)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxZ)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupPresentCapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureInstanceKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceGroupPresentCapabilitiesKHR* value = wrapper->decoded_value; + VkAccelerationStructureInstanceKHR* 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->presentMask.SetExternalMemory(value->presentMask, VK_MAX_DEVICE_GROUP_SIZE); - bytes_read += wrapper->presentMask.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->modes)); + wrapper->transform = PreloadDecodeAllocator::Allocate(); + wrapper->transform->decoded_value = &(value->transform); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transform); + uint32_t temp_instanceCustomIndex; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceCustomIndex); + value->instanceCustomIndex = temp_instanceCustomIndex; + uint32_t temp_mask; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mask); + value->mask = temp_mask; + uint32_t temp_instanceShaderBindingTableRecordOffset; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceShaderBindingTableRecordOffset); + value->instanceShaderBindingTableRecordOffset = temp_instanceShaderBindingTableRecordOffset; + VkGeometryInstanceFlagsKHR temp_flags; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &temp_flags); + value->flags = temp_flags; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureReference)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupPresentInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceGroupPresentInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* 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->pDeviceMasks.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDeviceMasks = wrapper->pDeviceMasks.GetPointer(); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->representativeFragmentTest)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceGroupSwapchainCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceGroupSwapchainCreateInfoKHR* value = wrapper->decoded_value; + VkPipelineRepresentativeFragmentTestStateCreateInfoNV* 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->modes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->representativeFragmentTestEnable)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModeParametersKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayModeParametersKHR* value = wrapper->decoded_value; + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* value = wrapper->decoded_value; - wrapper->visibleRegion = DecodeAllocator::Allocate(); - wrapper->visibleRegion->decoded_value = &(value->visibleRegion); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->visibleRegion); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refreshRate)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->representativeFragmentTest)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModeCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayModeCreateInfoKHR* value = wrapper->decoded_value; + VkPipelineRepresentativeFragmentTestStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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)); - wrapper->parameters = DecodeAllocator::Allocate(); - wrapper->parameters->decoded_value = &(value->parameters); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->parameters); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->representativeFragmentTestEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayModePropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewImageFormatInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayModePropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceImageViewImageFormatInfoEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->displayMode)); - value->displayMode = VK_NULL_HANDLE; - wrapper->parameters = DecodeAllocator::Allocate(); - wrapper->parameters->decoded_value = &(value->parameters); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->parameters); + 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->imageViewType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneCapabilitiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFilterCubicImageViewImageFormatPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPlaneCapabilitiesKHR* value = wrapper->decoded_value; + VkFilterCubicImageViewImageFormatPropertiesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedAlpha)); - wrapper->minSrcPosition = DecodeAllocator::Allocate(); - wrapper->minSrcPosition->decoded_value = &(value->minSrcPosition); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minSrcPosition); - wrapper->maxSrcPosition = DecodeAllocator::Allocate(); - wrapper->maxSrcPosition->decoded_value = &(value->maxSrcPosition); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSrcPosition); - wrapper->minSrcExtent = DecodeAllocator::Allocate(); - wrapper->minSrcExtent->decoded_value = &(value->minSrcExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minSrcExtent); - wrapper->maxSrcExtent = DecodeAllocator::Allocate(); - wrapper->maxSrcExtent->decoded_value = &(value->maxSrcExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSrcExtent); - wrapper->minDstPosition = DecodeAllocator::Allocate(); - wrapper->minDstPosition->decoded_value = &(value->minDstPosition); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minDstPosition); - wrapper->maxDstPosition = DecodeAllocator::Allocate(); - wrapper->maxDstPosition->decoded_value = &(value->maxDstPosition); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxDstPosition); - wrapper->minDstExtent = DecodeAllocator::Allocate(); - wrapper->minDstExtent->decoded_value = &(value->minDstExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minDstExtent); - wrapper->maxDstExtent = DecodeAllocator::Allocate(); - wrapper->maxDstExtent->decoded_value = &(value->maxDstExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxDstExtent); + 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->filterCubic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterCubicMinmax)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlanePropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewImageFormatInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPlanePropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceImageViewImageFormatInfoEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->currentDisplay)); - value->currentDisplay = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->currentStackIndex)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->imageViewType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFilterCubicImageViewImageFormatPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPropertiesKHR* value = wrapper->decoded_value; + VkFilterCubicImageViewImageFormatPropertiesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->display)); - value->display = VK_NULL_HANDLE; - bytes_read += wrapper->displayName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->displayName = wrapper->displayName.GetPointer(); - wrapper->physicalDimensions = DecodeAllocator::Allocate(); - wrapper->physicalDimensions->decoded_value = &(value->physicalDimensions); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->physicalDimensions); - wrapper->physicalResolution = DecodeAllocator::Allocate(); - wrapper->physicalResolution->decoded_value = &(value->physicalResolution); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->physicalResolution); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedTransforms)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->planeReorderPossible)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->persistentContent)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->filterCubic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterCubicMinmax)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplaySurfaceCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryHostPointerInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplaySurfaceCreateInfoKHR* value = wrapper->decoded_value; + VkImportMemoryHostPointerInfoEXT* 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->displayMode)); - value->displayMode = 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->planeStackIndex)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transform)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalAlpha)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaMode)); - wrapper->imageExtent = DecodeAllocator::Allocate(); - wrapper->imageExtent->decoded_value = &(value->imageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + 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->pHostPointer)); + value->pHostPointer = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPresentInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryHostPointerPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPresentInfoKHR* value = wrapper->decoded_value; + VkMemoryHostPointerPropertiesEXT* 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->srcRect = DecodeAllocator::Allocate(); - wrapper->srcRect->decoded_value = &(value->srcRect); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->srcRect); - wrapper->dstRect = DecodeAllocator::Allocate(); - wrapper->dstRect->decoded_value = &(value->dstRect); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstRect); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->persistent)); + 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_VkXlibSurfaceCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkXlibSurfaceCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceExternalMemoryHostPropertiesEXT* 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->dpy)); - value->dpy = nullptr; - bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->window)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImportedHostPointerAlignment)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkXcbSurfaceCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryHostPointerInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkXcbSurfaceCreateInfoKHR* value = wrapper->decoded_value; + VkImportMemoryHostPointerInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->connection)); - value->connection = nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->window)); + 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->pHostPointer)); + value->pHostPointer = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWaylandSurfaceCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryHostPointerPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkWaylandSurfaceCreateInfoKHR* value = wrapper->decoded_value; + VkMemoryHostPointerPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->display)); - value->display = nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->surface)); - value->surface = nullptr; + 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_VkAndroidSurfaceCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAndroidSurfaceCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceExternalMemoryHostPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->window)); - value->window = nullptr; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minImportedHostPointerAlignment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32SurfaceCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCompilerControlCreateInfoAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkWin32SurfaceCreateInfoKHR* value = wrapper->decoded_value; + VkPipelineCompilerControlCreateInfoAMD* 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->hinstance)); - value->hinstance = nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->hwnd)); - value->hwnd = nullptr; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compilerControlFlags)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyQueryResultStatusPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCompilerControlCreateInfoAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueueFamilyQueryResultStatusPropertiesKHR* value = wrapper->decoded_value; + VkPipelineCompilerControlCreateInfoAMD* 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)); + bytes_read += PreloadDecodePNextStruct((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->queryResultStatusSupport)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compilerControlFlags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyVideoPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueueFamilyVideoPropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCorePropertiesAMD* 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->videoCodecOperations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderEngineCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderArraysPerEngineCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeUnitsPerShaderArray)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->simdPerComputeUnit)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->wavefrontsPerSimd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->wavefrontSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sgprsPerSimd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSgprAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSgprAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sgprAllocationGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vgprsPerSimd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minVgprAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVgprAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vgprAllocationGranularity)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoProfileInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoProfileInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCorePropertiesAMD* 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)); + bytes_read += PreloadDecodePNextStruct((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->videoCodecOperation)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chromaSubsampling)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->lumaBitDepth)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->chromaBitDepth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderEngineCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderArraysPerEngineCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeUnitsPerShaderArray)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->simdPerComputeUnit)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->wavefrontsPerSimd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->wavefrontSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sgprsPerSimd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSgprAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSgprAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sgprAllocationGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vgprsPerSimd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minVgprAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVgprAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vgprAllocationGranularity)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoProfileListInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceMemoryOverallocationCreateInfoAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoProfileListInfoKHR* value = wrapper->decoded_value; + VkDeviceMemoryOverallocationCreateInfoAMD* 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->profileCount)); - wrapper->pProfiles = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pProfiles->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pProfiles = wrapper->pProfiles->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->overallocationBehavior)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoCapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceMemoryOverallocationCreateInfoAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoCapabilitiesKHR* value = wrapper->decoded_value; + VkDeviceMemoryOverallocationCreateInfoAMD* 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)); + bytes_read += PreloadDecodePNextStruct((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->minBitstreamBufferOffsetAlignment)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minBitstreamBufferSizeAlignment)); - wrapper->pictureAccessGranularity = DecodeAllocator::Allocate(); - wrapper->pictureAccessGranularity->decoded_value = &(value->pictureAccessGranularity); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->pictureAccessGranularity); - wrapper->minCodedExtent = DecodeAllocator::Allocate(); - wrapper->minCodedExtent->decoded_value = &(value->minCodedExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minCodedExtent); - wrapper->maxCodedExtent = DecodeAllocator::Allocate(); - wrapper->maxCodedExtent->decoded_value = &(value->maxCodedExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxCodedExtent); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDpbSlots)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxActiveReferencePictures)); - wrapper->stdHeaderVersion = DecodeAllocator::Allocate(); - wrapper->stdHeaderVersion->decoded_value = &(value->stdHeaderVersion); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->stdHeaderVersion); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->overallocationBehavior)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoFormatInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVideoFormatInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* 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->imageUsage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexAttribDivisor)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoFormatPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoFormatPropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->format)); - wrapper->componentMapping = DecodeAllocator::Allocate(); - wrapper->componentMapping->decoded_value = &(value->componentMapping); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->componentMapping); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCreateFlags)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageType)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageTiling)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageUsageFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexAttribDivisor)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoPictureResourceInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentFrameTokenGGP* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoPictureResourceInfoKHR* value = wrapper->decoded_value; + VkPresentFrameTokenGGP* 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->codedOffset = DecodeAllocator::Allocate(); - wrapper->codedOffset->decoded_value = &(value->codedOffset); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->codedOffset); - wrapper->codedExtent = DecodeAllocator::Allocate(); - wrapper->codedExtent->decoded_value = &(value->codedExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->codedExtent); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseArrayLayer)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->imageViewBinding)); - value->imageViewBinding = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameToken)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoReferenceSlotInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentFrameTokenGGP* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoReferenceSlotInfoKHR* value = wrapper->decoded_value; + VkPresentFrameTokenGGP* 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)); + bytes_read += PreloadDecodePNextStruct((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->slotIndex)); - wrapper->pPictureResource = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pPictureResource->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPictureResource = wrapper->pPictureResource->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameToken)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionMemoryRequirementsKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoSessionMemoryRequirementsKHR* value = wrapper->decoded_value; + VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* 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->memoryBindIndex)); - wrapper->memoryRequirements = DecodeAllocator::Allocate(); - wrapper->memoryRequirements->decoded_value = &(value->memoryRequirements); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->memoryRequirements); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeDerivativeGroupQuads)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeDerivativeGroupLinear)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindVideoSessionMemoryInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindVideoSessionMemoryInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->memoryBindIndex)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); - value->memory = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeDerivativeGroupQuads)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeDerivativeGroupLinear)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoSessionCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMeshShaderFeaturesNV* 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); - wrapper->pVideoProfile = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pVideoProfile->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pVideoProfile = wrapper->pVideoProfile->GetPointer(); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pictureFormat)); - wrapper->maxCodedExtent = DecodeAllocator::Allocate(); - wrapper->maxCodedExtent->decoded_value = &(value->maxCodedExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxCodedExtent); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->referencePictureFormat)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDpbSlots)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxActiveReferencePictures)); - wrapper->pStdHeaderVersion = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdHeaderVersion->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdHeaderVersion = wrapper->pStdHeaderVersion->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->taskShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshShader)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionParametersCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoSessionParametersCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMeshShaderPropertiesNV* 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->videoSessionParametersTemplate)); - value->videoSessionParametersTemplate = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->videoSession)); - value->videoSession = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDrawMeshTasksCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskWorkGroupInvocations)); + wrapper->maxTaskWorkGroupSize.SetExternalMemory(value->maxTaskWorkGroupSize, 3); + bytes_read += wrapper->maxTaskWorkGroupSize.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskTotalMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskOutputCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshWorkGroupInvocations)); + wrapper->maxMeshWorkGroupSize.SetExternalMemory(value->maxMeshWorkGroupSize, 3); + bytes_read += wrapper->maxMeshWorkGroupSize.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshTotalMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputVertices)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputPrimitives)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshMultiviewViewCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshOutputPerVertexGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshOutputPerPrimitiveGranularity)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoSessionParametersUpdateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrawMeshTasksIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoSessionParametersUpdateInfoKHR* value = wrapper->decoded_value; + VkDrawMeshTasksIndirectCommandNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->taskCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstTask)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderFeaturesNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMeshShaderFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->updateSequenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->taskShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshShader)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoBeginCodingInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoBeginCodingInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMeshShaderPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->videoSession)); - value->videoSession = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->videoSessionParameters)); - value->videoSessionParameters = VK_NULL_HANDLE; - 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->maxDrawMeshTasksCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskWorkGroupInvocations)); + wrapper->maxTaskWorkGroupSize.SetExternalMemory(value->maxTaskWorkGroupSize, 3); + bytes_read += wrapper->maxTaskWorkGroupSize.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskTotalMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskOutputCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshWorkGroupInvocations)); + wrapper->maxMeshWorkGroupSize.SetExternalMemory(value->maxMeshWorkGroupSize, 3); + bytes_read += wrapper->maxMeshWorkGroupSize.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshTotalMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputVertices)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputPrimitives)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshMultiviewViewCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshOutputPerVertexGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshOutputPerPrimitiveGranularity)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEndCodingInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrawMeshTasksIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEndCodingInfoKHR* value = wrapper->decoded_value; + VkDrawMeshTasksIndirectCommandNV* 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->taskCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstTask)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoCodingControlInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderImageFootprintFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoCodingControlInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderImageFootprintFeaturesNV* 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->imageFootprint)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeCapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderImageFootprintFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeCapabilitiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderImageFootprintFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->imageFootprint)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeUsageInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportExclusiveScissorStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeUsageInfoKHR* value = wrapper->decoded_value; + VkPipelineViewportExclusiveScissorStateCreateInfoNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->exclusiveScissorCount)); + wrapper->pExclusiveScissors = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pExclusiveScissors->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pExclusiveScissors = wrapper->pExclusiveScissors->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExclusiveScissorFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceExclusiveScissorFeaturesNV* 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->srcBuffer)); - value->srcBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcBufferOffset)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcBufferRange)); - wrapper->dstPictureResource = DecodeAllocator::Allocate(); - wrapper->dstPictureResource->decoded_value = &(value->dstPictureResource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dstPictureResource); - 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->exclusiveScissor)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264CapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportExclusiveScissorStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264CapabilitiesKHR* value = wrapper->decoded_value; + VkPipelineViewportExclusiveScissorStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); - bytes_read += ValueDecoder::DecodeUInt32Value((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->exclusiveScissorCount)); + wrapper->pExclusiveScissors = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pExclusiveScissors->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pExclusiveScissors = wrapper->pExclusiveScissors->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QpKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExclusiveScissorFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264QpKHR* value = wrapper->decoded_value; + VkPhysicalDeviceExclusiveScissorFeaturesNV* 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 += PreloadDecodePNextStruct((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->exclusiveScissor)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QualityLevelPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264QualityLevelPropertiesKHR* value = wrapper->decoded_value; + VkQueueFamilyCheckpointPropertiesNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preferredStdEntropyCodingModeFlag)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->checkpointExecutionStageMask)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCheckpointDataNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionCreateInfoKHR* value = wrapper->decoded_value; + VkCheckpointDataNV* 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->useMaxLevelIdc)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLevelIdc)); + bytes_read += ValueDecoder::DecodeEnumValue((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_VkVideoEncodeH264SessionParametersAddInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionParametersAddInfoKHR* value = wrapper->decoded_value; + VkQueueFamilyCheckpointPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->checkpointExecutionStageMask)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCheckpointDataNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + VkCheckpointDataNV* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeEnumValue((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_VkVideoEncodeH264SessionParametersGetInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionParametersGetInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* 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->writeStdSPS)); - bytes_read += ValueDecoder::DecodeUInt32Value((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->shaderIntegerFunctions2)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264SessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* 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)); + bytes_read += PreloadDecodePNextStruct((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->hasStdSPSOverrides)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderIntegerFunctions2)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264NaluSliceInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkInitializePerformanceApiInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264NaluSliceInfoKHR* value = wrapper->decoded_value; + VkInitializePerformanceApiInfoINTEL* 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::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_VkVideoEncodeH264PictureInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolPerformanceQueryCreateInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264PictureInfoKHR* value = wrapper->decoded_value; + VkQueryPoolPerformanceQueryCreateInfoINTEL* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->generatePrefixNalu)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceCountersSampling)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264DpbSlotInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceMarkerInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264DpbSlotInfoKHR* value = wrapper->decoded_value; + VkPerformanceMarkerInfoINTEL* 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->marker)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264ProfileInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceStreamMarkerInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264ProfileInfoKHR* value = wrapper->decoded_value; + VkPerformanceStreamMarkerInfoINTEL* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->marker)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceOverrideInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264RateControlInfoKHR* value = wrapper->decoded_value; + VkPerformanceOverrideInfoINTEL* 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 += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enable)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->parameter)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264FrameSizeKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceConfigurationAcquireInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264FrameSizeKHR* value = wrapper->decoded_value; + VkPerformanceConfigurationAcquireInfoINTEL* 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlLayerInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkInitializePerformanceApiInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264RateControlLayerInfoKHR* value = wrapper->decoded_value; + VkInitializePerformanceApiInfoINTEL* 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)); + bytes_read += PreloadDecodePNextStruct((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->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::DecodeUInt32Value((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::DecodeUInt32Value((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::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_VkVideoEncodeH264GopRemainingFrameInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolPerformanceQueryCreateInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH264GopRemainingFrameInfoKHR* value = wrapper->decoded_value; + VkQueryPoolPerformanceQueryCreateInfoINTEL* 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)); + bytes_read += PreloadDecodePNextStruct((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->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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceCountersSampling)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265CapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceMarkerInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265CapabilitiesKHR* value = wrapper->decoded_value; + VkPerformanceMarkerInfoINTEL* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersGopRemainingFrames)); - bytes_read += ValueDecoder::DecodeUInt32Value((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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->marker)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceStreamMarkerInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionCreateInfoKHR* value = wrapper->decoded_value; + VkPerformanceStreamMarkerInfoINTEL* 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)); + bytes_read += PreloadDecodePNextStruct((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->useMaxLevelIdc)); - 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->marker)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QpKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceOverrideInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265QpKHR* value = wrapper->decoded_value; + VkPerformanceOverrideInfoINTEL* 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 += PreloadDecodePNextStruct((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->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enable)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->parameter)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceConfigurationAcquireInfoINTEL* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265QualityLevelPropertiesKHR* value = wrapper->decoded_value; + VkPerformanceConfigurationAcquireInfoINTEL* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePCIBusInfoPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionParametersAddInfoKHR* value = wrapper->decoded_value; + VkPhysicalDevicePCIBusInfoPropertiesEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciDomain)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciBus)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciDevice)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciFunction)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePCIBusInfoPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDevicePCIBusInfoPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciDomain)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciBus)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciDevice)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciFunction)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayNativeHdrSurfaceCapabilitiesAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionParametersGetInfoKHR* value = wrapper->decoded_value; + VkDisplayNativeHdrSurfaceCapabilitiesAMD* 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->writeStdVPS)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->writeStdSPS)); - bytes_read += ValueDecoder::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->localDimmingSupport)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainDisplayNativeHdrCreateInfoAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265SessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; + VkSwapchainDisplayNativeHdrCreateInfoAMD* 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->hasStdVPSOverrides)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdSPSOverrides)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasStdPPSOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->localDimmingEnable)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayNativeHdrSurfaceCapabilitiesAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265NaluSliceSegmentInfoKHR* value = wrapper->decoded_value; + VkDisplayNativeHdrSurfaceCapabilitiesAMD* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->localDimmingSupport)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265PictureInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainDisplayNativeHdrCreateInfoAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265PictureInfoKHR* value = wrapper->decoded_value; + VkSwapchainDisplayNativeHdrCreateInfoAMD* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->localDimmingEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265DpbSlotInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImagePipeSurfaceCreateInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265DpbSlotInfoKHR* value = wrapper->decoded_value; + VkImagePipeSurfaceCreateInfoFUCHSIA* 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 += 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->imagePipeHandle)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265ProfileInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImagePipeSurfaceCreateInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265ProfileInfoKHR* value = wrapper->decoded_value; + VkImagePipeSurfaceCreateInfoFUCHSIA* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imagePipeHandle)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMetalSurfaceCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265RateControlInfoKHR* value = wrapper->decoded_value; + VkMetalSurfaceCreateInfoEXT* 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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pLayer)); + value->pLayer = nullptr; return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265FrameSizeKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMetalSurfaceCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265FrameSizeKHR* value = wrapper->decoded_value; + VkMetalSurfaceCreateInfoEXT* 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 += PreloadDecodePNextStruct((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->pLayer)); + value->pLayer = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlLayerInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265RateControlLayerInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMapFeaturesEXT* 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->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::DecodeUInt32Value((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::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMap)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapNonSubsampledImages)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeH265GopRemainingFrameInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMapPropertiesEXT* 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->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)); + wrapper->minFragmentDensityTexelSize = DecodeAllocator::Allocate(); + wrapper->minFragmentDensityTexelSize->decoded_value = &(value->minFragmentDensityTexelSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minFragmentDensityTexelSize); + wrapper->maxFragmentDensityTexelSize = DecodeAllocator::Allocate(); + wrapper->maxFragmentDensityTexelSize->decoded_value = &(value->maxFragmentDensityTexelSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFragmentDensityTexelSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityInvocations)); 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_VkRenderPassFragmentDensityMapCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264ProfileInfoKHR* value = wrapper->decoded_value; + VkRenderPassFragmentDensityMapCreateInfoEXT* 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)); + wrapper->fragmentDensityMapAttachment = DecodeAllocator::Allocate(); + wrapper->fragmentDensityMapAttachment->decoded_value = &(value->fragmentDensityMapAttachment); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentDensityMapAttachment); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264CapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264CapabilitiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMapFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMap)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapDynamic)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapNonSubsampledImages)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264SessionParametersAddInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMapPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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(); + wrapper->minFragmentDensityTexelSize = PreloadDecodeAllocator::Allocate(); + wrapper->minFragmentDensityTexelSize->decoded_value = &(value->minFragmentDensityTexelSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minFragmentDensityTexelSize); + wrapper->maxFragmentDensityTexelSize = PreloadDecodeAllocator::Allocate(); + wrapper->maxFragmentDensityTexelSize->decoded_value = &(value->maxFragmentDensityTexelSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFragmentDensityTexelSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityInvocations)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264SessionParametersCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassFragmentDensityMapCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + VkRenderPassFragmentDensityMapCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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(); + wrapper->fragmentDensityMapAttachment = PreloadDecodeAllocator::Allocate(); + wrapper->fragmentDensityMapAttachment->decoded_value = &(value->fragmentDensityMapAttachment); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentDensityMapAttachment); 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_VkPhysicalDeviceShaderCoreProperties2AMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264PictureInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCoreProperties2AMD* 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreFeatures)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->activeComputeUnitCount)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH264DpbSlotInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreProperties2AMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH264DpbSlotInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCoreProperties2AMD* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreFeatures)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->activeComputeUnitCount)); 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_VkPhysicalDeviceCoherentMemoryFeaturesAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingFragmentShadingRateAttachmentInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceCoherentMemoryFeaturesAMD* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceCoherentMemory)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingFragmentDensityMapAttachmentInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCoherentMemoryFeaturesAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingFragmentDensityMapAttachmentInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceCoherentMemoryFeaturesAMD* 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)); + bytes_read += PreloadDecodePNextStruct((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->deviceCoherentMemory)); 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_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAttachmentSampleCountInfoAMD* value = wrapper->decoded_value; + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* 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)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageInt64Atomics)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiviewPerViewAttributesInfoNVX* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMultiviewPerViewAttributesInfoNVX* value = wrapper->decoded_value; + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->perViewAttributes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewAttributesPositionXOnly)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageInt64Atomics)); 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_VkPhysicalDeviceMemoryBudgetPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportMemoryWin32HandleInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMemoryBudgetPropertiesEXT* 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(); + wrapper->heapBudget.SetExternalMemory(value->heapBudget, VK_MAX_MEMORY_HEAPS); + bytes_read += wrapper->heapBudget.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->heapUsage.SetExternalMemory(value->heapUsage, VK_MAX_MEMORY_HEAPS); + bytes_read += wrapper->heapUsage.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryBudgetPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportMemoryWin32HandleInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMemoryBudgetPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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(); + wrapper->heapBudget.SetExternalMemory(value->heapBudget, VK_MAX_MEMORY_HEAPS); + bytes_read += wrapper->heapBudget.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->heapUsage.SetExternalMemory(value->heapUsage, VK_MAX_MEMORY_HEAPS); + bytes_read += wrapper->heapUsage.PreloadDecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); 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_VkPhysicalDeviceMemoryPriorityFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryWin32HandlePropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMemoryPriorityFeaturesEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryPriority)); 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_VkMemoryPriorityAllocateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryGetWin32HandleInfoKHR* value = wrapper->decoded_value; + VkMemoryPriorityAllocateInfoEXT* 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::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->priority)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryFdInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryPriorityFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportMemoryFdInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMemoryPriorityFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryPriority)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryFdPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryPriorityAllocateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryFdPropertiesKHR* value = wrapper->decoded_value; + VkMemoryPriorityAllocateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->priority)); 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_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryGetFdInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dedicatedAllocationImageAliasing)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - 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::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(); + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->dedicatedAllocationImageAliasing)); 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_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportSemaphoreWin32HandleInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* 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->bufferDeviceAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressMultiDevice)); 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_VkBufferDeviceAddressCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportSemaphoreWin32HandleInfoKHR* value = wrapper->decoded_value; + VkBufferDeviceAddressCreateInfoEXT* 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkD3D12FenceSubmitInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkD3D12FenceSubmitInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressMultiDevice)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetWin32HandleInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferDeviceAddressCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSemaphoreGetWin32HandleInfoKHR* value = wrapper->decoded_value; + VkBufferDeviceAddressCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); 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_VkValidationFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportSemaphoreFdInfoKHR* value = wrapper->decoded_value; + VkValidationFeaturesEXT* 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->enabledValidationFeatureCount)); + bytes_read += wrapper->pEnabledValidationFeatures.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pEnabledValidationFeatures = wrapper->pEnabledValidationFeatures.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->disabledValidationFeatureCount)); + bytes_read += wrapper->pDisabledValidationFeatures.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDisabledValidationFeatures = wrapper->pDisabledValidationFeatures.GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetFdInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkValidationFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSemaphoreGetFdInfoKHR* value = wrapper->decoded_value; + VkValidationFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enabledValidationFeatureCount)); + bytes_read += wrapper->pEnabledValidationFeatures.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pEnabledValidationFeatures = wrapper->pEnabledValidationFeatures.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->disabledValidationFeatureCount)); + bytes_read += wrapper->pDisabledValidationFeatures.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDisabledValidationFeatures = wrapper->pDisabledValidationFeatures.GetPointer(); 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_VkCooperativeMatrixPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePushDescriptorPropertiesKHR* value = wrapper->decoded_value; + VkCooperativeMatrixPropertiesNV* 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::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->DType)); + 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_VkRectLayerKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRectLayerKHR* value = wrapper->decoded_value; + VkPhysicalDeviceCooperativeMatrixFeaturesNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrix)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixRobustBufferAccess)); 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_VkPhysicalDeviceCooperativeMatrixPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentRegionKHR* value = wrapper->decoded_value; + VkPhysicalDeviceCooperativeMatrixPropertiesNV* 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::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_VkPresentRegionsKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCooperativeMatrixPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentRegionsKHR* value = wrapper->decoded_value; + VkCooperativeMatrixPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->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->DType)); + 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_VkSharedPresentSurfaceCapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSharedPresentSurfaceCapabilitiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceCooperativeMatrixFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrix)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixRobustBufferAccess)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportFenceWin32HandleInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportFenceWin32HandleInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceCooperativeMatrixPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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; - 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->cooperativeMatrixSupportedStages)); 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_VkPhysicalDeviceCoverageReductionModeFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportFenceWin32HandleInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceCoverageReductionModeFeaturesNV* 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->coverageReductionMode)); 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_VkPipelineCoverageReductionStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFenceGetWin32HandleInfoKHR* value = wrapper->decoded_value; + VkPipelineCoverageReductionStateCreateInfoNV* 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageReductionMode)); 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_VkFramebufferMixedSamplesCombinationNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportFenceFdInfoKHR* value = wrapper->decoded_value; + VkFramebufferMixedSamplesCombinationNV* 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::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fd)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageReductionMode)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationSamples)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilSamples)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorSamples)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFenceGetFdInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCoverageReductionModeFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFenceGetFdInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceCoverageReductionModeFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->coverageReductionMode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCoverageReductionStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePerformanceQueryFeaturesKHR* value = wrapper->decoded_value; + VkPipelineCoverageReductionStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->performanceCounterQueryPools)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceCounterMultipleQueryPools)); + 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->coverageReductionMode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFramebufferMixedSamplesCombinationNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePerformanceQueryPropertiesKHR* value = wrapper->decoded_value; + VkFramebufferMixedSamplesCombinationNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->allowCommandBufferQueryCopies)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageReductionMode)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationSamples)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilSamples)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorSamples)); 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_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceCounterKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* 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->fragmentShaderSampleInterlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderPixelInterlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderShadingRateInterlock)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceCounterDescriptionKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceCounterDescriptionKHR* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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)); - 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)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderSampleInterlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderPixelInterlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderShadingRateInterlock)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolPerformanceCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueryPoolPerformanceCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* 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(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrImageArrays)); return bytes_read; -} - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcquireProfilingLockInfoKHR* wrapper) +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAcquireProfilingLockInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrImageArrays)); 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_VkPhysicalDeviceProvokingVertexFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceQuerySubmitInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceProvokingVertexFeaturesEXT* 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)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->provokingVertexLast)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackPreservesProvokingVertex)); 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_VkPhysicalDeviceProvokingVertexPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSurfaceInfo2KHR* value = wrapper->decoded_value; + VkPhysicalDeviceProvokingVertexPropertiesEXT* 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->provokingVertexModePerPipeline)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackPreservesTriangleFanProvokingVertex)); 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_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceCapabilities2KHR* value = wrapper->decoded_value; + VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->provokingVertexMode)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFormat2KHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProvokingVertexFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceFormat2KHR* value = wrapper->decoded_value; + VkPhysicalDeviceProvokingVertexFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->provokingVertexLast)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackPreservesProvokingVertex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayProperties2KHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProvokingVertexPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayProperties2KHR* value = wrapper->decoded_value; + VkPhysicalDeviceProvokingVertexPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->provokingVertexModePerPipeline)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackPreservesTriangleFanProvokingVertex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPlaneProperties2KHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPlaneProperties2KHR* value = wrapper->decoded_value; + VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->provokingVertexMode)); 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_VkSurfaceFullScreenExclusiveInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayModeProperties2KHR* value = wrapper->decoded_value; + VkSurfaceFullScreenExclusiveInfoEXT* 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); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->fullScreenExclusive)); 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_VkSurfaceCapabilitiesFullScreenExclusiveEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPlaneInfo2KHR* value = wrapper->decoded_value; + VkSurfaceCapabilitiesFullScreenExclusiveEXT* 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->fullScreenExclusiveSupported)); 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_VkSurfaceFullScreenExclusiveWin32InfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPlaneCapabilities2KHR* value = wrapper->decoded_value; + VkSurfaceFullScreenExclusiveWin32InfoEXT* 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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->hmonitor)); + value->hmonitor = nullptr; return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFullScreenExclusiveInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePortabilitySubsetFeaturesKHR* value = wrapper->decoded_value; + VkSurfaceFullScreenExclusiveInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->constantAlphaColorBlendFactors)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->events)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatReinterpretation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageViewFormatSwizzle)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageView2DOn3DImage)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multisampleArrayImage)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mutableComparisonSamplers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pointPolygons)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->samplerMipLodBias)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateStencilMaskRef)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSampleRateInterpolationFunctions)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationIsolines)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tessellationPointMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triangleFans)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeAccessBeyondStride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->fullScreenExclusive)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesFullScreenExclusiveEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePortabilitySubsetPropertiesKHR* value = wrapper->decoded_value; + VkSurfaceCapabilitiesFullScreenExclusiveEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fullScreenExclusiveSupported)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderClockFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFullScreenExclusiveWin32InfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderClockFeaturesKHR* value = wrapper->decoded_value; + VkSurfaceFullScreenExclusiveWin32InfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderSubgroupClock)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderDeviceClock)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->hmonitor)); + value->hmonitor = nullptr; 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_VkHeadlessSurfaceCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265ProfileInfoKHR* value = wrapper->decoded_value; + VkHeadlessSurfaceCreateInfoEXT* 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265CapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHeadlessSurfaceCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265CapabilitiesKHR* value = wrapper->decoded_value; + VkHeadlessSurfaceCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); 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_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265SessionParametersAddInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat32Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat32AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat64AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat32Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat32AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat64AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageFloat32Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageFloat32AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageFloat32Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageFloat32AtomicAdd)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265SessionParametersCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat32Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat32AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat64AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat32Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat32AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat64AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageFloat32Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageFloat32AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageFloat32Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageFloat32AtomicAdd)); 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_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265PictureInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeH265DpbSlotInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeH265DpbSlotInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState)); 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_VkPhysicalDeviceHostImageCopyFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceQueueGlobalPriorityCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceHostImageCopyFeaturesEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hostImageCopy)); 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_VkPhysicalDeviceHostImageCopyPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceHostImageCopyPropertiesEXT* 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->globalPriorityQuery)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->copySrcLayoutCount)); + bytes_read += wrapper->pCopySrcLayouts.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCopySrcLayouts = wrapper->pCopySrcLayouts.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->copyDstLayoutCount)); + bytes_read += wrapper->pCopyDstLayouts.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCopyDstLayouts = wrapper->pCopyDstLayouts.GetPointer(); + wrapper->optimalTilingLayoutUUID.SetExternalMemory(value->optimalTilingLayoutUUID, VK_UUID_SIZE); + bytes_read += wrapper->optimalTilingLayoutUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identicalMemoryTypeRequirements)); 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_VkMemoryToImageCopyEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueueFamilyGlobalPriorityPropertiesKHR* value = wrapper->decoded_value; + VkMemoryToImageCopyEXT* 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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pHostPointer)); + value->pHostPointer = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryRowLength)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryImageHeight)); + wrapper->imageSubresource = DecodeAllocator::Allocate(); + wrapper->imageSubresource->decoded_value = &(value->imageSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); + wrapper->imageOffset = DecodeAllocator::Allocate(); + wrapper->imageOffset->decoded_value = &(value->imageOffset); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); + wrapper->imageExtent = DecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); 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_VkImageToMemoryCopyEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFragmentShadingRateAttachmentInfoKHR* value = wrapper->decoded_value; + VkImageToMemoryCopyEXT* 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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pHostPointer)); + value->pHostPointer = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryRowLength)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryImageHeight)); + wrapper->imageSubresource = DecodeAllocator::Allocate(); + wrapper->imageSubresource->decoded_value = &(value->imageSubresource); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); + wrapper->imageOffset = DecodeAllocator::Allocate(); + wrapper->imageOffset->decoded_value = &(value->imageOffset); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); + wrapper->imageExtent = DecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); 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_VkCopyMemoryToImageInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineFragmentShadingRateStateCreateInfoKHR* value = wrapper->decoded_value; + VkCopyMemoryToImageInfoEXT* 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + 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_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageToMemoryInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShadingRateFeaturesKHR* value = wrapper->decoded_value; + VkCopyImageToMemoryInfoEXT* 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->pipelineFragmentShadingRate)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRate)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentFragmentShadingRate)); + 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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + 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_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageToImageInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShadingRatePropertiesKHR* value = wrapper->decoded_value; + VkCopyImageToImageInfoEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRateWithMultipleViewports)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->layeredShadingRateAttachments)); - bytes_read += ValueDecoder::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderDepthStencilWrites)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithSampleMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithShaderSampleMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithConservativeRasterization)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithFragmentShaderInterlock)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateWithCustomSampleLocations)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateStrictMultiplyCombiner)); + 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->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + 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_VkPhysicalDeviceFragmentShadingRateKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHostImageLayoutTransitionInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShadingRateKHR* value = wrapper->decoded_value; + VkHostImageLayoutTransitionInfoEXT* 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); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); + value->image = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->oldLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->newLayout)); + wrapper->subresourceRange = DecodeAllocator::Allocate(); + wrapper->subresourceRange->decoded_value = &(value->subresourceRange); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceRange); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubresourceHostMemcpySizeEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* value = wrapper->decoded_value; + VkSubresourceHostMemcpySizeEXT* 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->dynamicRenderingLocalRead)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingAttachmentLocationInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHostImageCopyDevicePerformanceQueryEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingAttachmentLocationInfoKHR* value = wrapper->decoded_value; + VkHostImageCopyDevicePerformanceQueryEXT* 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->pColorAttachmentLocations.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pColorAttachmentLocations = wrapper->pColorAttachmentLocations.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimalDeviceAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identicalMemoryLayout)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderingInputAttachmentIndexInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostImageCopyFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingInputAttachmentIndexInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceHostImageCopyFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pColorAttachmentInputIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pColorAttachmentInputIndices = wrapper->pColorAttachmentInputIndices.GetPointer(); - bytes_read += wrapper->pDepthInputAttachmentIndex.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDepthInputAttachmentIndex = wrapper->pDepthInputAttachmentIndex.GetPointer(); - bytes_read += wrapper->pStencilInputAttachmentIndex.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStencilInputAttachmentIndex = wrapper->pStencilInputAttachmentIndex.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hostImageCopy)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderQuadControlFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostImageCopyPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderQuadControlFeaturesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceHostImageCopyPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderQuadControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->copySrcLayoutCount)); + bytes_read += wrapper->pCopySrcLayouts.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCopySrcLayouts = wrapper->pCopySrcLayouts.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->copyDstLayoutCount)); + bytes_read += wrapper->pCopyDstLayouts.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCopyDstLayouts = wrapper->pCopyDstLayouts.GetPointer(); + wrapper->optimalTilingLayoutUUID.SetExternalMemory(value->optimalTilingLayoutUUID, VK_UUID_SIZE); + bytes_read += wrapper->optimalTilingLayoutUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identicalMemoryTypeRequirements)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceProtectedCapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryToImageCopyEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceProtectedCapabilitiesKHR* value = wrapper->decoded_value; + VkMemoryToImageCopyEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->supportsProtected)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pHostPointer)); + value->pHostPointer = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryRowLength)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryImageHeight)); + wrapper->imageSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->imageSubresource->decoded_value = &(value->imageSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); + wrapper->imageOffset = PreloadDecodeAllocator::Allocate(); + wrapper->imageOffset->decoded_value = &(value->imageOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); + wrapper->imageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentWaitFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageToMemoryCopyEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePresentWaitFeaturesKHR* value = wrapper->decoded_value; + VkImageToMemoryCopyEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->presentWait)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pHostPointer)); + value->pHostPointer = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryRowLength)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryImageHeight)); + wrapper->imageSubresource = PreloadDecodeAllocator::Allocate(); + wrapper->imageSubresource->decoded_value = &(value->imageSubresource); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); + wrapper->imageOffset = PreloadDecodeAllocator::Allocate(); + wrapper->imageOffset->decoded_value = &(value->imageOffset); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); + wrapper->imageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->imageExtent->decoded_value = &(value->imageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMemoryToImageInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* value = wrapper->decoded_value; + VkCopyMemoryToImageInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pipelineExecutableInfo)); + 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->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((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_VkPipelineInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageToMemoryInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineInfoKHR* value = wrapper->decoded_value; + VkCopyImageToMemoryInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((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_VkPipelineExecutablePropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageToImageInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineExecutablePropertiesKHR* value = wrapper->decoded_value; + VkCopyImageToImageInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->srcImage)); + value->srcImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); + value->dstImage = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((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_VkPipelineExecutableInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHostImageLayoutTransitionInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineExecutableInfoKHR* value = wrapper->decoded_value; + VkHostImageLayoutTransitionInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->image)); + value->image = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->oldLayout)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->newLayout)); + wrapper->subresourceRange = PreloadDecodeAllocator::Allocate(); + wrapper->subresourceRange->decoded_value = &(value->subresourceRange); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceRange); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableStatisticKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubresourceHostMemcpySizeEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineExecutableStatisticKHR* value = wrapper->decoded_value; + VkSubresourceHostMemcpySizeEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineExecutableInternalRepresentationKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHostImageCopyDevicePerformanceQueryEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineExecutableInternalRepresentationKHR* value = wrapper->decoded_value; + VkHostImageCopyDevicePerformanceQueryEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimalDeviceAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identicalMemoryLayout)); 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_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryMapInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryMapPlaced)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryMapRangePlaced)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryUnmapReserve)); 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_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryUnmapInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minPlacedMemoryMapAlignment)); 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_VkMemoryMapPlacedInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineLibraryCreateInfoKHR* value = wrapper->decoded_value; + VkMemoryMapPlacedInfoEXT* 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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pPlacedAddress)); + value->pPlacedAddress = nullptr; return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentIdKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentIdKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryMapPlaced)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryMapRangePlaced)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryUnmapReserve)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentIdFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePresentIdFeaturesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->presentId)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minPlacedMemoryMapAlignment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryMapPlacedInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeInfoKHR* value = wrapper->decoded_value; + VkMemoryMapPlacedInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstBufferOffset)); - bytes_read += ValueDecoder::DecodeUInt64Value((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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pPlacedAddress)); + value->pPlacedAddress = nullptr; 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_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeCapabilitiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat16Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat16AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat16AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat32AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat64AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat16Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat16AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat16AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat32AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat64AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageFloat32AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageFloat32AtomicMinMax)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderBufferFloat16Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat16AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat16AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat32AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat64AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat16Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat16AtomicAdd)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat16AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat32AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat64AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageFloat32AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageFloat32AtomicMinMax)); 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_VkSurfacePresentModeEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeUsageInfoKHR* value = wrapper->decoded_value; + VkSurfacePresentModeEXT* 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)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentMode)); 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_VkSurfacePresentScalingCapabilitiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeRateControlLayerInfoKHR* value = wrapper->decoded_value; + VkSurfacePresentScalingCapabilitiesEXT* 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)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedPresentScaling)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedPresentGravityX)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedPresentGravityY)); + wrapper->minScaledImageExtent = DecodeAllocator::Allocate(); + wrapper->minScaledImageExtent->decoded_value = &(value->minScaledImageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minScaledImageExtent); + wrapper->maxScaledImageExtent = DecodeAllocator::Allocate(); + wrapper->maxScaledImageExtent->decoded_value = &(value->maxScaledImageExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxScaledImageExtent); 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_VkSurfacePresentModeCompatibilityEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeRateControlInfoKHR* value = wrapper->decoded_value; + VkSurfacePresentModeCompatibilityEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentModeCount)); + bytes_read += wrapper->pPresentModes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentModes = wrapper->pPresentModes.GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfacePresentModeEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* value = wrapper->decoded_value; + VkSurfacePresentModeEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentMode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfacePresentScalingCapabilitiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeQualityLevelPropertiesKHR* value = wrapper->decoded_value; + VkSurfacePresentScalingCapabilitiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->supportedPresentScaling)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedPresentGravityX)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedPresentGravityY)); + wrapper->minScaledImageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->minScaledImageExtent->decoded_value = &(value->minScaledImageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minScaledImageExtent); + wrapper->maxScaledImageExtent = PreloadDecodeAllocator::Allocate(); + wrapper->maxScaledImageExtent->decoded_value = &(value->maxScaledImageExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxScaledImageExtent); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfacePresentModeCompatibilityEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeQualityLevelInfoKHR* value = wrapper->decoded_value; + VkSurfacePresentModeCompatibilityEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentModeCount)); + bytes_read += wrapper->pPresentModes.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentModes = wrapper->pPresentModes.GetPointer(); 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_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeSessionParametersGetInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainMaintenance1)); 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_VkSwapchainPresentFenceInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoEncodeSessionParametersFeedbackInfoKHR* value = wrapper->decoded_value; + VkSwapchainPresentFenceInfoEXT* 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->hasOverrides)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); + bytes_read += wrapper->pFences.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pFences = nullptr; 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_VkSwapchainPresentModesCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueueFamilyCheckpointProperties2NV* value = wrapper->decoded_value; + VkSwapchainPresentModesCreateInfoEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentModeCount)); + bytes_read += wrapper->pPresentModes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentModes = wrapper->pPresentModes.GetPointer(); 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_VkSwapchainPresentModeInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCheckpointData2NV* value = wrapper->decoded_value; + VkSwapchainPresentModeInfoEXT* 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 += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); + bytes_read += wrapper->pPresentModes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentModes = wrapper->pPresentModes.GetPointer(); 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_VkSwapchainPresentScalingCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* value = wrapper->decoded_value; + VkSwapchainPresentScalingCreateInfoEXT* 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->fragmentShaderBarycentric)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scalingBehavior)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentGravityX)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentGravityY)); 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_VkReleaseSwapchainImagesInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* value = wrapper->decoded_value; + VkReleaseSwapchainImagesInfoEXT* 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->triStripVertexOrderIndependentOfProvokingVertex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->swapchain)); + value->swapchain = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageIndexCount)); + bytes_read += wrapper->pImageIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImageIndices = wrapper->pImageIndices.GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderSubgroupUniformControlFlow)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainMaintenance1)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentFenceInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* value = wrapper->decoded_value; + VkSwapchainPresentFenceInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->workgroupMemoryExplicitLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayoutScalarBlockLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout8BitAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->workgroupMemoryExplicitLayout16BitAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapchainCount)); + bytes_read += wrapper->pFences.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pFences = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentModesCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* value = wrapper->decoded_value; + VkSwapchainPresentModesCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->rayTracingMaintenance1)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPipelineTraceRaysIndirect2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentModeCount)); + bytes_read += wrapper->pPresentModes.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentModes = wrapper->pPresentModes.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTraceRaysIndirectCommand2KHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentModeInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkTraceRaysIndirectCommand2KHR* value = wrapper->decoded_value; + VkSwapchainPresentModeInfoEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordAddress)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->raygenShaderRecordSize)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableAddress)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableSize)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->missShaderBindingTableStride)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableAddress)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableSize)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hitShaderBindingTableStride)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableAddress)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->callableShaderBindingTableSize)); - bytes_read += ValueDecoder::DecodeUInt64Value((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 += PreloadDecodePNextStruct((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->pPresentModes.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentModes = wrapper->pPresentModes.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentScalingCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* value = wrapper->decoded_value; + VkSwapchainPresentScalingCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderSubgroupRotate)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSubgroupRotateClustered)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scalingBehavior)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentGravityX)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentGravityY)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkReleaseSwapchainImagesInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* value = wrapper->decoded_value; + VkReleaseSwapchainImagesInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderMaximalReconvergence)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->swapchain)); + value->swapchain = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageIndexCount)); + bytes_read += wrapper->pImageIndices.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImageIndices = wrapper->pImageIndices.GetPointer(); 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_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance5FeaturesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* 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->maintenance5)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGraphicsShaderGroupCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectSequenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsTokenCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsStreamCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsTokenOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsStreamStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSequencesCountBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSequencesIndexBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minIndirectCommandsBufferOffsetAlignment)); 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_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance5PropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* 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->earlyFragmentMultisampleCoverageAfterSampleCounting)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentSampleMaskTestBeforeSampleCounting)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilSwizzleOneSupport)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->polygonModePointSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictSinglePixelWideLinesUseParallelogram)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictWideLinesUseParallelogram)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedCommands)); 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_VkGraphicsShaderGroupCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderingAreaInfoKHR* value = wrapper->decoded_value; + VkGraphicsShaderGroupCreateInfoNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stageCount)); + wrapper->pStages = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStages->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStages = wrapper->pStages->GetPointer(); + wrapper->pVertexInputState = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pVertexInputState->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVertexInputState = wrapper->pVertexInputState->GetPointer(); + wrapper->pTessellationState = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pTessellationState->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTessellationState = wrapper->pTessellationState->GetPointer(); 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_VkGraphicsPipelineShaderGroupsCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageSubresource2KHR* value = wrapper->decoded_value; + VkGraphicsPipelineShaderGroupsCreateInfoNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupCount)); + wrapper->pGroups = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pGroups->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pGroups = wrapper->pGroups->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineCount)); + bytes_read += wrapper->pPipelines.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPipelines = nullptr; 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_VkBindShaderGroupIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceImageSubresourceInfoKHR* value = wrapper->decoded_value; + VkBindShaderGroupIndirectCommandNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupIndex)); 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_VkBindIndexBufferIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubresourceLayout2KHR* value = wrapper->decoded_value; + VkBindIndexBufferIndirectCommandNV* 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); 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_VkBindVertexBufferIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineCreateFlags2CreateInfoKHR* value = wrapper->decoded_value; + VkBindVertexBufferIndirectCommandNV* 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->bufferAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); 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_VkSetStateFlagsIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBufferUsageFlags2CreateInfoKHR* value = wrapper->decoded_value; + VkSetStateFlagsIndirectCommandNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->data)); 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_VkIndirectCommandsStreamNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* value = wrapper->decoded_value; + VkIndirectCommandsStreamNV* 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->rayTracingPositionFetch)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); 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_VkIndirectCommandsLayoutTokenNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCooperativeMatrixPropertiesKHR* value = wrapper->decoded_value; + VkIndirectCommandsLayoutTokenNV* 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::DecodeUInt32Value((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->tokenType)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stream)); + 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->vertexBindingUnit)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexDynamicStride)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pushconstantPipelineLayout)); + value->pushconstantPipelineLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushconstantShaderStageFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushconstantOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushconstantSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indirectStateFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexTypeCount)); + bytes_read += wrapper->pIndexTypes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pIndexTypes = wrapper->pIndexTypes.GetPointer(); + bytes_read += wrapper->pIndexTypeValues.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pIndexTypeValues = wrapper->pIndexTypeValues.GetPointer(); 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_VkIndirectCommandsLayoutCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCooperativeMatrixFeaturesKHR* value = wrapper->decoded_value; + VkIndirectCommandsLayoutCreateInfoNV* 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->cooperativeMatrix)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixRobustBufferAccess)); + 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->pipelineBindPoint)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tokenCount)); + wrapper->pTokens = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pTokens->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTokens = wrapper->pTokens->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->streamCount)); + bytes_read += wrapper->pStreamStrides.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStreamStrides = wrapper->pStreamStrides.GetPointer(); 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_VkGeneratedCommandsInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCooperativeMatrixPropertiesKHR* value = wrapper->decoded_value; + VkGeneratedCommandsInfoNV* 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineBindPoint)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); + value->pipeline = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectCommandsLayout)); + value->indirectCommandsLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->streamCount)); + wrapper->pStreams = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStreams->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStreams = wrapper->pStreams->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequencesCount)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->preprocessBuffer)); + value->preprocessBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preprocessOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preprocessSize)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->sequencesCountBuffer)); + value->sequencesCountBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequencesCountOffset)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->sequencesIndexBuffer)); + value->sequencesIndexBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequencesIndexOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1ProfileInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeneratedCommandsMemoryRequirementsInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeAV1ProfileInfoKHR* value = wrapper->decoded_value; + VkGeneratedCommandsMemoryRequirementsInfoNV* 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->stdProfile)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filmGrainSupport)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineBindPoint)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); + value->pipeline = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectCommandsLayout)); + value->indirectCommandsLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSequencesCount)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1CapabilitiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeAV1CapabilitiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGraphicsShaderGroupCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectSequenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsTokenCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsStreamCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsTokenOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsStreamStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSequencesCountBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSequencesIndexBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minIndirectCommandsBufferOffsetAlignment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1SessionParametersCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeAV1SessionParametersCreateInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->pStdSequenceHeader = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStdSequenceHeader->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStdSequenceHeader = wrapper->pStdSequenceHeader->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedCommands)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1PictureInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGraphicsShaderGroupCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeAV1PictureInfoKHR* value = wrapper->decoded_value; + VkGraphicsShaderGroupCreateInfoNV* 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(); - wrapper->referenceNameSlotIndices.SetExternalMemory(value->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR); - bytes_read += wrapper->referenceNameSlotIndices.DecodeInt32((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameHeaderOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tileCount)); - bytes_read += wrapper->pTileOffsets.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pTileOffsets = wrapper->pTileOffsets.GetPointer(); - bytes_read += wrapper->pTileSizes.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pTileSizes = wrapper->pTileSizes.GetPointer(); + bytes_read += PreloadDecodePNextStruct((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->stageCount)); + wrapper->pStages = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStages->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStages = wrapper->pStages->GetPointer(); + wrapper->pVertexInputState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pVertexInputState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVertexInputState = wrapper->pVertexInputState->GetPointer(); + wrapper->pTessellationState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pTessellationState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTessellationState = wrapper->pTessellationState->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1DpbSlotInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGraphicsPipelineShaderGroupsCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoDecodeAV1DpbSlotInfoKHR* value = wrapper->decoded_value; + VkGraphicsPipelineShaderGroupsCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupCount)); + wrapper->pGroups = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pGroups->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pGroups = wrapper->pGroups->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineCount)); + bytes_read += wrapper->pPipelines.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPipelines = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindShaderGroupIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVideoMaintenance1FeaturesKHR* value = wrapper->decoded_value; + VkBindShaderGroupIndirectCommandNV* 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->videoMaintenance1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupIndex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVideoInlineQueryInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindIndexBufferIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVideoInlineQueryInfoKHR* value = wrapper->decoded_value; + VkBindIndexBufferIndirectCommandNV* 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->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)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindVertexBufferIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* value = wrapper->decoded_value; + VkBindVertexBufferIndirectCommandNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportsNonZeroFirstInstance)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDivisorDescriptionKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSetStateFlagsIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVertexInputBindingDivisorDescriptionKHR* value = wrapper->decoded_value; + VkSetStateFlagsIndirectCommandNV* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->data)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsStreamNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineVertexInputDivisorStateCreateInfoKHR* value = wrapper->decoded_value; + VkIndirectCommandsStreamNV* 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(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutTokenNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* value = wrapper->decoded_value; + VkIndirectCommandsLayoutTokenNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->vertexAttributeInstanceRateDivisor)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateZeroDivisor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tokenType)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stream)); + 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->vertexBindingUnit)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexDynamicStride)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pushconstantPipelineLayout)); + value->pushconstantPipelineLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushconstantShaderStageFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushconstantOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushconstantSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indirectStateFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexTypeCount)); + bytes_read += wrapper->pIndexTypes.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pIndexTypes = wrapper->pIndexTypes.GetPointer(); + bytes_read += wrapper->pIndexTypeValues.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pIndexTypeValues = wrapper->pIndexTypeValues.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderFloatControls2FeaturesKHR* value = wrapper->decoded_value; + VkIndirectCommandsLayoutCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderFloatControls2)); + 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->pipelineBindPoint)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tokenCount)); + wrapper->pTokens = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pTokens->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTokens = wrapper->pTokens->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->streamCount)); + bytes_read += wrapper->pStreamStrides.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStreamStrides = wrapper->pStreamStrides.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeneratedCommandsInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceIndexTypeUint8FeaturesKHR* value = wrapper->decoded_value; + VkGeneratedCommandsInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->indexTypeUint8)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineBindPoint)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); + value->pipeline = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectCommandsLayout)); + value->indirectCommandsLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->streamCount)); + wrapper->pStreams = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStreams->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStreams = wrapper->pStreams->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequencesCount)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->preprocessBuffer)); + value->preprocessBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preprocessOffset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preprocessSize)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->sequencesCountBuffer)); + value->sequencesCountBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequencesCountOffset)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->sequencesIndexBuffer)); + value->sequencesIndexBuffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequencesIndexOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeneratedCommandsMemoryRequirementsInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLineRasterizationFeaturesKHR* value = wrapper->decoded_value; + VkGeneratedCommandsMemoryRequirementsInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->rectangularLines)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bresenhamLines)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->smoothLines)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledRectangularLines)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledBresenhamLines)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledSmoothLines)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineBindPoint)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); + value->pipeline = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectCommandsLayout)); + value->indirectCommandsLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSequencesCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLineRasterizationPropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceInheritedViewportScissorFeaturesNV* 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->lineSubPixelPrecisionBits)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inheritedViewportScissor2D)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationLineStateCreateInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceViewportScissorInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRasterizationLineStateCreateInfoKHR* value = wrapper->decoded_value; + VkCommandBufferInheritanceViewportScissorInfoNV* 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->lineRasterizationMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stippledLineEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lineStippleFactor)); - bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lineStipplePattern)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportScissor2D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportDepthCount)); + wrapper->pViewportDepths = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pViewportDepths->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewportDepths = wrapper->pViewportDepths->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCalibratedTimestampInfoKHR* value = wrapper->decoded_value; + VkPhysicalDeviceInheritedViewportScissorFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inheritedViewportScissor2D)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceViewportScissorInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* value = wrapper->decoded_value; + VkCommandBufferInheritanceViewportScissorInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderExpectAssume)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportScissor2D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportDepthCount)); + wrapper->pViewportDepths = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pViewportDepths->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pViewportDepths = wrapper->pViewportDepths->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance6FeaturesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* 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->maintenance6)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->texelBufferAlignment)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance6PropertiesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->blockTexelViewCompatibleMultipleLayers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxCombinedImageSamplerDescriptorCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateClampCombinerInputs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->texelBufferAlignment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindMemoryStatusKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassTransformBeginInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindMemoryStatusKHR* value = wrapper->decoded_value; + VkRenderPassTransformBeginInfoQCOM* 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->pResult.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pResult = wrapper->pResult.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transform)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindDescriptorSetsInfoKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindDescriptorSetsInfoKHR* value = wrapper->decoded_value; + VkCommandBufferInheritanceRenderPassTransformInfoQCOM* 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->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(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transform)); + wrapper->renderArea = DecodeAllocator::Allocate(); + wrapper->renderArea->decoded_value = &(value->renderArea); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderArea); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushConstantsInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassTransformBeginInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPushConstantsInfoKHR* value = wrapper->decoded_value; + VkRenderPassTransformBeginInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->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(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transform)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushDescriptorSetInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPushDescriptorSetInfoKHR* value = wrapper->decoded_value; + VkCommandBufferInheritanceRenderPassTransformInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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)); - 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(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transform)); + wrapper->renderArea = PreloadDecodeAllocator::Allocate(); + wrapper->renderArea->decoded_value = &(value->renderArea); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderArea); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSetDescriptorBufferOffsetsInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthBiasControlFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSetDescriptorBufferOffsetsInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDepthBiasControlFeaturesEXT* 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->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.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - value->pOffsets = wrapper->pOffsets.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->leastRepresentableValueForceUnormRepresentation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->floatRepresentation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasExact)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDepthBiasInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindDescriptorBufferEmbeddedSamplersInfoEXT* value = wrapper->decoded_value; + VkDepthBiasInfoEXT* 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->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::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasConstantFactor)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasClamp)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasSlopeFactor)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDepthBiasRepresentationInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* value = wrapper->decoded_value; + VkDepthBiasRepresentationInfoEXT* 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->shaderRelaxedExtendedInstruction)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasRepresentation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasExact)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance7FeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthBiasControlFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance7FeaturesKHR* value = wrapper->decoded_value; + VkPhysicalDeviceDepthBiasControlFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->maintenance7)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasControl)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->leastRepresentableValueForceUnormRepresentation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->floatRepresentation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasExact)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance7PropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDepthBiasInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMaintenance7PropertiesKHR* value = wrapper->decoded_value; + VkDepthBiasInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->robustFragmentShadingRateAttachmentAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->separateDepthStencilAttachmentAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetTotalUniformBuffersDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetTotalStorageBuffersDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetTotalBuffersDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindTotalBuffersDynamic)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasConstantFactor)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasClamp)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasSlopeFactor)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiPropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDepthBiasRepresentationInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLayeredApiPropertiesKHR* value = wrapper->decoded_value; + VkDepthBiasRepresentationInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->vendorID)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceID)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->layeredAPI)); - wrapper->deviceName.SetExternalMemory(value->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE); - bytes_read += wrapper->deviceName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasRepresentation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasExact)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiPropertiesListKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLayeredApiPropertiesListKHR* value = wrapper->decoded_value; + VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* 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->layeredApiCount)); - wrapper->pLayeredApis = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pLayeredApis->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pLayeredApis = wrapper->pLayeredApis->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceMemoryReport)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceMemoryReportCallbackDataEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* value = wrapper->decoded_value; + VkDeviceMemoryReportCallbackDataEXT* 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->properties = DecodeAllocator::Allocate(); - wrapper->properties->decoded_value = &(value->properties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->properties); + 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->type)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryObjectId)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectType)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectHandle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->heapIndex)); 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_VkDeviceDeviceMemoryReportCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugReportCallbackCreateInfoEXT* value = wrapper->decoded_value; + VkDeviceDeviceMemoryReportCreateInfoEXT* 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->pfnUserCallback)); + value->pfnUserCallback = 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_VkPipelineRasterizationStateRasterizationOrderAMD* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRasterizationStateRasterizationOrderAMD* value = wrapper->decoded_value; + VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceMemoryReport)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceMemoryReportCallbackDataEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugMarkerObjectNameInfoEXT* value = wrapper->decoded_value; + VkDeviceMemoryReportCallbackDataEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->type)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryObjectId)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); 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::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectHandle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->heapIndex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectTagInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceDeviceMemoryReportCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugMarkerObjectTagInfoEXT* value = wrapper->decoded_value; + VkDeviceDeviceMemoryReportCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnUserCallback)); + value->pfnUserCallback = 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_VkDebugMarkerMarkerInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRobustness2FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugMarkerMarkerInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceRobustness2FeaturesEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustBufferAccess2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustImageAccess2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nullDescriptor)); 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_VkPhysicalDeviceRobustness2PropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDedicatedAllocationImageCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceRobustness2PropertiesEXT* 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->dedicatedAllocation)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustStorageBufferAccessSizeAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustUniformBufferAccessSizeAlignment)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationBufferCreateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRobustness2FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDedicatedAllocationBufferCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceRobustness2FeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->dedicatedAllocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustBufferAccess2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustImageAccess2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nullDescriptor)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDedicatedAllocationMemoryAllocateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRobustness2PropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDedicatedAllocationMemoryAllocateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceRobustness2PropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustStorageBufferAccessSizeAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustUniformBufferAccessSizeAlignment)); 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_VkSamplerCustomBorderColorCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTransformFeedbackFeaturesEXT* value = wrapper->decoded_value; + VkSamplerCustomBorderColorCreateInfoEXT* 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->transformFeedback)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryStreams)); + wrapper->customBorderColor = DecodeAllocator::Allocate(); + wrapper->customBorderColor->decoded_value = &(value->customBorderColor); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->customBorderColor); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); 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_VkPhysicalDeviceCustomBorderColorPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTransformFeedbackPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceCustomBorderColorPropertiesEXT* 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::DecodeUInt64Value((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackQueries)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackStreamsLinesTriangles)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackRasterizationStreamSelect)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackDraw)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxCustomBorderColorSamplers)); 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_VkPhysicalDeviceCustomBorderColorFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRasterizationStateStreamCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceCustomBorderColorFeaturesEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->customBorderColors)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->customBorderColorWithoutFormat)); + + return bytes_read; +} +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerCustomBorderColorCreateInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerCustomBorderColorCreateInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->customBorderColor = PreloadDecodeAllocator::Allocate(); + wrapper->customBorderColor->decoded_value = &(value->customBorderColor); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->customBorderColor); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewHandleInfoNVX* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCustomBorderColorPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageViewHandleInfoNVX* value = wrapper->decoded_value; + VkPhysicalDeviceCustomBorderColorPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxCustomBorderColorSamplers)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewAddressPropertiesNVX* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCustomBorderColorFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageViewAddressPropertiesNVX* value = wrapper->decoded_value; + VkPhysicalDeviceCustomBorderColorFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->deviceAddress)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->customBorderColors)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->customBorderColorWithoutFormat)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTextureLODGatherFormatPropertiesAMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentBarrierFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkTextureLODGatherFormatPropertiesAMD* value = wrapper->decoded_value; + VkPhysicalDevicePresentBarrierFeaturesNV* 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->supportsTextureGatherLODBiasAMD)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentBarrier)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderResourceUsageAMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesPresentBarrierNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkShaderResourceUsageAMD* value = wrapper->decoded_value; + VkSurfaceCapabilitiesPresentBarrierNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numUsedVgprs)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numUsedSgprs)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ldsSizePerLocalWorkGroup)); - bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ldsUsageSizeInBytes)); - bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scratchMemUsageInBytes)); + 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->presentBarrierSupported)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderStatisticsInfoAMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentBarrierCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkShaderStatisticsInfoAMD* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStageMask)); - wrapper->resourceUsage = DecodeAllocator::Allocate(); - wrapper->resourceUsage->decoded_value = &(value->resourceUsage); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->resourceUsage); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numPhysicalVgprs)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numPhysicalSgprs)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numAvailableVgprs)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numAvailableSgprs)); - wrapper->computeWorkGroupSize.SetExternalMemory(value->computeWorkGroupSize, 3); - bytes_read += wrapper->computeWorkGroupSize.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + VkSwapchainPresentBarrierCreateInfoNV* 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->presentBarrierEnable)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkStreamDescriptorSurfaceCreateInfoGGP* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentBarrierFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkStreamDescriptorSurfaceCreateInfoGGP* value = wrapper->decoded_value; + VkPhysicalDevicePresentBarrierFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->streamDescriptor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentBarrier)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCornerSampledImageFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesPresentBarrierNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCornerSampledImageFeaturesNV* value = wrapper->decoded_value; + VkSurfaceCapabilitiesPresentBarrierNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->cornerSampledImage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentBarrierSupported)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalImageFormatPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentBarrierCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalImageFormatPropertiesNV* value = wrapper->decoded_value; + VkSwapchainPresentBarrierCreateInfoNV* value = wrapper->decoded_value; - wrapper->imageFormatProperties = DecodeAllocator::Allocate(); - wrapper->imageFormatProperties->decoded_value = &(value->imageFormatProperties); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageFormatProperties); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalMemoryFeatures)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->exportFromImportedHandleTypes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->compatibleHandleTypes)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->presentBarrierEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryImageCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalMemoryImageCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceDiagnosticsConfigFeaturesNV* 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->handleTypes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->diagnosticsConfig)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryAllocateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceDiagnosticsConfigCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportMemoryAllocateInfoNV* value = wrapper->decoded_value; + VkDeviceDiagnosticsConfigCreateInfoNV* 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->handleTypes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryWin32HandleInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportMemoryWin32HandleInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceDiagnosticsConfigFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->handleType)); - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->handle)); - value->handle = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->diagnosticsConfig)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceDiagnosticsConfigCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExportMemoryWin32HandleInfoNV* value = wrapper->decoded_value; + VkDeviceDiagnosticsConfigCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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 += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryLowLatencySupportNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkWin32KeyedMutexAcquireReleaseInfoNV* value = wrapper->decoded_value; + VkQueryLowLatencySupportNV* 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->pAcquireTimeoutMilliseconds.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAcquireTimeoutMilliseconds = wrapper->pAcquireTimeoutMilliseconds.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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pQueriedLowLatencyData)); + value->pQueriedLowLatencyData = nullptr; return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkValidationFlagsEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryLowLatencySupportNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkValidationFlagsEXT* value = wrapper->decoded_value; + VkQueryLowLatencySupportNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->disabledValidationCheckCount)); - bytes_read += wrapper->pDisabledValidationChecks.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDisabledValidationChecks = wrapper->pDisabledValidationChecks.GetPointer(); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pQueriedLowLatencyData)); + value->pQueriedLowLatencyData = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViSurfaceCreateInfoNN* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkViSurfaceCreateInfoNN* value = wrapper->decoded_value; + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* 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->window)); - value->window = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->graphicsPipelineLibrary)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewASTCDecodeModeEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageViewASTCDecodeModeEXT* value = wrapper->decoded_value; + VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* 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->decodeMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->graphicsPipelineLibraryFastLinking)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->graphicsPipelineLibraryIndependentInterpolationDecoration)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceASTCDecodeFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGraphicsPipelineLibraryCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceASTCDecodeFeaturesEXT* value = wrapper->decoded_value; + VkGraphicsPipelineLibraryCreateInfoEXT* 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->decodeModeSharedExponent)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePipelineRobustnessFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pipelineRobustness)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->graphicsPipelineLibrary)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePipelineRobustnessPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->defaultRobustnessStorageBuffers)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessUniformBuffers)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessVertexInputs)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->defaultRobustnessImages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->graphicsPipelineLibraryFastLinking)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->graphicsPipelineLibraryIndependentInterpolationDecoration)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRobustnessCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGraphicsPipelineLibraryCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRobustnessCreateInfoEXT* value = wrapper->decoded_value; + VkGraphicsPipelineLibraryCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->storageBuffers)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->uniformBuffers)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexInputs)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->images)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkConditionalRenderingBeginInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkConditionalRenderingBeginInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* 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->buffer)); - value->buffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); - 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->shaderEarlyAndLateFragmentTests)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConditionalRenderingFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceConditionalRenderingFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* 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)); + bytes_read += PreloadDecodePNextStruct((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->conditionalRendering)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inheritedConditionalRendering)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderEarlyAndLateFragmentTests)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceConditionalRenderingInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCommandBufferInheritanceConditionalRenderingInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* 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->conditionalRenderingEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateEnums)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supersampleFragmentShadingRates)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->noInvocationFragmentShadingRates)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViewportWScalingNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkViewportWScalingNV* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->xcoeff)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycoeff)); + 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->maxFragmentShadingRateInvocationCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportWScalingStateCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineViewportWScalingStateCreateInfoNV* value = wrapper->decoded_value; + VkPipelineFragmentShadingRateEnumStateCreateInfoNV* 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->viewportWScalingEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportCount)); - wrapper->pViewportWScalings = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pViewportWScalings->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pViewportWScalings = wrapper->pViewportWScalings->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRate)); + 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_VkSurfaceCapabilities2EXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceCapabilities2EXT* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->minImageCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageCount)); - wrapper->currentExtent = DecodeAllocator::Allocate(); - wrapper->currentExtent->decoded_value = &(value->currentExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->currentExtent); - wrapper->minImageExtent = DecodeAllocator::Allocate(); - wrapper->minImageExtent->decoded_value = &(value->minImageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minImageExtent); - wrapper->maxImageExtent = DecodeAllocator::Allocate(); - wrapper->maxImageExtent->decoded_value = &(value->maxImageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxImageExtent); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxImageArrayLayers)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedTransforms)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->currentTransform)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedCompositeAlpha)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedUsageFlags)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedSurfaceCounters)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShadingRateEnums)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supersampleFragmentShadingRates)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->noInvocationFragmentShadingRates)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayPowerInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayPowerInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->powerState)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFragmentShadingRateInvocationCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceEventInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceEventInfoEXT* value = wrapper->decoded_value; + VkPipelineFragmentShadingRateEnumStateCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->deviceEvent)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRate)); + wrapper->combinerOps.SetExternalMemory(value->combinerOps, 2); + bytes_read += wrapper->combinerOps.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayEventInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryMotionTrianglesDataNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayEventInfoEXT* value = wrapper->decoded_value; + VkAccelerationStructureGeometryMotionTrianglesDataNV* 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->displayEvent)); + wrapper->vertexData = DecodeAllocator::Allocate(); + wrapper->vertexData->decoded_value = &(value->vertexData); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->vertexData); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainCounterCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureMotionInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSwapchainCounterCreateInfoEXT* value = wrapper->decoded_value; + VkAccelerationStructureMotionInfoNV* 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->surfaceCounters)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInstances)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRefreshCycleDurationGOOGLE* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureMatrixMotionInstanceNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRefreshCycleDurationGOOGLE* value = wrapper->decoded_value; + VkAccelerationStructureMatrixMotionInstanceNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->refreshDuration)); + wrapper->transformT0 = DecodeAllocator::Allocate(); + wrapper->transformT0->decoded_value = &(value->transformT0); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT0); + wrapper->transformT1 = DecodeAllocator::Allocate(); + wrapper->transformT1->decoded_value = &(value->transformT1); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT1); + uint32_t temp_instanceCustomIndex; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceCustomIndex); + value->instanceCustomIndex = temp_instanceCustomIndex; + uint32_t temp_mask; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mask); + value->mask = temp_mask; + uint32_t temp_instanceShaderBindingTableRecordOffset; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceShaderBindingTableRecordOffset); + value->instanceShaderBindingTableRecordOffset = temp_instanceShaderBindingTableRecordOffset; + VkGeometryInstanceFlagsKHR temp_flags; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &temp_flags); + value->flags = temp_flags; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureReference)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPastPresentationTimingGOOGLE* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSRTDataNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPastPresentationTimingGOOGLE* value = wrapper->decoded_value; + VkSRTDataNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->desiredPresentTime)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->actualPresentTime)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earliestPresentTime)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentMargin)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sx)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->a)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->b)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pvx)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sy)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->c)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pvy)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sz)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pvz)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qx)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qy)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qz)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qw)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tx)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ty)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tz)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentTimeGOOGLE* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureSRTMotionInstanceNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentTimeGOOGLE* value = wrapper->decoded_value; + VkAccelerationStructureSRTMotionInstanceNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->desiredPresentTime)); + wrapper->transformT0 = DecodeAllocator::Allocate(); + wrapper->transformT0->decoded_value = &(value->transformT0); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT0); + wrapper->transformT1 = DecodeAllocator::Allocate(); + wrapper->transformT1->decoded_value = &(value->transformT1); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT1); + uint32_t temp_instanceCustomIndex; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceCustomIndex); + value->instanceCustomIndex = temp_instanceCustomIndex; + uint32_t temp_mask; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mask); + value->mask = temp_mask; + uint32_t temp_instanceShaderBindingTableRecordOffset; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceShaderBindingTableRecordOffset); + value->instanceShaderBindingTableRecordOffset = temp_instanceShaderBindingTableRecordOffset; + VkGeometryInstanceFlagsKHR temp_flags; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &temp_flags); + value->flags = temp_flags; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureReference)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentTimesInfoGOOGLE* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentTimesInfoGOOGLE* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* 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->pTimes = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pTimes->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pTimes = wrapper->pTimes->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingMotionBlur)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingMotionBlurPipelineTraceRaysIndirect)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryMotionTrianglesDataNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* value = wrapper->decoded_value; + VkAccelerationStructureGeometryMotionTrianglesDataNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->perViewPositionAllComponents)); - - return bytes_read; -} - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkViewportSwizzleNV* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkViewportSwizzleNV* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->z)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->w)); + wrapper->vertexData = PreloadDecodeAllocator::Allocate(); + wrapper->vertexData->decoded_value = &(value->vertexData); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->vertexData); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportSwizzleStateCreateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureMotionInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineViewportSwizzleStateCreateInfoNV* value = wrapper->decoded_value; + VkAccelerationStructureMotionInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxInstances)); 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->viewportCount)); - wrapper->pViewportSwizzles = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pViewportSwizzles->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pViewportSwizzles = wrapper->pViewportSwizzles->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiscardRectanglePropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureMatrixMotionInstanceNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDiscardRectanglePropertiesEXT* value = wrapper->decoded_value; + VkAccelerationStructureMatrixMotionInstanceNV* 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->maxDiscardRectangles)); + wrapper->transformT0 = PreloadDecodeAllocator::Allocate(); + wrapper->transformT0->decoded_value = &(value->transformT0); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT0); + wrapper->transformT1 = PreloadDecodeAllocator::Allocate(); + wrapper->transformT1->decoded_value = &(value->transformT1); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT1); + uint32_t temp_instanceCustomIndex; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceCustomIndex); + value->instanceCustomIndex = temp_instanceCustomIndex; + uint32_t temp_mask; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mask); + value->mask = temp_mask; + uint32_t temp_instanceShaderBindingTableRecordOffset; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceShaderBindingTableRecordOffset); + value->instanceShaderBindingTableRecordOffset = temp_instanceShaderBindingTableRecordOffset; + VkGeometryInstanceFlagsKHR temp_flags; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &temp_flags); + value->flags = temp_flags; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureReference)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineDiscardRectangleStateCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSRTDataNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineDiscardRectangleStateCreateInfoEXT* value = wrapper->decoded_value; + VkSRTDataNV* 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->discardRectangleMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->discardRectangleCount)); - wrapper->pDiscardRectangles = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDiscardRectangles->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDiscardRectangles = wrapper->pDiscardRectangles->GetPointer(); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sx)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->a)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->b)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pvx)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sy)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->c)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pvy)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sz)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pvz)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qx)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qy)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qz)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qw)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tx)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ty)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tz)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureSRTMotionInstanceNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceConservativeRasterizationPropertiesEXT* value = wrapper->decoded_value; + VkAccelerationStructureSRTMotionInstanceNV* 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::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveOverestimationSize)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxExtraPrimitiveOverestimationSize)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extraPrimitiveOverestimationSizeGranularity)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveUnderestimation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conservativePointAndLineRasterization)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->degenerateTrianglesRasterized)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->degenerateLinesRasterized)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fullyCoveredFragmentShaderInputVariable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->conservativeRasterizationPostDepthCoverage)); + wrapper->transformT0 = PreloadDecodeAllocator::Allocate(); + wrapper->transformT0->decoded_value = &(value->transformT0); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT0); + wrapper->transformT1 = PreloadDecodeAllocator::Allocate(); + wrapper->transformT1->decoded_value = &(value->transformT1); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT1); + uint32_t temp_instanceCustomIndex; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceCustomIndex); + value->instanceCustomIndex = temp_instanceCustomIndex; + uint32_t temp_mask; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mask); + value->mask = temp_mask; + uint32_t temp_instanceShaderBindingTableRecordOffset; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceShaderBindingTableRecordOffset); + value->instanceShaderBindingTableRecordOffset = temp_instanceShaderBindingTableRecordOffset; + VkGeometryInstanceFlagsKHR temp_flags; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &temp_flags); + value->flags = temp_flags; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureReference)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationConservativeStateCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRasterizationConservativeStateCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->conservativeRasterizationMode)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extraPrimitiveOverestimationSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingMotionBlur)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingMotionBlurPipelineTraceRaysIndirect)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipEnableFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDepthClipEnableFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* 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->depthClipEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcr2plane444Formats)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationDepthClipStateCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRasterizationDepthClipStateCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->depthClipEnable)); - - return bytes_read; -} - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkXYColorEXT* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkXYColorEXT* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcr2plane444Formats)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHdrMetadataEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkHdrMetadataEXT* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* 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->displayPrimaryRed = DecodeAllocator::Allocate(); - wrapper->displayPrimaryRed->decoded_value = &(value->displayPrimaryRed); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPrimaryRed); - wrapper->displayPrimaryGreen = DecodeAllocator::Allocate(); - wrapper->displayPrimaryGreen->decoded_value = &(value->displayPrimaryGreen); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPrimaryGreen); - wrapper->displayPrimaryBlue = DecodeAllocator::Allocate(); - wrapper->displayPrimaryBlue->decoded_value = &(value->displayPrimaryBlue); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displayPrimaryBlue); - wrapper->whitePoint = DecodeAllocator::Allocate(); - wrapper->whitePoint->decoded_value = &(value->whitePoint); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->whitePoint); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxLuminance)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minLuminance)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxContentLightLevel)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxFrameAverageLightLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapDeferred)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* 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->relaxedLineRasterization)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsampledLoads)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsampledCoarseReconstructionEarlyAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubsampledArrayLayers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetSubsampledSamplers)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIOSSurfaceCreateInfoMVK* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkIOSSurfaceCreateInfoMVK* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pView)); - value->pView = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapDeferred)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMacOSSurfaceCreateInfoMVK* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMacOSSurfaceCreateInfoMVK* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pView)); - value->pView = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsampledLoads)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsampledCoarseReconstructionEarlyAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubsampledArrayLayers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetSubsampledSamplers)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsLabelEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyCommandTransformInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugUtilsLabelEXT* value = wrapper->decoded_value; + VkCopyCommandTransformInfoQCOM* 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->pLabelName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pLabelName = wrapper->pLabelName.GetPointer(); - wrapper->color.SetExternalMemory(value->color, 4); - bytes_read += wrapper->color.DecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transform)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsObjectNameInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyCommandTransformInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugUtilsObjectNameInfoEXT* value = wrapper->decoded_value; + VkCopyCommandTransformInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->objectHandle)); - value->objectHandle = 0; - bytes_read += wrapper->pObjectName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pObjectName = wrapper->pObjectName.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->transform)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsMessengerCallbackDataEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugUtilsMessengerCallbackDataEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImageCompressionControlFeaturesEXT* 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 += wrapper->pMessageIdName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pMessageIdName = wrapper->pMessageIdName.GetPointer(); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->messageIdNumber)); - bytes_read += wrapper->pMessage.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pMessage = wrapper->pMessage.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueLabelCount)); - wrapper->pQueueLabels = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pQueueLabels->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pQueueLabels = wrapper->pQueueLabels->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cmdBufLabelCount)); - wrapper->pCmdBufLabels = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pCmdBufLabels->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCmdBufLabels = wrapper->pCmdBufLabels->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectCount)); - wrapper->pObjects = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pObjects->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pObjects = wrapper->pObjects->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCompressionControl)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsMessengerCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCompressionControlEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugUtilsMessengerCreateInfoEXT* value = wrapper->decoded_value; + VkImageCompressionControlEXT* 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->messageSeverity)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->messageType)); - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnUserCallback)); - value->pfnUserCallback = nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pUserData)); - value->pUserData = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->compressionControlPlaneCount)); + bytes_read += wrapper->pFixedRateFlags.DecodeFlags((buffer + bytes_read), (buffer_size - bytes_read)); + value->pFixedRateFlags = wrapper->pFixedRateFlags.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugUtilsObjectTagInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCompressionPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDebugUtilsObjectTagInfoEXT* value = wrapper->decoded_value; + VkImageCompressionPropertiesEXT* 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->objectHandle)); - value->objectHandle = 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCompressionFlags)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCompressionFixedRateFlags)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferUsageANDROID* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAndroidHardwareBufferUsageANDROID* value = wrapper->decoded_value; + VkPhysicalDeviceImageCompressionControlFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->androidHardwareBufferUsage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCompressionControl)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferPropertiesANDROID* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCompressionControlEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAndroidHardwareBufferPropertiesANDROID* value = wrapper->decoded_value; + VkImageCompressionControlEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->allocationSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryTypeBits)); + 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->compressionControlPlaneCount)); + bytes_read += wrapper->pFixedRateFlags.PreloadDecodeFlags((buffer + bytes_read), (buffer_size - bytes_read)); + value->pFixedRateFlags = wrapper->pFixedRateFlags.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatPropertiesANDROID* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCompressionPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAndroidHardwareBufferFormatPropertiesANDROID* value = wrapper->decoded_value; + VkImageCompressionPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->format)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormat)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatFeatures)); - wrapper->samplerYcbcrConversionComponents = DecodeAllocator::Allocate(); - wrapper->samplerYcbcrConversionComponents->decoded_value = &(value->samplerYcbcrConversionComponents); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->samplerYcbcrConversionComponents); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrModel)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrRange)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedXChromaOffset)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYChromaOffset)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCompressionFlags)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCompressionFixedRateFlags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportAndroidHardwareBufferInfoANDROID* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportAndroidHardwareBufferInfoANDROID* value = wrapper->decoded_value; + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* 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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); - value->buffer = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentFeedbackLoopLayout)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetAndroidHardwareBufferInfoANDROID* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryGetAndroidHardwareBufferInfoANDROID* value = wrapper->decoded_value; + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentFeedbackLoopLayout)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalFormatANDROID* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevice4444FormatsFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalFormatANDROID* value = wrapper->decoded_value; + VkPhysicalDevice4444FormatsFeaturesEXT* 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->externalFormat)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatA4R4G4B4)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatA4B4G4R4)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatProperties2ANDROID* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevice4444FormatsFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAndroidHardwareBufferFormatProperties2ANDROID* value = wrapper->decoded_value; + VkPhysicalDevice4444FormatsFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->format)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormat)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatFeatures)); - wrapper->samplerYcbcrConversionComponents = DecodeAllocator::Allocate(); - wrapper->samplerYcbcrConversionComponents->decoded_value = &(value->samplerYcbcrConversionComponents); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->samplerYcbcrConversionComponents); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrModel)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYcbcrRange)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedXChromaOffset)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->suggestedYChromaOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatA4R4G4B4)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatA4B4G4R4)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSampleLocationEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFaultFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSampleLocationEXT* value = wrapper->decoded_value; + VkPhysicalDeviceFaultFeaturesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->x)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->y)); + 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->deviceFault)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceFaultVendorBinary)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSampleLocationsInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultCountsEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSampleLocationsInfoEXT* value = wrapper->decoded_value; + VkDeviceFaultCountsEXT* 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->sampleLocationsPerPixel)); - wrapper->sampleLocationGridSize = DecodeAllocator::Allocate(); - wrapper->sampleLocationGridSize->decoded_value = &(value->sampleLocationGridSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationGridSize); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationsCount)); - wrapper->pSampleLocations = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSampleLocations->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSampleLocations = wrapper->pSampleLocations->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressInfoCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorInfoCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorBinarySize)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAttachmentSampleLocationsEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultAddressInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAttachmentSampleLocationsEXT* value = wrapper->decoded_value; + VkDeviceFaultAddressInfoEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentIndex)); - wrapper->sampleLocationsInfo = DecodeAllocator::Allocate(); - wrapper->sampleLocationsInfo->decoded_value = &(value->sampleLocationsInfo); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationsInfo); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressType)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reportedAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressPrecision)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassSampleLocationsEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultVendorInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubpassSampleLocationsEXT* value = wrapper->decoded_value; + VkDeviceFaultVendorInfoEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassIndex)); - wrapper->sampleLocationsInfo = DecodeAllocator::Allocate(); - wrapper->sampleLocationsInfo->decoded_value = &(value->sampleLocationsInfo); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationsInfo); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorFaultCode)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorFaultData)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassSampleLocationsBeginInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassSampleLocationsBeginInfoEXT* value = wrapper->decoded_value; + VkDeviceFaultInfoEXT* 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->attachmentInitialSampleLocationsCount)); - wrapper->pAttachmentInitialSampleLocations = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pAttachmentInitialSampleLocations->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAttachmentInitialSampleLocations = wrapper->pAttachmentInitialSampleLocations->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->postSubpassSampleLocationsCount)); - wrapper->pPostSubpassSampleLocations = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pPostSubpassSampleLocations->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPostSubpassSampleLocations = wrapper->pPostSubpassSampleLocations->GetPointer(); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pAddressInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pAddressInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAddressInfos = wrapper->pAddressInfos->GetPointer(); + wrapper->pVendorInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pVendorInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVendorInfos = wrapper->pVendorInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pVendorBinaryData)); + value->pVendorBinaryData = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineSampleLocationsStateCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultVendorBinaryHeaderVersionOneEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineSampleLocationsStateCreateInfoEXT* value = wrapper->decoded_value; + VkDeviceFaultVendorBinaryHeaderVersionOneEXT* 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->sampleLocationsEnable)); - wrapper->sampleLocationsInfo = DecodeAllocator::Allocate(); - wrapper->sampleLocationsInfo->decoded_value = &(value->sampleLocationsInfo); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->sampleLocationsInfo); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->headerSize)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->headerVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverVersion)); + wrapper->pipelineCacheUUID.SetExternalMemory(value->pipelineCacheUUID, VK_UUID_SIZE); + bytes_read += wrapper->pipelineCacheUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->applicationNameOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->applicationVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->engineNameOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->engineVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->apiVersion)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSampleLocationsPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFaultFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSampleLocationsPropertiesEXT* 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->sampleLocationSampleCounts)); - wrapper->maxSampleLocationGridSize = DecodeAllocator::Allocate(); - wrapper->maxSampleLocationGridSize->decoded_value = &(value->maxSampleLocationGridSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSampleLocationGridSize); - wrapper->sampleLocationCoordinateRange.SetExternalMemory(value->sampleLocationCoordinateRange, 2); - bytes_read += wrapper->sampleLocationCoordinateRange.DecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationSubPixelBits)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->variableSampleLocations)); + VkPhysicalDeviceFaultFeaturesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->deviceFault)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceFaultVendorBinary)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultisamplePropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultCountsEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMultisamplePropertiesEXT* value = wrapper->decoded_value; + VkDeviceFaultCountsEXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->maxSampleLocationGridSize = DecodeAllocator::Allocate(); - wrapper->maxSampleLocationGridSize->decoded_value = &(value->maxSampleLocationGridSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxSampleLocationGridSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressInfoCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorInfoCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorBinarySize)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultAddressInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* value = wrapper->decoded_value; + VkDeviceFaultAddressInfoEXT* 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->advancedBlendCoherentOperations)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressType)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reportedAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressPrecision)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultVendorInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* value = wrapper->decoded_value; + VkDeviceFaultVendorInfoEXT* 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->advancedBlendMaxColorAttachments)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendIndependentBlend)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendNonPremultipliedSrcColor)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendNonPremultipliedDstColor)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendCorrelatedOverlap)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendAllOperations)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorFaultCode)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorFaultData)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineColorBlendAdvancedStateCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineColorBlendAdvancedStateCreateInfoEXT* value = wrapper->decoded_value; + VkDeviceFaultInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->srcPremultiplied)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstPremultiplied)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->blendOverlap)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pAddressInfos = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pAddressInfos->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAddressInfos = wrapper->pAddressInfos->GetPointer(); + wrapper->pVendorInfos = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pVendorInfos->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVendorInfos = wrapper->pVendorInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pVendorBinaryData)); + value->pVendorBinaryData = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCoverageToColorStateCreateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultVendorBinaryHeaderVersionOneEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineCoverageToColorStateCreateInfoNV* value = wrapper->decoded_value; + VkDeviceFaultVendorBinaryHeaderVersionOneEXT* 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->coverageToColorEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageToColorLocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->headerSize)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->headerVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverVersion)); + wrapper->pipelineCacheUUID.SetExternalMemory(value->pipelineCacheUUID, VK_UUID_SIZE); + bytes_read += wrapper->pipelineCacheUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->applicationNameOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->applicationVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->engineNameOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->engineVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->apiVersion)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCoverageModulationStateCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineCoverageModulationStateCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* 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->coverageModulationMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageModulationTableEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->coverageModulationTableCount)); - bytes_read += wrapper->pCoverageModulationTable.DecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCoverageModulationTable = wrapper->pCoverageModulationTable.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrderColorAttachmentAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrderDepthAttachmentAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrderStencilAttachmentAccess)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* value = wrapper->decoded_value; + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderSMCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderWarpsPerSM)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrderColorAttachmentAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrderDepthAttachmentAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrderStencilAttachmentAccess)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* 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->shaderSMBuiltins)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatRgba10x6WithoutYCbCrSampler)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDrmFormatModifierPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierPlaneCount)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierTilingFeatures)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->formatRgba10x6WithoutYCbCrSampler)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesListEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDirectFBSurfaceCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDrmFormatModifierPropertiesListEXT* value = wrapper->decoded_value; + VkDirectFBSurfaceCreateInfoEXT* 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->drmFormatModifierCount)); - wrapper->pDrmFormatModifierProperties = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDrmFormatModifierProperties->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDrmFormatModifierProperties = wrapper->pDrmFormatModifierProperties->GetPointer(); + 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->dfb)); + value->dfb = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->surface)); + value->surface = nullptr; return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDirectFBSurfaceCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageDrmFormatModifierInfoEXT* value = wrapper->decoded_value; + VkDirectFBSurfaceCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->drmFormatModifier)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sharingMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueFamilyIndexCount)); - bytes_read += wrapper->pQueueFamilyIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pQueueFamilyIndices = wrapper->pQueueFamilyIndices.GetPointer(); + 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->dfb)); + value->dfb = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->surface)); + value->surface = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierListCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageDrmFormatModifierListCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* 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->drmFormatModifierCount)); - bytes_read += wrapper->pDrmFormatModifiers.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDrmFormatModifiers = wrapper->pDrmFormatModifiers.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mutableDescriptorType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierExplicitCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeListEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageDrmFormatModifierExplicitCreateInfoEXT* value = wrapper->decoded_value; + VkMutableDescriptorTypeListEXT* 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->drmFormatModifier)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierPlaneCount)); - wrapper->pPlaneLayouts = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pPlaneLayouts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPlaneLayouts = wrapper->pPlaneLayouts->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorTypeCount)); + bytes_read += wrapper->pDescriptorTypes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDescriptorTypes = wrapper->pDescriptorTypes.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageDrmFormatModifierPropertiesEXT* value = wrapper->decoded_value; + VkMutableDescriptorTypeCreateInfoEXT* 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->drmFormatModifier)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mutableDescriptorTypeListCount)); + wrapper->pMutableDescriptorTypeLists = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pMutableDescriptorTypeLists->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMutableDescriptorTypeLists = wrapper->pMutableDescriptorTypeLists->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierProperties2EXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDrmFormatModifierProperties2EXT* value = wrapper->decoded_value; + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifier)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierPlaneCount)); - bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->drmFormatModifierTilingFeatures)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->mutableDescriptorType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesList2EXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeListEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDrmFormatModifierPropertiesList2EXT* value = wrapper->decoded_value; + VkMutableDescriptorTypeListEXT* 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->drmFormatModifierCount)); - wrapper->pDrmFormatModifierProperties = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDrmFormatModifierProperties->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDrmFormatModifierProperties = wrapper->pDrmFormatModifierProperties->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorTypeCount)); + bytes_read += wrapper->pDescriptorTypes.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDescriptorTypes = wrapper->pDescriptorTypes.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkValidationCacheCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkValidationCacheCreateInfoEXT* value = wrapper->decoded_value; + VkMutableDescriptorTypeCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->initialDataSize)); - bytes_read += wrapper->pInitialData.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); - value->pInitialData = wrapper->pInitialData.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->mutableDescriptorTypeListCount)); + wrapper->pMutableDescriptorTypeLists = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pMutableDescriptorTypeLists->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pMutableDescriptorTypeLists = wrapper->pMutableDescriptorTypeLists->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderModuleValidationCacheCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkShaderModuleValidationCacheCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* 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->validationCache)); - value->validationCache = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexInputDynamicState)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShadingRatePaletteNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDescription2EXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkShadingRatePaletteNV* value = wrapper->decoded_value; + VkVertexInputBindingDescription2EXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRatePaletteEntryCount)); - bytes_read += wrapper->pShadingRatePaletteEntries.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pShadingRatePaletteEntries = wrapper->pShadingRatePaletteEntries.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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputRate)); + 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_VkPipelineViewportShadingRateImageStateCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputAttributeDescription2EXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineViewportShadingRateImageStateCreateInfoNV* value = wrapper->decoded_value; + VkVertexInputAttributeDescription2EXT* 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->shadingRateImageEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportCount)); - wrapper->pShadingRatePalettes = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pShadingRatePalettes->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pShadingRatePalettes = wrapper->pShadingRatePalettes->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->location)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShadingRateImageFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShadingRateImageFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shadingRateImage)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateCoarseSampleOrder)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexInputDynamicState)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShadingRateImagePropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDescription2EXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShadingRateImagePropertiesNV* value = wrapper->decoded_value; + VkVertexInputBindingDescription2EXT* 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->shadingRateTexelSize = DecodeAllocator::Allocate(); - wrapper->shadingRateTexelSize->decoded_value = &(value->shadingRateTexelSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->shadingRateTexelSize); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRatePaletteSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRateMaxCoarseSamples)); + bytes_read += PreloadDecodePNextStruct((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->binding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputRate)); + 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_VkCoarseSampleLocationNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputAttributeDescription2EXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCoarseSampleLocationNV* value = wrapper->decoded_value; + VkVertexInputAttributeDescription2EXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pixelX)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pixelY)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sample)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->location)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCoarseSampleOrderCustomNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDrmPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCoarseSampleOrderCustomNV* value = wrapper->decoded_value; + VkPhysicalDeviceDrmPropertiesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRate)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampleLocationCount)); - wrapper->pSampleLocations = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSampleLocations->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSampleLocations = wrapper->pSampleLocations->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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasPrimary)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasRender)); + bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primaryMajor)); + bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primaryMinor)); + bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderMajor)); + bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderMinor)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDrmPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceDrmPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->sampleOrderType)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->customSampleOrderCount)); - wrapper->pCustomSampleOrders = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pCustomSampleOrders->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCustomSampleOrders = wrapper->pCustomSampleOrders->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasPrimary)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasRender)); + bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primaryMajor)); + bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primaryMinor)); + bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderMajor)); + bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderMinor)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRayTracingShaderGroupCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAddressBindingReportFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRayTracingShaderGroupCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceAddressBindingReportFeaturesEXT* 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->type)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->generalShader)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->closestHitShader)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->anyHitShader)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->intersectionShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reportAddressBinding)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRayTracingPipelineCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceAddressBindingCallbackDataEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRayTracingPipelineCreateInfoNV* value = wrapper->decoded_value; + VkDeviceAddressBindingCallbackDataEXT* 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->stageCount)); - wrapper->pStages = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStages->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStages = wrapper->pStages->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupCount)); - wrapper->pGroups = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pGroups->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pGroups = wrapper->pGroups->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRecursionDepth)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); - value->layout = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->basePipelineHandle)); - value->basePipelineHandle = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->basePipelineIndex)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->bindingType)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryTrianglesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAddressBindingReportFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGeometryTrianglesNV* value = wrapper->decoded_value; + VkPhysicalDeviceAddressBindingReportFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->vertexData)); - value->vertexData = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexCount)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexStride)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexFormat)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indexData)); - value->indexData = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexCount)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->transformData)); - value->transformData = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reportAddressBinding)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryAABBNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceAddressBindingCallbackDataEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGeometryAABBNV* value = wrapper->decoded_value; + VkDeviceAddressBindingCallbackDataEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->aabbData)); - value->aabbData = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numAABBs)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + 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->baseAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->bindingType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryDataNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipControlFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGeometryDataNV* value = wrapper->decoded_value; + VkPhysicalDeviceDepthClipControlFeaturesEXT* value = wrapper->decoded_value; - wrapper->triangles = DecodeAllocator::Allocate(); - wrapper->triangles->decoded_value = &(value->triangles); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->triangles); - wrapper->aabbs = DecodeAllocator::Allocate(); - wrapper->aabbs->decoded_value = &(value->aabbs); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->aabbs); + 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->depthClipControl)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeometryNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportDepthClipControlCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGeometryNV* value = wrapper->decoded_value; + VkPipelineViewportDepthClipControlCreateInfoEXT* 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->geometryType)); - wrapper->geometry = DecodeAllocator::Allocate(); - wrapper->geometry->decoded_value = &(value->geometry); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->geometry); - 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->negativeOneToOne)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipControlFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceDepthClipControlFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->type)); - 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->instanceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryCount)); - wrapper->pGeometries = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pGeometries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pGeometries = wrapper->pGeometries->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthClipControl)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureCreateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportDepthClipControlCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureCreateInfoNV* value = wrapper->decoded_value; + VkPipelineViewportDepthClipControlCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->compactedSize)); - wrapper->info = DecodeAllocator::Allocate(); - wrapper->info->decoded_value = &(value->info); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->info); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->negativeOneToOne)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindAccelerationStructureMemoryInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindAccelerationStructureMemoryInfoNV* value = wrapper->decoded_value; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* 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->accelerationStructure)); - value->accelerationStructure = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->memory)); - value->memory = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceIndexCount)); - bytes_read += wrapper->pDeviceIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDeviceIndices = wrapper->pDeviceIndices.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveTopologyListRestart)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveTopologyPatchListRestart)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetAccelerationStructureNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkWriteDescriptorSetAccelerationStructureNV* value = wrapper->decoded_value; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->accelerationStructureCount)); - bytes_read += wrapper->pAccelerationStructures.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAccelerationStructures = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveTopologyListRestart)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveTopologyPatchListRestart)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureMemoryRequirementsInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryZirconHandleInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureMemoryRequirementsInfoNV* value = wrapper->decoded_value; + VkImportMemoryZirconHandleInfoFUCHSIA* 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->type)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->accelerationStructure)); - value->accelerationStructure = 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->handle)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPropertiesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryZirconHandlePropertiesFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRayTracingPropertiesNV* value = wrapper->decoded_value; + VkMemoryZirconHandlePropertiesFUCHSIA* 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->shaderGroupHandleSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRecursionDepth)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxShaderGroupStride)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderGroupBaseAlignment)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGeometryCount)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInstanceCount)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTriangleCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetAccelerationStructures)); + 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_VkTransformMatrixKHR* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetZirconHandleInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkTransformMatrixKHR* value = wrapper->decoded_value; + VkMemoryGetZirconHandleInfoFUCHSIA* value = wrapper->decoded_value; - wrapper->matrix.SetExternalMemory(value->matrix, 3, 4); - bytes_read += wrapper->matrix.DecodeFloat((buffer + bytes_read), (buffer_size - bytes_read)); + 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)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAabbPositionsKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryZirconHandleInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAabbPositionsKHR* value = wrapper->decoded_value; + VkImportMemoryZirconHandleInfoFUCHSIA* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minX)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minY)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minZ)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxX)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxY)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxZ)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->handle)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureInstanceKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryZirconHandlePropertiesFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureInstanceKHR* value = wrapper->decoded_value; + VkMemoryZirconHandlePropertiesFUCHSIA* value = wrapper->decoded_value; - wrapper->transform = DecodeAllocator::Allocate(); - wrapper->transform->decoded_value = &(value->transform); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transform); - uint32_t temp_instanceCustomIndex; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceCustomIndex); - value->instanceCustomIndex = temp_instanceCustomIndex; - uint32_t temp_mask; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mask); - value->mask = temp_mask; - uint32_t temp_instanceShaderBindingTableRecordOffset; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceShaderBindingTableRecordOffset); - value->instanceShaderBindingTableRecordOffset = temp_instanceShaderBindingTableRecordOffset; - VkGeometryInstanceFlagsKHR temp_flags; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &temp_flags); - value->flags = temp_flags; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureReference)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetZirconHandleInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* value = wrapper->decoded_value; + VkMemoryGetZirconHandleInfoFUCHSIA* 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)); + bytes_read += PreloadDecodePNextStruct((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->representativeFragmentTest)); + 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_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportSemaphoreZirconHandleInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRepresentativeFragmentTestStateCreateInfoNV* value = wrapper->decoded_value; + VkImportSemaphoreZirconHandleInfoFUCHSIA* 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->representativeFragmentTestEnable)); + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->zirconHandle)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewImageFormatInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetZirconHandleInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageViewImageFormatInfoEXT* value = wrapper->decoded_value; + VkSemaphoreGetZirconHandleInfoFUCHSIA* 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->imageViewType)); + 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_VkFilterCubicImageViewImageFormatPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportSemaphoreZirconHandleInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFilterCubicImageViewImageFormatPropertiesEXT* value = wrapper->decoded_value; + VkImportSemaphoreZirconHandleInfoFUCHSIA* 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)); + bytes_read += PreloadDecodePNextStruct((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->filterCubic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->filterCubicMinmax)); + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->zirconHandle)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryHostPointerInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetZirconHandleInfoFUCHSIA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportMemoryHostPointerInfoEXT* value = wrapper->decoded_value; + VkSemaphoreGetZirconHandleInfoFUCHSIA* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pHostPointer)); - value->pHostPointer = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryHostPointerPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryHostPointerPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->invocationMask)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExternalMemoryHostPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* 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)); + bytes_read += PreloadDecodePNextStruct((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->minImportedHostPointerAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->invocationMask)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCompilerControlCreateInfoAMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetRemoteAddressInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineCompilerControlCreateInfoAMD* value = wrapper->decoded_value; + VkMemoryGetRemoteAddressInfoNV* 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->compilerControlFlags)); + 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_VkPhysicalDeviceShaderCorePropertiesAMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderCorePropertiesAMD* value = wrapper->decoded_value; + VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* 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->shaderEngineCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderArraysPerEngineCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeUnitsPerShaderArray)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->simdPerComputeUnit)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->wavefrontsPerSimd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->wavefrontSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sgprsPerSimd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSgprAllocation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSgprAllocation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sgprAllocationGranularity)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vgprsPerSimd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minVgprAllocation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVgprAllocation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vgprAllocationGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalMemoryRDMA)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceMemoryOverallocationCreateInfoAMD* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetRemoteAddressInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceMemoryOverallocationCreateInfoAMD* value = wrapper->decoded_value; + VkMemoryGetRemoteAddressInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->overallocationBehavior)); + 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_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalMemoryRDMA)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentFrameTokenGGP* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFrameBoundaryFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPresentFrameTokenGGP* value = wrapper->decoded_value; + VkPhysicalDeviceFrameBoundaryFeaturesEXT* 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->frameToken)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameBoundary)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFrameBoundaryEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* value = wrapper->decoded_value; + VkFrameBoundaryEXT* 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->computeDerivativeGroupQuads)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->computeDerivativeGroupLinear)); + 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->frameID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCount)); + bytes_read += wrapper->pImages.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImages = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferCount)); + bytes_read += wrapper->pBuffers.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBuffers = nullptr; + 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_VkPhysicalDeviceMeshShaderFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFrameBoundaryFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMeshShaderFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceFrameBoundaryFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->taskShader)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->frameBoundary)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFrameBoundaryEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMeshShaderPropertiesNV* value = wrapper->decoded_value; + VkFrameBoundaryEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxDrawMeshTasksCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskWorkGroupInvocations)); - wrapper->maxTaskWorkGroupSize.SetExternalMemory(value->maxTaskWorkGroupSize, 3); - bytes_read += wrapper->maxTaskWorkGroupSize.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskTotalMemorySize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskOutputCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshWorkGroupInvocations)); - wrapper->maxMeshWorkGroupSize.SetExternalMemory(value->maxMeshWorkGroupSize, 3); - bytes_read += wrapper->maxMeshWorkGroupSize.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshTotalMemorySize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputVertices)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputPrimitives)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshMultiviewViewCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshOutputPerVertexGranularity)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshOutputPerPrimitiveGranularity)); + 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->frameID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCount)); + bytes_read += wrapper->pImages.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pImages = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferCount)); + bytes_read += wrapper->pBuffers.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pBuffers = nullptr; + 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.PreloadDecodeVoid((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_VkDrawMeshTasksIndirectCommandNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDrawMeshTasksIndirectCommandNV* value = wrapper->decoded_value; + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->taskCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstTask)); + 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->multisampledRenderToSingleSampled)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderImageFootprintFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassResolvePerformanceQueryEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderImageFootprintFeaturesNV* value = wrapper->decoded_value; + VkSubpassResolvePerformanceQueryEXT* 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->imageFootprint)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimal)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportExclusiveScissorStateCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultisampledRenderToSingleSampledInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineViewportExclusiveScissorStateCreateInfoNV* value = wrapper->decoded_value; + VkMultisampledRenderToSingleSampledInfoEXT* 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->exclusiveScissorCount)); - wrapper->pExclusiveScissors = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pExclusiveScissors->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pExclusiveScissors = wrapper->pExclusiveScissors->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multisampledRenderToSingleSampledEnable)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationSamples)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExclusiveScissorFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExclusiveScissorFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->exclusiveScissor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multisampledRenderToSingleSampled)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassResolvePerformanceQueryEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueueFamilyCheckpointPropertiesNV* value = wrapper->decoded_value; + VkSubpassResolvePerformanceQueryEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->checkpointExecutionStageMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->optimal)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCheckpointDataNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultisampledRenderToSingleSampledInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCheckpointDataNV* value = wrapper->decoded_value; + VkMultisampledRenderToSingleSampledInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->stage)); - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pCheckpointMarker)); - value->pCheckpointMarker = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multisampledRenderToSingleSampledEnable)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationSamples)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* 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->shaderIntegerFunctions2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState2LogicOp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState2PatchControlPoints)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkInitializePerformanceApiInfoINTEL* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkInitializePerformanceApiInfoINTEL* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pUserData)); - value->pUserData = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState2LogicOp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState2PatchControlPoints)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryPoolPerformanceQueryCreateInfoINTEL* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkScreenSurfaceCreateInfoQNX* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueryPoolPerformanceQueryCreateInfoINTEL* value = wrapper->decoded_value; + VkScreenSurfaceCreateInfoQNX* 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->performanceCountersSampling)); + 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->context)); + value->context = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->window)); + value->window = nullptr; return bytes_read; } +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkScreenSurfaceCreateInfoQNX* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceMarkerInfoINTEL* wrapper) + size_t bytes_read = 0; + VkScreenSurfaceCreateInfoQNX* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->context)); + value->context = nullptr; + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->window)); + value->window = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceColorWriteEnableFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceMarkerInfoINTEL* value = wrapper->decoded_value; + VkPhysicalDeviceColorWriteEnableFeaturesEXT* 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->marker)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorWriteEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceStreamMarkerInfoINTEL* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineColorWriteCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceStreamMarkerInfoINTEL* value = wrapper->decoded_value; + VkPipelineColorWriteCreateInfoEXT* 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->marker)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentCount)); + bytes_read += wrapper->pColorWriteEnables.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorWriteEnables = wrapper->pColorWriteEnables.GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceOverrideInfoINTEL* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceColorWriteEnableFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceOverrideInfoINTEL* value = wrapper->decoded_value; + VkPhysicalDeviceColorWriteEnableFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->type)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enable)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->parameter)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorWriteEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPerformanceConfigurationAcquireInfoINTEL* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineColorWriteCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPerformanceConfigurationAcquireInfoINTEL* value = wrapper->decoded_value; + VkPipelineColorWriteCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentCount)); + bytes_read += wrapper->pColorWriteEnables.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + value->pColorWriteEnables = wrapper->pColorWriteEnables.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePCIBusInfoPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePCIBusInfoPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* 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->pciDomain)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciBus)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciDevice)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pciFunction)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitivesGeneratedQuery)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitivesGeneratedQueryWithRasterizerDiscard)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitivesGeneratedQueryWithNonZeroStreams)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDisplayNativeHdrSurfaceCapabilitiesAMD* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDisplayNativeHdrSurfaceCapabilitiesAMD* value = wrapper->decoded_value; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->localDimmingSupport)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitivesGeneratedQuery)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitivesGeneratedQueryWithRasterizerDiscard)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitivesGeneratedQueryWithNonZeroStreams)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainDisplayNativeHdrCreateInfoAMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewMinLodFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSwapchainDisplayNativeHdrCreateInfoAMD* value = wrapper->decoded_value; + VkPhysicalDeviceImageViewMinLodFeaturesEXT* 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->localDimmingEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minLod)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImagePipeSurfaceCreateInfoFUCHSIA* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewMinLodCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImagePipeSurfaceCreateInfoFUCHSIA* value = wrapper->decoded_value; + VkImageViewMinLodCreateInfoEXT* 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->imagePipeHandle)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minLod)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMetalSurfaceCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewMinLodFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMetalSurfaceCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImageViewMinLodFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pLayer)); - value->pLayer = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minLod)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewMinLodCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentDensityMapFeaturesEXT* value = wrapper->decoded_value; + VkImageViewMinLodCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->fragmentDensityMap)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapDynamic)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapNonSubsampledImages)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minLod)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiDrawFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentDensityMapPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceMultiDrawFeaturesEXT* 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->minFragmentDensityTexelSize = DecodeAllocator::Allocate(); - wrapper->minFragmentDensityTexelSize->decoded_value = &(value->minFragmentDensityTexelSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minFragmentDensityTexelSize); - wrapper->maxFragmentDensityTexelSize = DecodeAllocator::Allocate(); - wrapper->maxFragmentDensityTexelSize->decoded_value = &(value->maxFragmentDensityTexelSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxFragmentDensityTexelSize); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityInvocations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiDraw)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassFragmentDensityMapCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiDrawPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassFragmentDensityMapCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceMultiDrawPropertiesEXT* 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->fragmentDensityMapAttachment = DecodeAllocator::Allocate(); - wrapper->fragmentDensityMapAttachment->decoded_value = &(value->fragmentDensityMapAttachment); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentDensityMapAttachment); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiDrawCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreProperties2AMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiDrawInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderCoreProperties2AMD* value = wrapper->decoded_value; + VkMultiDrawInfoEXT* 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->shaderCoreFeatures)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->activeComputeUnitCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstVertex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCoherentMemoryFeaturesAMD* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiDrawIndexedInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCoherentMemoryFeaturesAMD* value = wrapper->decoded_value; + VkMultiDrawIndexedInfoEXT* 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->deviceCoherentMemory)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexCount)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexOffset)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiDrawFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceMultiDrawFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderImageInt64Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageInt64Atomics)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiDraw)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryBudgetPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiDrawPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMemoryBudgetPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceMultiDrawPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->heapBudget.SetExternalMemory(value->heapBudget, VK_MAX_MEMORY_HEAPS); - bytes_read += wrapper->heapBudget.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->heapUsage.SetExternalMemory(value->heapUsage, VK_MAX_MEMORY_HEAPS); - bytes_read += wrapper->heapUsage.DecodeUInt64((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMultiDrawCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryPriorityFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiDrawInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMemoryPriorityFeaturesEXT* value = wrapper->decoded_value; + VkMultiDrawInfoEXT* 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->memoryPriority)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstVertex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryPriorityAllocateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiDrawIndexedInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryPriorityAllocateInfoEXT* value = wrapper->decoded_value; + VkMultiDrawIndexedInfoEXT* 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::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->priority)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexCount)); + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* 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->dedicatedAllocationImageAliasing)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->image2DViewOf3D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampler2DViewOf3D)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->bufferDeviceAddress)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressCaptureReplay)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferDeviceAddressMultiDevice)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->image2DViewOf3D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampler2DViewOf3D)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBufferDeviceAddressCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTileImageFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBufferDeviceAddressCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderTileImageFeaturesEXT* 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->deviceAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageColorReadAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageDepthReadAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageStencilReadAccess)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkValidationFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTileImagePropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkValidationFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderTileImagePropertiesEXT* 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->enabledValidationFeatureCount)); - bytes_read += wrapper->pEnabledValidationFeatures.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pEnabledValidationFeatures = wrapper->pEnabledValidationFeatures.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->disabledValidationFeatureCount)); - bytes_read += wrapper->pDisabledValidationFeatures.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDisabledValidationFeatures = wrapper->pDisabledValidationFeatures.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageCoherentReadAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageReadSampleFromPixelRateInvocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageReadFromHelperInvocation)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCooperativeMatrixPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTileImageFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCooperativeMatrixPropertiesNV* value = wrapper->decoded_value; + VkPhysicalDeviceShaderTileImageFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->DType)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->scope)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageColorReadAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageDepthReadAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageStencilReadAccess)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTileImagePropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCooperativeMatrixFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceShaderTileImagePropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->cooperativeMatrix)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cooperativeMatrixRobustBufferAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageCoherentReadAccelerated)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageReadSampleFromPixelRateInvocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageReadFromHelperInvocation)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapUsageEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCooperativeMatrixPropertiesNV* value = wrapper->decoded_value; + VkMicromapUsageEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->count)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subdivisionLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCoverageReductionModeFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapBuildInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCoverageReductionModeFeaturesNV* value = wrapper->decoded_value; + VkMicromapBuildInfoEXT* 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->coverageReductionMode)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + 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->mode)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstMicromap)); + value->dstMicromap = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usageCountsCount)); + wrapper->pUsageCounts = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pUsageCounts = wrapper->pUsageCounts->GetPointer(); + wrapper->ppUsageCounts = DecodeAllocator::Allocate>(); + bytes_read += wrapper->ppUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppUsageCounts = wrapper->ppUsageCounts->GetPointer(); + wrapper->data = DecodeAllocator::Allocate(); + wrapper->data->decoded_value = &(value->data); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data); + wrapper->scratchData = DecodeAllocator::Allocate(); + wrapper->scratchData->decoded_value = &(value->scratchData); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->scratchData); + wrapper->triangleArray = DecodeAllocator::Allocate(); + wrapper->triangleArray->decoded_value = &(value->triangleArray); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->triangleArray); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triangleArrayStride)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineCoverageReductionStateCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineCoverageReductionStateCreateInfoNV* value = wrapper->decoded_value; + VkMicromapCreateInfoEXT* 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->coverageReductionMode)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->createFlags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFramebufferMixedSamplesCombinationNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpacityMicromapFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFramebufferMixedSamplesCombinationNV* value = wrapper->decoded_value; + VkPhysicalDeviceOpacityMicromapFeaturesEXT* 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->coverageReductionMode)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationSamples)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilSamples)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorSamples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromap)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromapCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromapHostCommands)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpacityMicromapPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceOpacityMicromapPropertiesEXT* 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->fragmentShaderSampleInterlock)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderPixelInterlock)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentShaderShadingRateInterlock)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxOpacity2StateSubdivisionLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxOpacity4StateSubdivisionLevel)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapVersionInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* value = wrapper->decoded_value; + VkMicromapVersionInfoEXT* 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->ycbcrImageArrays)); + bytes_read += wrapper->pVersionData.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVersionData = wrapper->pVersionData.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProvokingVertexFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMicromapToMemoryInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceProvokingVertexFeaturesEXT* value = wrapper->decoded_value; + VkCopyMicromapToMemoryInfoEXT* 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->provokingVertexLast)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackPreservesProvokingVertex)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->src)); + value->src = VK_NULL_HANDLE; + wrapper->dst = DecodeAllocator::Allocate(); + wrapper->dst->decoded_value = &(value->dst); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dst); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProvokingVertexPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMemoryToMicromapInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceProvokingVertexPropertiesEXT* value = wrapper->decoded_value; + VkCopyMemoryToMicromapInfoEXT* 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->provokingVertexModePerPipeline)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformFeedbackPreservesTriangleFanProvokingVertex)); + wrapper->src = DecodeAllocator::Allocate(); + wrapper->src->decoded_value = &(value->src); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->src); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dst)); + value->dst = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMicromapInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* value = wrapper->decoded_value; + VkCopyMicromapInfoEXT* 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->provokingVertexMode)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->src)); + value->src = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dst)); + value->dst = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFullScreenExclusiveInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapBuildSizesInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceFullScreenExclusiveInfoEXT* value = wrapper->decoded_value; + VkMicromapBuildSizesInfoEXT* 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->fullScreenExclusive)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromapSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->buildScratchSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->discardable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesFullScreenExclusiveEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesOpacityMicromapEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceCapabilitiesFullScreenExclusiveEXT* value = wrapper->decoded_value; + VkAccelerationStructureTrianglesOpacityMicromapEXT* 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->fullScreenExclusiveSupported)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); + wrapper->indexBuffer = DecodeAllocator::Allocate(); + wrapper->indexBuffer->decoded_value = &(value->indexBuffer); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->indexBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseTriangle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usageCountsCount)); + wrapper->pUsageCounts = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pUsageCounts = wrapper->pUsageCounts->GetPointer(); + wrapper->ppUsageCounts = DecodeAllocator::Allocate>(); + bytes_read += wrapper->ppUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppUsageCounts = wrapper->ppUsageCounts->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->micromap)); + value->micromap = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceFullScreenExclusiveWin32InfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapTriangleEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceFullScreenExclusiveWin32InfoEXT* value = wrapper->decoded_value; + VkMicromapTriangleEXT* 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::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->hmonitor)); - value->hmonitor = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dataOffset)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subdivisionLevel)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHeadlessSurfaceCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapUsageEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkHeadlessSurfaceCreateInfoEXT* value = wrapper->decoded_value; + VkMicromapUsageEXT* 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->count)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subdivisionLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapBuildInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* value = wrapper->decoded_value; + VkMicromapBuildInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderBufferFloat32Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat32AtomicAdd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat64Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat64AtomicAdd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat32Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat32AtomicAdd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat64Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat64AtomicAdd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageFloat32Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageFloat32AtomicAdd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageFloat32Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageFloat32AtomicAdd)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + 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->mode)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstMicromap)); + value->dstMicromap = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usageCountsCount)); + wrapper->pUsageCounts = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pUsageCounts->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pUsageCounts = wrapper->pUsageCounts->GetPointer(); + wrapper->ppUsageCounts = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->ppUsageCounts->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppUsageCounts = wrapper->ppUsageCounts->GetPointer(); + wrapper->data = PreloadDecodeAllocator::Allocate(); + wrapper->data->decoded_value = &(value->data); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data); + wrapper->scratchData = PreloadDecodeAllocator::Allocate(); + wrapper->scratchData->decoded_value = &(value->scratchData); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->scratchData); + wrapper->triangleArray = PreloadDecodeAllocator::Allocate(); + wrapper->triangleArray->decoded_value = &(value->triangleArray); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->triangleArray); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triangleArrayStride)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* value = wrapper->decoded_value; + VkMicromapCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->extendedDynamicState)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->createFlags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostImageCopyFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpacityMicromapFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceHostImageCopyFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceOpacityMicromapFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->hostImageCopy)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromap)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromapCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromapHostCommands)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostImageCopyPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpacityMicromapPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceHostImageCopyPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceOpacityMicromapPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->copySrcLayoutCount)); - bytes_read += wrapper->pCopySrcLayouts.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCopySrcLayouts = wrapper->pCopySrcLayouts.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->copyDstLayoutCount)); - bytes_read += wrapper->pCopyDstLayouts.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCopyDstLayouts = wrapper->pCopyDstLayouts.GetPointer(); - wrapper->optimalTilingLayoutUUID.SetExternalMemory(value->optimalTilingLayoutUUID, VK_UUID_SIZE); - bytes_read += wrapper->optimalTilingLayoutUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identicalMemoryTypeRequirements)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxOpacity2StateSubdivisionLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxOpacity4StateSubdivisionLevel)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryToImageCopyEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapVersionInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryToImageCopyEXT* value = wrapper->decoded_value; + VkMicromapVersionInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pHostPointer)); - value->pHostPointer = nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryRowLength)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryImageHeight)); - wrapper->imageSubresource = DecodeAllocator::Allocate(); - wrapper->imageSubresource->decoded_value = &(value->imageSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); - wrapper->imageOffset = DecodeAllocator::Allocate(); - wrapper->imageOffset->decoded_value = &(value->imageOffset); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); - wrapper->imageExtent = DecodeAllocator::Allocate(); - wrapper->imageExtent->decoded_value = &(value->imageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + bytes_read += wrapper->pVersionData.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVersionData = wrapper->pVersionData.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageToMemoryCopyEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMicromapToMemoryInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageToMemoryCopyEXT* value = wrapper->decoded_value; + VkCopyMicromapToMemoryInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pHostPointer)); - value->pHostPointer = nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryRowLength)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryImageHeight)); - wrapper->imageSubresource = DecodeAllocator::Allocate(); - wrapper->imageSubresource->decoded_value = &(value->imageSubresource); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageSubresource); - wrapper->imageOffset = DecodeAllocator::Allocate(); - wrapper->imageOffset->decoded_value = &(value->imageOffset); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageOffset); - wrapper->imageExtent = DecodeAllocator::Allocate(); - wrapper->imageExtent->decoded_value = &(value->imageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->imageExtent); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->src)); + value->src = VK_NULL_HANDLE; + wrapper->dst = PreloadDecodeAllocator::Allocate(); + wrapper->dst->decoded_value = &(value->dst); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dst); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMemoryToImageInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMemoryToMicromapInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyMemoryToImageInfoEXT* value = wrapper->decoded_value; + VkCopyMemoryToMicromapInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->dstImage)); - value->dstImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); - wrapper->pRegions = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRegions = wrapper->pRegions->GetPointer(); + wrapper->src = PreloadDecodeAllocator::Allocate(); + wrapper->src->decoded_value = &(value->src); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->src); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dst)); + value->dst = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageToMemoryInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMicromapInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyImageToMemoryInfoEXT* value = wrapper->decoded_value; + VkCopyMicromapInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->srcImage)); - value->srcImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); - wrapper->pRegions = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRegions = wrapper->pRegions->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->src)); + value->src = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dst)); + value->dst = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyImageToImageInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapBuildSizesInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyImageToImageInfoEXT* value = wrapper->decoded_value; + VkMicromapBuildSizesInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->srcImage)); - value->srcImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcImageLayout)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstImage)); - value->dstImage = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstImageLayout)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->regionCount)); - wrapper->pRegions = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRegions->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRegions = wrapper->pRegions->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromapSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->buildScratchSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->discardable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHostImageLayoutTransitionInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesOpacityMicromapEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkHostImageLayoutTransitionInfoEXT* value = wrapper->decoded_value; + VkAccelerationStructureTrianglesOpacityMicromapEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->oldLayout)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->newLayout)); - wrapper->subresourceRange = DecodeAllocator::Allocate(); - wrapper->subresourceRange->decoded_value = &(value->subresourceRange); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->subresourceRange); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); + wrapper->indexBuffer = PreloadDecodeAllocator::Allocate(); + wrapper->indexBuffer->decoded_value = &(value->indexBuffer); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->indexBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseTriangle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usageCountsCount)); + wrapper->pUsageCounts = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pUsageCounts->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pUsageCounts = wrapper->pUsageCounts->GetPointer(); + wrapper->ppUsageCounts = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->ppUsageCounts->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppUsageCounts = wrapper->ppUsageCounts->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->micromap)); + value->micromap = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubresourceHostMemcpySizeEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapTriangleEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubresourceHostMemcpySizeEXT* value = wrapper->decoded_value; + VkMicromapTriangleEXT* 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->size)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dataOffset)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subdivisionLevel)); + bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHostImageCopyDevicePerformanceQueryEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkHostImageCopyDevicePerformanceQueryEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDisplacementMicromapFeaturesNV* 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->optimalDeviceAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identicalMemoryLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementMicromap)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDisplacementMicromapPropertiesNV* 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->memoryMapPlaced)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryMapRangePlaced)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryUnmapReserve)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDisplacementMicromapSubdivisionLevel)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesDisplacementMicromapNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* value = wrapper->decoded_value; + VkAccelerationStructureTrianglesDisplacementMicromapNV* 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->minPlacedMemoryMapAlignment)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementBiasAndScaleFormat)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementVectorFormat)); + wrapper->displacementBiasAndScaleBuffer = DecodeAllocator::Allocate(); + wrapper->displacementBiasAndScaleBuffer->decoded_value = &(value->displacementBiasAndScaleBuffer); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displacementBiasAndScaleBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementBiasAndScaleStride)); + wrapper->displacementVectorBuffer = DecodeAllocator::Allocate(); + wrapper->displacementVectorBuffer->decoded_value = &(value->displacementVectorBuffer); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displacementVectorBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementVectorStride)); + wrapper->displacedMicromapPrimitiveFlags = DecodeAllocator::Allocate(); + wrapper->displacedMicromapPrimitiveFlags->decoded_value = &(value->displacedMicromapPrimitiveFlags); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displacedMicromapPrimitiveFlags); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacedMicromapPrimitiveFlagsStride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); + wrapper->indexBuffer = DecodeAllocator::Allocate(); + wrapper->indexBuffer->decoded_value = &(value->indexBuffer); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->indexBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseTriangle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usageCountsCount)); + wrapper->pUsageCounts = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pUsageCounts = wrapper->pUsageCounts->GetPointer(); + wrapper->ppUsageCounts = DecodeAllocator::Allocate>(); + bytes_read += wrapper->ppUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppUsageCounts = wrapper->ppUsageCounts->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->micromap)); + value->micromap = VK_NULL_HANDLE; return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryMapPlacedInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryMapPlacedInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDisplacementMicromapFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pPlacedAddress)); - value->pPlacedAddress = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementMicromap)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDisplacementMicromapPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderBufferFloat16Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat16AtomicAdd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat16AtomicMinMax)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat32AtomicMinMax)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBufferFloat64AtomicMinMax)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat16Atomics)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat16AtomicAdd)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat16AtomicMinMax)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat32AtomicMinMax)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderSharedFloat64AtomicMinMax)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderImageFloat32AtomicMinMax)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sparseImageFloat32AtomicMinMax)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDisplacementMicromapSubdivisionLevel)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfacePresentModeEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesDisplacementMicromapNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfacePresentModeEXT* value = wrapper->decoded_value; + VkAccelerationStructureTrianglesDisplacementMicromapNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->presentMode)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementBiasAndScaleFormat)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementVectorFormat)); + wrapper->displacementBiasAndScaleBuffer = PreloadDecodeAllocator::Allocate(); + wrapper->displacementBiasAndScaleBuffer->decoded_value = &(value->displacementBiasAndScaleBuffer); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displacementBiasAndScaleBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementBiasAndScaleStride)); + wrapper->displacementVectorBuffer = PreloadDecodeAllocator::Allocate(); + wrapper->displacementVectorBuffer->decoded_value = &(value->displacementVectorBuffer); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displacementVectorBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementVectorStride)); + wrapper->displacedMicromapPrimitiveFlags = PreloadDecodeAllocator::Allocate(); + wrapper->displacedMicromapPrimitiveFlags->decoded_value = &(value->displacedMicromapPrimitiveFlags); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displacedMicromapPrimitiveFlags); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacedMicromapPrimitiveFlagsStride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); + wrapper->indexBuffer = PreloadDecodeAllocator::Allocate(); + wrapper->indexBuffer->decoded_value = &(value->indexBuffer); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->indexBuffer); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseTriangle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usageCountsCount)); + wrapper->pUsageCounts = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pUsageCounts->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pUsageCounts = wrapper->pUsageCounts->GetPointer(); + wrapper->ppUsageCounts = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->ppUsageCounts->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppUsageCounts = wrapper->ppUsageCounts->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->micromap)); + value->micromap = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfacePresentScalingCapabilitiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfacePresentScalingCapabilitiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* 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->supportedPresentScaling)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedPresentGravityX)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedPresentGravityY)); - wrapper->minScaledImageExtent = DecodeAllocator::Allocate(); - wrapper->minScaledImageExtent->decoded_value = &(value->minScaledImageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->minScaledImageExtent); - wrapper->maxScaledImageExtent = DecodeAllocator::Allocate(); - wrapper->maxScaledImageExtent->decoded_value = &(value->maxScaledImageExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxScaledImageExtent); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clustercullingShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewClusterCullingShader)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfacePresentModeCompatibilityEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfacePresentModeCompatibilityEXT* value = wrapper->decoded_value; + VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* 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->presentModeCount)); - bytes_read += wrapper->pPresentModes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPresentModes = wrapper->pPresentModes.GetPointer(); + wrapper->maxWorkGroupCount.SetExternalMemory(value->maxWorkGroupCount, 3); + bytes_read += wrapper->maxWorkGroupCount.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->maxWorkGroupSize.SetExternalMemory(value->maxWorkGroupSize, 3); + bytes_read += wrapper->maxWorkGroupSize.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxOutputClusterCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indirectBufferOffsetAlignment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* 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->swapchainMaintenance1)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clusterShadingRate)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentFenceInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSwapchainPresentFenceInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* 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)); + bytes_read += PreloadDecodePNextStruct((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->pFences.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pFences = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clustercullingShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewClusterCullingShader)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentModesCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSwapchainPresentModesCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* 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)); + bytes_read += PreloadDecodePNextStruct((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->presentModeCount)); - bytes_read += wrapper->pPresentModes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPresentModes = wrapper->pPresentModes.GetPointer(); + wrapper->maxWorkGroupCount.SetExternalMemory(value->maxWorkGroupCount, 3); + bytes_read += wrapper->maxWorkGroupCount.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->maxWorkGroupSize.SetExternalMemory(value->maxWorkGroupSize, 3); + bytes_read += wrapper->maxWorkGroupSize.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxOutputClusterCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indirectBufferOffsetAlignment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentModeInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSwapchainPresentModeInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* 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)); + bytes_read += PreloadDecodePNextStruct((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->pPresentModes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPresentModes = wrapper->pPresentModes.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clusterShadingRate)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentScalingCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSwapchainPresentScalingCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* 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->scalingBehavior)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentGravityX)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentGravityY)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->borderColorSwizzle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->borderColorSwizzleFromImage)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkReleaseSwapchainImagesInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerBorderColorComponentMappingCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkReleaseSwapchainImagesInfoEXT* value = wrapper->decoded_value; + VkSamplerBorderColorComponentMappingCreateInfoEXT* 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->swapchain)); - value->swapchain = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageIndexCount)); - bytes_read += wrapper->pImageIndices.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pImageIndices = wrapper->pImageIndices.GetPointer(); + wrapper->components = DecodeAllocator::Allocate(); + wrapper->components->decoded_value = &(value->components); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->components); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srgb)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* value = wrapper->decoded_value; + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxGraphicsShaderGroupCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectSequenceCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsTokenCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsStreamCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsTokenOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsStreamStride)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSequencesCountBufferOffsetAlignment)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minSequencesIndexBufferOffsetAlignment)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minIndirectCommandsBufferOffsetAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->borderColorSwizzle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->borderColorSwizzleFromImage)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerBorderColorComponentMappingCreateInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkSamplerBorderColorComponentMappingCreateInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->components = PreloadDecodeAllocator::Allocate(); + wrapper->components->decoded_value = &(value->components); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->components); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srgb)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* 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->deviceGeneratedCommands)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pageableDeviceLocalMemory)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGraphicsShaderGroupCreateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGraphicsShaderGroupCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->stageCount)); - wrapper->pStages = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStages->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStages = wrapper->pStages->GetPointer(); - wrapper->pVertexInputState = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pVertexInputState->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pVertexInputState = wrapper->pVertexInputState->GetPointer(); - wrapper->pTessellationState = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pTessellationState->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pTessellationState = wrapper->pTessellationState->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pageableDeviceLocalMemory)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGraphicsPipelineShaderGroupsCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGraphicsPipelineShaderGroupsCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCorePropertiesARM* 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->groupCount)); - wrapper->pGroups = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pGroups->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pGroups = wrapper->pGroups->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineCount)); - bytes_read += wrapper->pPipelines.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPipelines = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pixelRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->texelRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fmaRate)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindShaderGroupIndirectCommandNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindShaderGroupIndirectCommandNV* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCorePropertiesARM* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupIndex)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pixelRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->texelRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fmaRate)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindIndexBufferIndirectCommandNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindIndexBufferIndirectCommandNV* value = wrapper->decoded_value; + VkDeviceQueueShaderCoreControlCreateInfoARM* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferAddress)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); + 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->shaderCoreCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindVertexBufferIndirectCommandNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindVertexBufferIndirectCommandNV* value = wrapper->decoded_value; + VkPhysicalDeviceSchedulingControlsFeaturesARM* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferAddress)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + 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->schedulingControls)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSetStateFlagsIndirectCommandNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSetStateFlagsIndirectCommandNV* value = wrapper->decoded_value; + VkPhysicalDeviceSchedulingControlsPropertiesARM* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->data)); + 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->schedulingControlsFlags)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsStreamNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkIndirectCommandsStreamNV* value = wrapper->decoded_value; + VkDeviceQueueShaderCoreControlCreateInfoARM* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); - value->buffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderCoreCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutTokenNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkIndirectCommandsLayoutTokenNV* value = wrapper->decoded_value; + VkPhysicalDeviceSchedulingControlsFeaturesARM* 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)); + bytes_read += PreloadDecodePNextStruct((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->tokenType)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stream)); - 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->vertexBindingUnit)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexDynamicStride)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pushconstantPipelineLayout)); - value->pushconstantPipelineLayout = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushconstantShaderStageFlags)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushconstantOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushconstantSize)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indirectStateFlags)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexTypeCount)); - bytes_read += wrapper->pIndexTypes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pIndexTypes = wrapper->pIndexTypes.GetPointer(); - bytes_read += wrapper->pIndexTypeValues.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pIndexTypeValues = wrapper->pIndexTypeValues.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->schedulingControls)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutCreateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkIndirectCommandsLayoutCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceSchedulingControlsPropertiesARM* 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)); + bytes_read += PreloadDecodePNextStruct((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->pipelineBindPoint)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tokenCount)); - wrapper->pTokens = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pTokens->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pTokens = wrapper->pTokens->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->streamCount)); - bytes_read += wrapper->pStreamStrides.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStreamStrides = wrapper->pStreamStrides.GetPointer(); + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->schedulingControlsFlags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeneratedCommandsInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGeneratedCommandsInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* 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->pipelineBindPoint)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); - value->pipeline = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectCommandsLayout)); - value->indirectCommandsLayout = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->streamCount)); - wrapper->pStreams = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStreams->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStreams = wrapper->pStreams->GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequencesCount)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->preprocessBuffer)); - value->preprocessBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preprocessOffset)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preprocessSize)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->sequencesCountBuffer)); - value->sequencesCountBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequencesCountOffset)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->sequencesIndexBuffer)); - value->sequencesIndexBuffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequencesIndexOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageSlicedViewOf3D)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeneratedCommandsMemoryRequirementsInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewSlicedCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGeneratedCommandsMemoryRequirementsInfoNV* value = wrapper->decoded_value; + VkImageViewSlicedCreateInfoEXT* 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->pipelineBindPoint)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); - value->pipeline = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectCommandsLayout)); - value->indirectCommandsLayout = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSequencesCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sliceOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sliceCount)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceInheritedViewportScissorFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->inheritedViewportScissor2D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageSlicedViewOf3D)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceViewportScissorInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewSlicedCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCommandBufferInheritanceViewportScissorInfoNV* value = wrapper->decoded_value; + VkImageViewSlicedCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->viewportScissor2D)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->viewportDepthCount)); - wrapper->pViewportDepths = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pViewportDepths->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pViewportDepths = wrapper->pViewportDepths->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sliceOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sliceCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* 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->texelBufferAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorSetHostMapping)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassTransformBeginInfoQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetBindingReferenceVALVE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassTransformBeginInfoQCOM* value = wrapper->decoded_value; + VkDescriptorSetBindingReferenceVALVE* 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->transform)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->descriptorSetLayout)); + value->descriptorSetLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutHostMappingInfoVALVE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCommandBufferInheritanceRenderPassTransformInfoQCOM* value = wrapper->decoded_value; + VkDescriptorSetLayoutHostMappingInfoVALVE* 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->transform)); - wrapper->renderArea = DecodeAllocator::Allocate(); - wrapper->renderArea->decoded_value = &(value->renderArea); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderArea); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorSize)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthBiasControlFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDepthBiasControlFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* 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)); + bytes_read += PreloadDecodePNextStruct((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->depthBiasControl)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->leastRepresentableValueForceUnormRepresentation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->floatRepresentation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasExact)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorSetHostMapping)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDepthBiasInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetBindingReferenceVALVE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDepthBiasInfoEXT* value = wrapper->decoded_value; + VkDescriptorSetBindingReferenceVALVE* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasConstantFactor)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasClamp)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasSlopeFactor)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->descriptorSetLayout)); + value->descriptorSetLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDepthBiasRepresentationInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutHostMappingInfoVALVE* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDepthBiasRepresentationInfoEXT* value = wrapper->decoded_value; + VkDescriptorSetLayoutHostMappingInfoVALVE* 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)); + bytes_read += PreloadDecodePNextStruct((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->depthBiasRepresentation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthBiasExact)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorSize)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* 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->deviceMemoryReport)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthClampZeroOne)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceMemoryReportCallbackDataEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceMemoryReportCallbackDataEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->type)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->memoryObjectId)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectType)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->objectHandle)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->heapIndex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthClampZeroOne)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceDeviceMemoryReportCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceDeviceMemoryReportCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* 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->pfnUserCallback)); - value->pfnUserCallback = nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pUserData)); - value->pUserData = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonSeamlessCubeMap)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRobustness2FeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRobustness2FeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->robustBufferAccess2)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustImageAccess2)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nullDescriptor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonSeamlessCubeMap)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRobustness2PropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRobustness2PropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceRenderPassStripedFeaturesARM* 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->robustStorageBufferAccessSizeAlignment)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->robustUniformBufferAccessSizeAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderPassStriped)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerCustomBorderColorCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSamplerCustomBorderColorCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceRenderPassStripedPropertiesARM* 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->customBorderColor = DecodeAllocator::Allocate(); - wrapper->customBorderColor->decoded_value = &(value->customBorderColor); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->customBorderColor); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + wrapper->renderPassStripeGranularity = DecodeAllocator::Allocate(); + wrapper->renderPassStripeGranularity->decoded_value = &(value->renderPassStripeGranularity); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderPassStripeGranularity); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRenderPassStripes)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCustomBorderColorPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeInfoARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCustomBorderColorPropertiesEXT* value = wrapper->decoded_value; + VkRenderPassStripeInfoARM* 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->maxCustomBorderColorSamplers)); + wrapper->stripeArea = DecodeAllocator::Allocate(); + wrapper->stripeArea->decoded_value = &(value->stripeArea); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->stripeArea); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCustomBorderColorFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeBeginInfoARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCustomBorderColorFeaturesEXT* value = wrapper->decoded_value; + VkRenderPassStripeBeginInfoARM* 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->customBorderColors)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->customBorderColorWithoutFormat)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stripeInfoCount)); + wrapper->pStripeInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStripeInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStripeInfos = wrapper->pStripeInfos->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentBarrierFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeSubmitInfoARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePresentBarrierFeaturesNV* value = wrapper->decoded_value; + VkRenderPassStripeSubmitInfoARM* 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->presentBarrier)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stripeSemaphoreInfoCount)); + wrapper->pStripeSemaphoreInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStripeSemaphoreInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStripeSemaphoreInfos = wrapper->pStripeSemaphoreInfos->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesPresentBarrierNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSurfaceCapabilitiesPresentBarrierNV* value = wrapper->decoded_value; + VkPhysicalDeviceRenderPassStripedFeaturesARM* 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)); + bytes_read += PreloadDecodePNextStruct((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->presentBarrierSupported)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderPassStriped)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainPresentBarrierCreateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSwapchainPresentBarrierCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceRenderPassStripedPropertiesARM* 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)); + bytes_read += PreloadDecodePNextStruct((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->presentBarrierEnable)); + wrapper->renderPassStripeGranularity = PreloadDecodeAllocator::Allocate(); + wrapper->renderPassStripeGranularity->decoded_value = &(value->renderPassStripeGranularity); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderPassStripeGranularity); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRenderPassStripes)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeInfoARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDiagnosticsConfigFeaturesNV* value = wrapper->decoded_value; + VkRenderPassStripeInfoARM* 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)); + bytes_read += PreloadDecodePNextStruct((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->diagnosticsConfig)); + wrapper->stripeArea = PreloadDecodeAllocator::Allocate(); + wrapper->stripeArea->decoded_value = &(value->stripeArea); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->stripeArea); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceDiagnosticsConfigCreateInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeBeginInfoARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceDiagnosticsConfigCreateInfoNV* value = wrapper->decoded_value; + VkRenderPassStripeBeginInfoARM* 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)); + bytes_read += PreloadDecodePNextStruct((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->stripeInfoCount)); + wrapper->pStripeInfos = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStripeInfos->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStripeInfos = wrapper->pStripeInfos->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkQueryLowLatencySupportNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeSubmitInfoARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkQueryLowLatencySupportNV* value = wrapper->decoded_value; + VkRenderPassStripeSubmitInfoARM* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pQueriedLowLatencyData)); - value->pQueriedLowLatencyData = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stripeSemaphoreInfoCount)); + wrapper->pStripeSemaphoreInfos = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStripeSemaphoreInfos->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStripeSemaphoreInfos = wrapper->pStripeSemaphoreInfos->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* 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->graphicsPipelineLibrary)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* 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->graphicsPipelineLibraryFastLinking)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->graphicsPipelineLibraryIndependentInterpolationDecoration)); + wrapper->fragmentDensityOffsetGranularity = DecodeAllocator::Allocate(); + wrapper->fragmentDensityOffsetGranularity->decoded_value = &(value->fragmentDensityOffsetGranularity); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentDensityOffsetGranularity); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGraphicsPipelineLibraryCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGraphicsPipelineLibraryCreateInfoEXT* value = wrapper->decoded_value; + VkSubpassFragmentDensityMapOffsetEndInfoQCOM* 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->fragmentDensityOffsetCount)); + wrapper->pFragmentDensityOffsets = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pFragmentDensityOffsets->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pFragmentDensityOffsets = wrapper->pFragmentDensityOffsets->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderEarlyAndLateFragmentTests)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityMapOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->fragmentShadingRateEnums)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supersampleFragmentShadingRates)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->noInvocationFragmentShadingRates)); + wrapper->fragmentDensityOffsetGranularity = PreloadDecodeAllocator::Allocate(); + wrapper->fragmentDensityOffsetGranularity->decoded_value = &(value->fragmentDensityOffsetGranularity); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentDensityOffsetGranularity); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* value = wrapper->decoded_value; + VkSubpassFragmentDensityMapOffsetEndInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxFragmentShadingRateInvocationCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fragmentDensityOffsetCount)); + wrapper->pFragmentDensityOffsets = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pFragmentDensityOffsets->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pFragmentDensityOffsets = wrapper->pFragmentDensityOffsets->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineFragmentShadingRateEnumStateCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* 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->shadingRateType)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shadingRate)); - wrapper->combinerOps.SetExternalMemory(value->combinerOps, 2); - bytes_read += wrapper->combinerOps.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedCompute)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedComputePipelines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedComputeCaptureReplay)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryMotionTrianglesDataNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkComputePipelineIndirectBufferInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureGeometryMotionTrianglesDataNV* value = wrapper->decoded_value; + VkComputePipelineIndirectBufferInfoNV* 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->vertexData = DecodeAllocator::Allocate(); - wrapper->vertexData->decoded_value = &(value->vertexData); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->vertexData); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineDeviceAddressCaptureReplay)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureMotionInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineIndirectDeviceAddressInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureMotionInfoNV* value = wrapper->decoded_value; + VkPipelineIndirectDeviceAddressInfoNV* 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->maxInstances)); - 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->pipelineBindPoint)); + 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_VkAccelerationStructureMatrixMotionInstanceNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindPipelineIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureMatrixMotionInstanceNV* value = wrapper->decoded_value; + VkBindPipelineIndirectCommandNV* value = wrapper->decoded_value; - wrapper->transformT0 = DecodeAllocator::Allocate(); - wrapper->transformT0->decoded_value = &(value->transformT0); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT0); - wrapper->transformT1 = DecodeAllocator::Allocate(); - wrapper->transformT1->decoded_value = &(value->transformT1); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT1); - uint32_t temp_instanceCustomIndex; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceCustomIndex); - value->instanceCustomIndex = temp_instanceCustomIndex; - uint32_t temp_mask; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mask); - value->mask = temp_mask; - uint32_t temp_instanceShaderBindingTableRecordOffset; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceShaderBindingTableRecordOffset); - value->instanceShaderBindingTableRecordOffset = temp_instanceShaderBindingTableRecordOffset; - VkGeometryInstanceFlagsKHR temp_flags; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &temp_flags); - value->flags = temp_flags; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureReference)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineAddress)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSRTDataNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSRTDataNV* value = wrapper->decoded_value; + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sx)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->a)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->b)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pvx)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sy)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->c)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pvy)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sz)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->pvz)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qx)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qy)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qz)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->qw)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tx)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->ty)); - bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->tz)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->deviceGeneratedCompute)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedComputePipelines)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedComputeCaptureReplay)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureSRTMotionInstanceNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkComputePipelineIndirectBufferInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureSRTMotionInstanceNV* value = wrapper->decoded_value; + VkComputePipelineIndirectBufferInfoNV* value = wrapper->decoded_value; - wrapper->transformT0 = DecodeAllocator::Allocate(); - wrapper->transformT0->decoded_value = &(value->transformT0); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT0); - wrapper->transformT1 = DecodeAllocator::Allocate(); - wrapper->transformT1->decoded_value = &(value->transformT1); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformT1); - uint32_t temp_instanceCustomIndex; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceCustomIndex); - value->instanceCustomIndex = temp_instanceCustomIndex; - uint32_t temp_mask; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_mask); - value->mask = temp_mask; - uint32_t temp_instanceShaderBindingTableRecordOffset; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &temp_instanceShaderBindingTableRecordOffset); - value->instanceShaderBindingTableRecordOffset = temp_instanceShaderBindingTableRecordOffset; - VkGeometryInstanceFlagsKHR temp_flags; - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &temp_flags); - value->flags = temp_flags; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureReference)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->deviceAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineDeviceAddressCaptureReplay)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineIndirectDeviceAddressInfoNV* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineIndirectDeviceAddressInfoNV* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->pipelineBindPoint)); + 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_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindPipelineIndirectCommandNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* value = wrapper->decoded_value; + VkBindPipelineIndirectCommandNV* 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->rayTracingMotionBlur)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingMotionBlurPipelineTraceRaysIndirect)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineAddress)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLinearColorAttachmentFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceLinearColorAttachmentFeaturesNV* 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->ycbcr2plane444Formats)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->linearColorAttachment)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLinearColorAttachmentFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceLinearColorAttachmentFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->fragmentDensityMapDeferred)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->linearColorAttachment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* 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->subsampledLoads)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subsampledCoarseReconstructionEarlyAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSubsampledArrayLayers)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetSubsampledSamplers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCompressionControlSwapchain)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyCommandTransformInfoQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyCommandTransformInfoQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->transform)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCompressionControlSwapchain)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewSampleWeightCreateInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageCompressionControlFeaturesEXT* value = wrapper->decoded_value; + VkImageViewSampleWeightCreateInfoQCOM* 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->imageCompressionControl)); + wrapper->filterCenter = DecodeAllocator::Allocate(); + wrapper->filterCenter->decoded_value = &(value->filterCenter); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->filterCenter); + wrapper->filterSize = DecodeAllocator::Allocate(); + wrapper->filterSize->decoded_value = &(value->filterSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->filterSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numPhases)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCompressionControlEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageCompressionControlEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImageProcessingFeaturesQCOM* 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->compressionControlPlaneCount)); - bytes_read += wrapper->pFixedRateFlags.DecodeFlags((buffer + bytes_read), (buffer_size - bytes_read)); - value->pFixedRateFlags = wrapper->pFixedRateFlags.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureSampleWeighted)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureBoxFilter)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureBlockMatch)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageCompressionPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingPropertiesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageCompressionPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImageProcessingPropertiesQCOM* 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->imageCompressionFlags)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCompressionFixedRateFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxWeightFilterPhases)); + wrapper->maxWeightFilterDimension = DecodeAllocator::Allocate(); + wrapper->maxWeightFilterDimension->decoded_value = &(value->maxWeightFilterDimension); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxWeightFilterDimension); + wrapper->maxBlockMatchRegion = DecodeAllocator::Allocate(); + wrapper->maxBlockMatchRegion->decoded_value = &(value->maxBlockMatchRegion); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxBlockMatchRegion); + wrapper->maxBoxFilterBlockSize = DecodeAllocator::Allocate(); + wrapper->maxBoxFilterBlockSize->decoded_value = &(value->maxBoxFilterBlockSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxBoxFilterBlockSize); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewSampleWeightCreateInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* value = wrapper->decoded_value; + VkImageViewSampleWeightCreateInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->attachmentFeedbackLoopLayout)); + wrapper->filterCenter = PreloadDecodeAllocator::Allocate(); + wrapper->filterCenter->decoded_value = &(value->filterCenter); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->filterCenter); + wrapper->filterSize = PreloadDecodeAllocator::Allocate(); + wrapper->filterSize->decoded_value = &(value->filterSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->filterSize); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numPhases)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevice4444FormatsFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevice4444FormatsFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImageProcessingFeaturesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->formatA4R4G4B4)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->formatA4B4G4R4)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureSampleWeighted)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureBoxFilter)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureBlockMatch)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFaultFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingPropertiesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFaultFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImageProcessingPropertiesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->deviceFault)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceFaultVendorBinary)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxWeightFilterPhases)); + wrapper->maxWeightFilterDimension = PreloadDecodeAllocator::Allocate(); + wrapper->maxWeightFilterDimension->decoded_value = &(value->maxWeightFilterDimension); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxWeightFilterDimension); + wrapper->maxBlockMatchRegion = PreloadDecodeAllocator::Allocate(); + wrapper->maxBlockMatchRegion->decoded_value = &(value->maxBlockMatchRegion); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxBlockMatchRegion); + wrapper->maxBoxFilterBlockSize = PreloadDecodeAllocator::Allocate(); + wrapper->maxBoxFilterBlockSize->decoded_value = &(value->maxBoxFilterBlockSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxBoxFilterBlockSize); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultCountsEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceFaultCountsEXT* value = wrapper->decoded_value; + VkPhysicalDeviceNestedCommandBufferFeaturesEXT* 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->addressInfoCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorInfoCount)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorBinarySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nestedCommandBuffer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nestedCommandBufferRendering)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nestedCommandBufferSimultaneousUse)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultAddressInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceFaultAddressInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceNestedCommandBufferPropertiesEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressType)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->reportedAddress)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->addressPrecision)); + 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->maxCommandBufferNestingLevel)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultVendorInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceFaultVendorInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceNestedCommandBufferFeaturesEXT* value = wrapper->decoded_value; - wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorFaultCode)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorFaultData)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->nestedCommandBuffer)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nestedCommandBufferRendering)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nestedCommandBufferSimultaneousUse)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceFaultInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceNestedCommandBufferPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); - bytes_read += wrapper->description.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->pAddressInfos = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pAddressInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pAddressInfos = wrapper->pAddressInfos->GetPointer(); - wrapper->pVendorInfos = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pVendorInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pVendorInfos = wrapper->pVendorInfos->GetPointer(); - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pVendorBinaryData)); - value->pVendorBinaryData = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxCommandBufferNestingLevel)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceFaultVendorBinaryHeaderVersionOneEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryAcquireUnmodifiedEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceFaultVendorBinaryHeaderVersionOneEXT* value = wrapper->decoded_value; + VkExternalMemoryAcquireUnmodifiedEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->headerSize)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->headerVersion)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vendorID)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceID)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverVersion)); - wrapper->pipelineCacheUUID.SetExternalMemory(value->pipelineCacheUUID, VK_UUID_SIZE); - bytes_read += wrapper->pipelineCacheUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->applicationNameOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->applicationVersion)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->engineNameOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->engineVersion)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->apiVersion)); + 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->acquireUnmodifiedMemory)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryAcquireUnmodifiedEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* value = wrapper->decoded_value; + VkExternalMemoryAcquireUnmodifiedEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->rasterizationOrderColorAttachmentAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrderDepthAttachmentAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationOrderStencilAttachmentAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->acquireUnmodifiedMemory)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* 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->formatRgba10x6WithoutYCbCrSampler)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3TessellationDomainOrigin)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3DepthClampEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3PolygonMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3RasterizationSamples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3SampleMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3AlphaToCoverageEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3AlphaToOneEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3LogicOpEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorBlendEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorBlendEquation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorWriteMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3RasterizationStream)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ConservativeRasterizationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ExtraPrimitiveOverestimationSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3DepthClipEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3SampleLocationsEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorBlendAdvanced)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ProvokingVertexMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3LineRasterizationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3LineStippleEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3DepthClipNegativeOneToOne)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ViewportWScalingEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ViewportSwizzle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageToColorEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageToColorLocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageModulationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageModulationTableEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageModulationTable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageReductionMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3RepresentativeFragmentTestEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ShadingRateImageEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDirectFBSurfaceCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDirectFBSurfaceCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* 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->dfb)); - value->dfb = nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->surface)); - value->surface = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicPrimitiveTopologyUnrestricted)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkColorBlendEquationEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* value = wrapper->decoded_value; + VkColorBlendEquationEXT* 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->mutableDescriptorType)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcColorBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstColorBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorBlendOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAlphaBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAlphaBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaBlendOp)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeListEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkColorBlendAdvancedEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMutableDescriptorTypeListEXT* value = wrapper->decoded_value; + VkColorBlendAdvancedEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorTypeCount)); - bytes_read += wrapper->pDescriptorTypes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDescriptorTypes = wrapper->pDescriptorTypes.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendOp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcPremultiplied)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstPremultiplied)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->blendOverlap)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clampResults)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMutableDescriptorTypeCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->mutableDescriptorTypeListCount)); - wrapper->pMutableDescriptorTypeLists = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pMutableDescriptorTypeLists->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pMutableDescriptorTypeLists = wrapper->pMutableDescriptorTypeLists->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3TessellationDomainOrigin)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3DepthClampEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3PolygonMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3RasterizationSamples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3SampleMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3AlphaToCoverageEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3AlphaToOneEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3LogicOpEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorBlendEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorBlendEquation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorWriteMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3RasterizationStream)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ConservativeRasterizationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ExtraPrimitiveOverestimationSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3DepthClipEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3SampleLocationsEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorBlendAdvanced)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ProvokingVertexMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3LineRasterizationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3LineStippleEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3DepthClipNegativeOneToOne)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ViewportWScalingEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ViewportSwizzle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageToColorEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageToColorLocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageModulationMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageModulationTableEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageModulationTable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageReductionMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3RepresentativeFragmentTestEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ShadingRateImageEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->vertexInputDynamicState)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicPrimitiveTopologyUnrestricted)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDescription2EXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkColorBlendEquationEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVertexInputBindingDescription2EXT* value = wrapper->decoded_value; + VkColorBlendEquationEXT* 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->binding)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputRate)); - 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->srcColorBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstColorBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorBlendOp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAlphaBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAlphaBlendFactor)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaBlendOp)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputAttributeDescription2EXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkColorBlendAdvancedEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkVertexInputAttributeDescription2EXT* value = wrapper->decoded_value; + VkColorBlendAdvancedEXT* 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->location)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendOp)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcPremultiplied)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstPremultiplied)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->blendOverlap)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clampResults)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDrmPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDrmPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* 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->hasPrimary)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hasRender)); - bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primaryMajor)); - bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primaryMinor)); - bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderMajor)); - bytes_read += ValueDecoder::DecodeInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderMinor)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassMergeFeedback)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAddressBindingReportFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreationControlEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceAddressBindingReportFeaturesEXT* value = wrapper->decoded_value; + VkRenderPassCreationControlEXT* 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->reportAddressBinding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->disallowMerging)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceAddressBindingCallbackDataEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreationFeedbackInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceAddressBindingCallbackDataEXT* value = wrapper->decoded_value; + VkRenderPassCreationFeedbackInfoEXT* 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->baseAddress)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->bindingType)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->postMergeSubpassCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipControlFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreationFeedbackCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDepthClipControlFeaturesEXT* value = wrapper->decoded_value; + VkRenderPassCreationFeedbackCreateInfoEXT* 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->depthClipControl)); + wrapper->pRenderPassFeedback = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pRenderPassFeedback->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRenderPassFeedback = wrapper->pRenderPassFeedback->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportDepthClipControlCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineViewportDepthClipControlCreateInfoEXT* value = wrapper->decoded_value; + VkRenderPassSubpassFeedbackInfoEXT* 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->negativeOneToOne)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassMergeStatus)); + 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->postMergeIndex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* value = wrapper->decoded_value; + VkRenderPassSubpassFeedbackCreateInfoEXT* 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->primitiveTopologyListRestart)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveTopologyPatchListRestart)); + wrapper->pSubpassFeedback = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSubpassFeedback->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSubpassFeedback = wrapper->pSubpassFeedback->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportMemoryZirconHandleInfoFUCHSIA* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportMemoryZirconHandleInfoFUCHSIA* value = wrapper->decoded_value; + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->handle)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassMergeFeedback)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryZirconHandlePropertiesFUCHSIA* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreationControlEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryZirconHandlePropertiesFUCHSIA* value = wrapper->decoded_value; + VkRenderPassCreationControlEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->disallowMerging)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetZirconHandleInfoFUCHSIA* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreationFeedbackInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryGetZirconHandleInfoFUCHSIA* value = wrapper->decoded_value; + VkRenderPassCreationFeedbackInfoEXT* 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->postMergeSubpassCount)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImportSemaphoreZirconHandleInfoFUCHSIA* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreationFeedbackCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImportSemaphoreZirconHandleInfoFUCHSIA* value = wrapper->decoded_value; + VkRenderPassCreationFeedbackCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->zirconHandle)); + wrapper->pRenderPassFeedback = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRenderPassFeedback->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pRenderPassFeedback = wrapper->pRenderPassFeedback->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSemaphoreGetZirconHandleInfoFUCHSIA* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSemaphoreGetZirconHandleInfoFUCHSIA* value = wrapper->decoded_value; + VkRenderPassSubpassFeedbackInfoEXT* 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassMergeStatus)); + wrapper->description.SetExternalMemory(value->description, VK_MAX_DESCRIPTION_SIZE); + bytes_read += wrapper->description.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->postMergeIndex)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* value = wrapper->decoded_value; + VkRenderPassSubpassFeedbackCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->invocationMask)); + wrapper->pSubpassFeedback = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSubpassFeedback->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSubpassFeedback = wrapper->pSubpassFeedback->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMemoryGetRemoteAddressInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingInfoLUNARG* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMemoryGetRemoteAddressInfoNV* value = wrapper->decoded_value; + VkDirectDriverLoadingInfoLUNARG* 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::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pfnGetInstanceProcAddr)); + value->pfnGetInstanceProcAddr = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingListLUNARG* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* value = wrapper->decoded_value; + VkDirectDriverLoadingListLUNARG* 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->externalMemoryRDMA)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverCount)); + wrapper->pDrivers = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDrivers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDrivers = wrapper->pDrivers->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFrameBoundaryFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingInfoLUNARG* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFrameBoundaryFeaturesEXT* value = wrapper->decoded_value; + VkDirectDriverLoadingInfoLUNARG* 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)); + bytes_read += PreloadDecodePNextStruct((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->frameBoundary)); + 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->pfnGetInstanceProcAddr)); + value->pfnGetInstanceProcAddr = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkFrameBoundaryEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingListLUNARG* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkFrameBoundaryEXT* value = wrapper->decoded_value; + VkDirectDriverLoadingListLUNARG* 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)); + bytes_read += PreloadDecodePNextStruct((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->frameID)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageCount)); - bytes_read += wrapper->pImages.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pImages = nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferCount)); - bytes_read += wrapper->pBuffers.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pBuffers = nullptr; - 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverCount)); + wrapper->pDrivers = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDrivers->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDrivers = wrapper->pDrivers->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* 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->multisampledRenderToSingleSampled)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderModuleIdentifier)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassResolvePerformanceQueryEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubpassResolvePerformanceQueryEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* 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->optimal)); + wrapper->shaderModuleIdentifierAlgorithmUUID.SetExternalMemory(value->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE); + bytes_read += wrapper->shaderModuleIdentifierAlgorithmUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultisampledRenderToSingleSampledInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineShaderStageModuleIdentifierCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMultisampledRenderToSingleSampledInfoEXT* value = wrapper->decoded_value; + VkPipelineShaderStageModuleIdentifierCreateInfoEXT* 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->multisampledRenderToSingleSampledEnable)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rasterizationSamples)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identifierSize)); + bytes_read += wrapper->pIdentifier.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + value->pIdentifier = wrapper->pIdentifier.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderModuleIdentifierEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* value = wrapper->decoded_value; + VkShaderModuleIdentifierEXT* 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->extendedDynamicState2)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState2LogicOp)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState2PatchControlPoints)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identifierSize)); + wrapper->identifier.SetExternalMemory(value->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT); + bytes_read += wrapper->identifier.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkScreenSurfaceCreateInfoQNX* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkScreenSurfaceCreateInfoQNX* value = wrapper->decoded_value; + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->context)); - value->context = nullptr; - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->window)); - value->window = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderModuleIdentifier)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceColorWriteEnableFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceColorWriteEnableFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->colorWriteEnable)); + wrapper->shaderModuleIdentifierAlgorithmUUID.SetExternalMemory(value->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE); + bytes_read += wrapper->shaderModuleIdentifierAlgorithmUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineColorWriteCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineShaderStageModuleIdentifierCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineColorWriteCreateInfoEXT* value = wrapper->decoded_value; + VkPipelineShaderStageModuleIdentifierCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->attachmentCount)); - bytes_read += wrapper->pColorWriteEnables.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - value->pColorWriteEnables = wrapper->pColorWriteEnables.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identifierSize)); + bytes_read += wrapper->pIdentifier.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + value->pIdentifier = wrapper->pIdentifier.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderModuleIdentifierEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* value = wrapper->decoded_value; + VkShaderModuleIdentifierEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->primitivesGeneratedQuery)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitivesGeneratedQueryWithRasterizerDiscard)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitivesGeneratedQueryWithNonZeroStreams)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->identifierSize)); + wrapper->identifier.SetExternalMemory(value->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT); + bytes_read += wrapper->identifier.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewMinLodFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpticalFlowFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageViewMinLodFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceOpticalFlowFeaturesNV* 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->minLod)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->opticalFlow)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewMinLodCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpticalFlowPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageViewMinLodCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceOpticalFlowPropertiesNV* 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::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minLod)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedOutputGridSizes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedHintGridSizes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hintSupported)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->costSupported)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bidirectionalFlowSupported)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalFlowSupported)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minWidth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minHeight)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxWidth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxHeight)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxNumRegionsOfInterest)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiDrawFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowImageFormatInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMultiDrawFeaturesEXT* value = wrapper->decoded_value; + VkOpticalFlowImageFormatInfoNV* 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->multiDraw)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->usage)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiDrawPropertiesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowImageFormatPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMultiDrawPropertiesEXT* value = wrapper->decoded_value; + VkOpticalFlowImageFormatPropertiesNV* 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->maxMultiDrawCount)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiDrawInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowSessionCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMultiDrawInfoEXT* value = wrapper->decoded_value; + VkOpticalFlowSessionCreateInfoNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstVertex)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexCount)); + 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->width)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->height)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageFormat)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flowVectorFormat)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->costFormat)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->outputGridSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->hintGridSize)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceLevel)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiDrawIndexedInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowSessionCreatePrivateDataInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMultiDrawIndexedInfoEXT* value = wrapper->decoded_value; + VkOpticalFlowSessionCreatePrivateDataInfoNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstIndex)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexCount)); - bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexOffset)); + 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->id)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pPrivateData)); + value->pPrivateData = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowExecuteInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* value = wrapper->decoded_value; + VkOpticalFlowExecuteInfoNV* 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->image2DViewOf3D)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sampler2DViewOf3D)); + 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->regionCount)); + 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_VkPhysicalDeviceShaderTileImageFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpticalFlowFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderTileImageFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceOpticalFlowFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderTileImageColorReadAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageDepthReadAccess)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageStencilReadAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->opticalFlow)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTileImagePropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpticalFlowPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderTileImagePropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceOpticalFlowPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderTileImageCoherentReadAccelerated)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageReadSampleFromPixelRateInvocation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderTileImageReadFromHelperInvocation)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedOutputGridSizes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedHintGridSizes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hintSupported)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->costSupported)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bidirectionalFlowSupported)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalFlowSupported)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minWidth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minHeight)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxWidth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxHeight)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxNumRegionsOfInterest)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapUsageEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowImageFormatInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMicromapUsageEXT* value = wrapper->decoded_value; + VkOpticalFlowImageFormatInfoNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->count)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subdivisionLevel)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->usage)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapBuildInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowImageFormatPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMicromapBuildInfoEXT* value = wrapper->decoded_value; + VkOpticalFlowImageFormatPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->type)); - 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->mode)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstMicromap)); - value->dstMicromap = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usageCountsCount)); - wrapper->pUsageCounts = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pUsageCounts = wrapper->pUsageCounts->GetPointer(); - wrapper->ppUsageCounts = DecodeAllocator::Allocate>(); - bytes_read += wrapper->ppUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->ppUsageCounts = wrapper->ppUsageCounts->GetPointer(); - wrapper->data = DecodeAllocator::Allocate(); - wrapper->data->decoded_value = &(value->data); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data); - wrapper->scratchData = DecodeAllocator::Allocate(); - wrapper->scratchData->decoded_value = &(value->scratchData); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->scratchData); - wrapper->triangleArray = DecodeAllocator::Allocate(); - wrapper->triangleArray->decoded_value = &(value->triangleArray); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->triangleArray); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->triangleArrayStride)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowSessionCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMicromapCreateInfoEXT* value = wrapper->decoded_value; + VkOpticalFlowSessionCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->createFlags)); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); - value->buffer = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); + 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::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageFormat)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flowVectorFormat)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->costFormat)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->outputGridSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->hintGridSize)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceLevel)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpacityMicromapFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowSessionCreatePrivateDataInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceOpacityMicromapFeaturesEXT* value = wrapper->decoded_value; + VkOpticalFlowSessionCreatePrivateDataInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->micromap)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromapCaptureReplay)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->micromapHostCommands)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->id)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pPrivateData)); + value->pPrivateData = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpacityMicromapPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowExecuteInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceOpacityMicromapPropertiesEXT* value = wrapper->decoded_value; + VkOpticalFlowExecuteInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxOpacity2StateSubdivisionLevel)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxOpacity4StateSubdivisionLevel)); + 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->regionCount)); + wrapper->pRegions = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pRegions->PreloadDecode((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_VkMicromapVersionInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyDitheringFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMicromapVersionInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceLegacyDitheringFeaturesEXT* 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->pVersionData.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - value->pVersionData = wrapper->pVersionData.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->legacyDithering)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMicromapToMemoryInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyDitheringFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyMicromapToMemoryInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceLegacyDitheringFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->src)); - value->src = VK_NULL_HANDLE; - wrapper->dst = DecodeAllocator::Allocate(); - wrapper->dst->decoded_value = &(value->dst); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dst); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->legacyDithering)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMemoryToMicromapInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyMemoryToMicromapInfoEXT* value = wrapper->decoded_value; + VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* 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->src = DecodeAllocator::Allocate(); - wrapper->src->decoded_value = &(value->src); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->src); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dst)); - value->dst = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineProtectedAccess)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMicromapInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkCopyMicromapInfoEXT* value = wrapper->decoded_value; + VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->src)); - value->src = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dst)); - value->dst = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineProtectedAccess)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapBuildSizesInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMicromapBuildSizesInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* 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->micromapSize)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->buildScratchSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->discardable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormatResolve)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesOpacityMicromapEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureTrianglesOpacityMicromapEXT* value = wrapper->decoded_value; + VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* 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->indexType)); - wrapper->indexBuffer = DecodeAllocator::Allocate(); - wrapper->indexBuffer->decoded_value = &(value->indexBuffer); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->indexBuffer); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexStride)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseTriangle)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usageCountsCount)); - wrapper->pUsageCounts = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pUsageCounts = wrapper->pUsageCounts->GetPointer(); - wrapper->ppUsageCounts = DecodeAllocator::Allocate>(); - bytes_read += wrapper->ppUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->ppUsageCounts = wrapper->ppUsageCounts->GetPointer(); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->micromap)); - value->micromap = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nullColorAttachmentWithExternalFormatResolve)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormatResolveChromaOffsetX)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormatResolveChromaOffsetY)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMicromapTriangleEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatResolvePropertiesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMicromapTriangleEXT* value = wrapper->decoded_value; + VkAndroidHardwareBufferFormatResolvePropertiesANDROID* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dataOffset)); - bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->subdivisionLevel)); - bytes_read += ValueDecoder::DecodeUInt16Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->format)); + 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->colorAttachmentFormat)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDisplacementMicromapFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* 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)); + bytes_read += PreloadDecodePNextStruct((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->displacementMicromap)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormatResolve)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDisplacementMicromapPropertiesNV* value = wrapper->decoded_value; + VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxDisplacementMicromapSubdivisionLevel)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nullColorAttachmentWithExternalFormatResolve)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormatResolveChromaOffsetX)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormatResolveChromaOffsetY)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesDisplacementMicromapNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatResolvePropertiesANDROID* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAccelerationStructureTrianglesDisplacementMicromapNV* value = wrapper->decoded_value; + VkAndroidHardwareBufferFormatResolvePropertiesANDROID* 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)); + bytes_read += PreloadDecodePNextStruct((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->displacementBiasAndScaleFormat)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementVectorFormat)); - wrapper->displacementBiasAndScaleBuffer = DecodeAllocator::Allocate(); - wrapper->displacementBiasAndScaleBuffer->decoded_value = &(value->displacementBiasAndScaleBuffer); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displacementBiasAndScaleBuffer); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementBiasAndScaleStride)); - wrapper->displacementVectorBuffer = DecodeAllocator::Allocate(); - wrapper->displacementVectorBuffer->decoded_value = &(value->displacementVectorBuffer); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displacementVectorBuffer); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacementVectorStride)); - wrapper->displacedMicromapPrimitiveFlags = DecodeAllocator::Allocate(); - wrapper->displacedMicromapPrimitiveFlags->decoded_value = &(value->displacedMicromapPrimitiveFlags); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->displacedMicromapPrimitiveFlags); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->displacedMicromapPrimitiveFlagsStride)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); - wrapper->indexBuffer = DecodeAllocator::Allocate(); - wrapper->indexBuffer->decoded_value = &(value->indexBuffer); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->indexBuffer); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexStride)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->baseTriangle)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->usageCountsCount)); - wrapper->pUsageCounts = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pUsageCounts = wrapper->pUsageCounts->GetPointer(); - wrapper->ppUsageCounts = DecodeAllocator::Allocate>(); - bytes_read += wrapper->ppUsageCounts->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->ppUsageCounts = wrapper->ppUsageCounts->GetPointer(); - bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->micromap)); - value->micromap = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorAttachmentFormat)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* value = wrapper->decoded_value; + VkPhysicalDeviceShaderObjectFeaturesEXT* 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->clustercullingShader)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewClusterCullingShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderObject)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* value = wrapper->decoded_value; + VkPhysicalDeviceShaderObjectPropertiesEXT* 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->maxWorkGroupCount.SetExternalMemory(value->maxWorkGroupCount, 3); - bytes_read += wrapper->maxWorkGroupCount.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - wrapper->maxWorkGroupSize.SetExternalMemory(value->maxWorkGroupSize, 3); - bytes_read += wrapper->maxWorkGroupSize.DecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxOutputClusterCount)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indirectBufferOffsetAlignment)); + wrapper->shaderBinaryUUID.SetExternalMemory(value->shaderBinaryUUID, VK_UUID_SIZE); + bytes_read += wrapper->shaderBinaryUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBinaryVersion)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* value = wrapper->decoded_value; + VkShaderCreateInfoEXT* 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->clusterShadingRate)); + 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->stage)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->nextStage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->codeType)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->codeSize)); + bytes_read += wrapper->pCode.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCode = wrapper->pCode.GetPointer(); + bytes_read += wrapper->pName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pName = wrapper->pName.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->setLayoutCount)); + bytes_read += wrapper->pSetLayouts.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSetLayouts = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushConstantRangeCount)); + wrapper->pPushConstantRanges = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pPushConstantRanges->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPushConstantRanges = wrapper->pPushConstantRanges->GetPointer(); + wrapper->pSpecializationInfo = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSpecializationInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSpecializationInfo = wrapper->pSpecializationInfo->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderObjectFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->borderColorSwizzle)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->borderColorSwizzleFromImage)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderObject)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerBorderColorComponentMappingCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSamplerBorderColorComponentMappingCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderObjectPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->components = DecodeAllocator::Allocate(); - wrapper->components->decoded_value = &(value->components); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->components); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srgb)); + wrapper->shaderBinaryUUID.SetExternalMemory(value->shaderBinaryUUID, VK_UUID_SIZE); + bytes_read += wrapper->shaderBinaryUUID.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBinaryVersion)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* value = wrapper->decoded_value; + VkShaderCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pageableDeviceLocalMemory)); + 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->stage)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->nextStage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->codeType)); + bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->codeSize)); + bytes_read += wrapper->pCode.PreloadDecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pCode = wrapper->pCode.GetPointer(); + bytes_read += wrapper->pName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pName = wrapper->pName.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->setLayoutCount)); + bytes_read += wrapper->pSetLayouts.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSetLayouts = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushConstantRangeCount)); + wrapper->pPushConstantRanges = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPushConstantRanges->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPushConstantRanges = wrapper->pPushConstantRanges->GetPointer(); + wrapper->pSpecializationInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSpecializationInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSpecializationInfo = wrapper->pSpecializationInfo->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesARM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderCorePropertiesARM* value = wrapper->decoded_value; + VkPhysicalDeviceTilePropertiesFeaturesQCOM* 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->pixelRate)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->texelRate)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->fmaRate)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tileProperties)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTilePropertiesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDeviceQueueShaderCoreControlCreateInfoARM* value = wrapper->decoded_value; + VkTilePropertiesQCOM* 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->shaderCoreCount)); + wrapper->tileSize = DecodeAllocator::Allocate(); + wrapper->tileSize->decoded_value = &(value->tileSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->tileSize); + wrapper->apronSize = DecodeAllocator::Allocate(); + wrapper->apronSize->decoded_value = &(value->apronSize); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->apronSize); + wrapper->origin = DecodeAllocator::Allocate(); + wrapper->origin->decoded_value = &(value->origin); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->origin); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSchedulingControlsFeaturesARM* value = wrapper->decoded_value; + VkPhysicalDeviceTilePropertiesFeaturesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->schedulingControls)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tileProperties)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTilePropertiesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSchedulingControlsPropertiesARM* value = wrapper->decoded_value; + VkTilePropertiesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->schedulingControlsFlags)); + wrapper->tileSize = PreloadDecodeAllocator::Allocate(); + wrapper->tileSize->decoded_value = &(value->tileSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->tileSize); + wrapper->apronSize = PreloadDecodeAllocator::Allocate(); + wrapper->apronSize->decoded_value = &(value->apronSize); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->apronSize); + wrapper->origin = PreloadDecodeAllocator::Allocate(); + wrapper->origin->decoded_value = &(value->origin); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->origin); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAmigoProfilingFeaturesSEC* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceAmigoProfilingFeaturesSEC* 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->imageSlicedViewOf3D)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->amigoProfiling)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageViewSlicedCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAmigoProfilingSubmitInfoSEC* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageViewSlicedCreateInfoEXT* value = wrapper->decoded_value; + VkAmigoProfilingSubmitInfoSEC* 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->sliceOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sliceCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstDrawTimestamp)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapBufferTimestamp)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAmigoProfilingFeaturesSEC* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* value = wrapper->decoded_value; + VkPhysicalDeviceAmigoProfilingFeaturesSEC* 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)); + bytes_read += PreloadDecodePNextStruct((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->descriptorSetHostMapping)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->amigoProfiling)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetBindingReferenceVALVE* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAmigoProfilingSubmitInfoSEC* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDescriptorSetBindingReferenceVALVE* value = wrapper->decoded_value; + VkAmigoProfilingSubmitInfoSEC* 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)); + bytes_read += PreloadDecodePNextStruct((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->descriptorSetLayout)); - value->descriptorSetLayout = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstDrawTimestamp)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapBufferTimestamp)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutHostMappingInfoVALVE* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDescriptorSetLayoutHostMappingInfoVALVE* value = wrapper->decoded_value; + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* 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::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorOffset)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewPerViewViewports)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->depthClampZeroOne)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewPerViewViewports)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* 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->nonSeamlessCubeMap)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingInvocationReorderReorderingHint)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRenderPassStripedFeaturesARM* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* 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->renderPassStriped)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingInvocationReorder)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRenderPassStripedPropertiesARM* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->renderPassStripeGranularity = DecodeAllocator::Allocate(); - wrapper->renderPassStripeGranularity->decoded_value = &(value->renderPassStripeGranularity); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderPassStripeGranularity); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRenderPassStripes)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingInvocationReorderReorderingHint)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeInfoARM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassStripeInfoARM* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->stripeArea = DecodeAllocator::Allocate(); - wrapper->stripeArea->decoded_value = &(value->stripeArea); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->stripeArea); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingInvocationReorder)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeBeginInfoARM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassStripeBeginInfoARM* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* 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->stripeInfoCount)); - wrapper->pStripeInfos = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStripeInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStripeInfos = wrapper->pStripeInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseAddressSpace)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeSubmitInfoARM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassStripeSubmitInfoARM* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* 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->stripeSemaphoreInfoCount)); - wrapper->pStripeSemaphoreInfos = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pStripeSemaphoreInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pStripeSemaphoreInfos = wrapper->pStripeSemaphoreInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseAddressSpaceSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseImageUsageFlags)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseBufferUsageFlags)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->fragmentDensityMapOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseAddressSpace)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->fragmentDensityOffsetGranularity = DecodeAllocator::Allocate(); - wrapper->fragmentDensityOffsetGranularity->decoded_value = &(value->fragmentDensityOffsetGranularity); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->fragmentDensityOffsetGranularity); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseAddressSpaceSize)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseImageUsageFlags)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseBufferUsageFlags)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSubpassFragmentDensityMapOffsetEndInfoQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* 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->fragmentDensityOffsetCount)); - wrapper->pFragmentDensityOffsets = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pFragmentDensityOffsets->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pFragmentDensityOffsets = wrapper->pFragmentDensityOffsets->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->legacyVertexAttributes)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* 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->deviceGeneratedCompute)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedComputePipelines)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedComputeCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nativeUnalignedPerformance)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkComputePipelineIndirectBufferInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkComputePipelineIndirectBufferInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->deviceAddress)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineDeviceAddressCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->legacyVertexAttributes)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineIndirectDeviceAddressInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineIndirectDeviceAddressInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->pipelineBindPoint)); - 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->nativeUnalignedPerformance)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindPipelineIndirectCommandNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLayerSettingEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBindPipelineIndirectCommandNV* value = wrapper->decoded_value; + VkLayerSettingEXT* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineAddress)); + bytes_read += wrapper->pLayerName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLayerName = wrapper->pLayerName.GetPointer(); + bytes_read += wrapper->pSettingName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSettingName = wrapper->pSettingName.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->valueCount)); + 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_VkPhysicalDeviceLinearColorAttachmentFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLayerSettingsCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLinearColorAttachmentFeaturesNV* value = wrapper->decoded_value; + VkLayerSettingsCreateInfoEXT* 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->linearColorAttachment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->settingCount)); + wrapper->pSettings = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSettings->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSettings = wrapper->pSettings->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLayerSettingEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* value = wrapper->decoded_value; + VkLayerSettingEXT* 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->imageCompressionControlSwapchain)); + bytes_read += wrapper->pLayerName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLayerName = wrapper->pLayerName.GetPointer(); + bytes_read += wrapper->pSettingName.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSettingName = wrapper->pSettingName.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->valueCount)); + bytes_read += wrapper->pValues.PreloadDecodeVoid((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_VkImageViewSampleWeightCreateInfoQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLayerSettingsCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageViewSampleWeightCreateInfoQCOM* value = wrapper->decoded_value; + VkLayerSettingsCreateInfoEXT* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->filterCenter = DecodeAllocator::Allocate(); - wrapper->filterCenter->decoded_value = &(value->filterCenter); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->filterCenter); - wrapper->filterSize = DecodeAllocator::Allocate(); - wrapper->filterSize->decoded_value = &(value->filterSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->filterSize); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->numPhases)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->settingCount)); + wrapper->pSettings = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pSettings->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSettings = wrapper->pSettings->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingFeaturesQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageProcessingFeaturesQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* 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->textureSampleWeighted)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureBoxFilter)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureBlockMatch)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreBuiltins)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingPropertiesQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageProcessingPropertiesQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* 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->maxWeightFilterPhases)); - wrapper->maxWeightFilterDimension = DecodeAllocator::Allocate(); - wrapper->maxWeightFilterDimension->decoded_value = &(value->maxWeightFilterDimension); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxWeightFilterDimension); - wrapper->maxBlockMatchRegion = DecodeAllocator::Allocate(); - wrapper->maxBlockMatchRegion->decoded_value = &(value->maxBlockMatchRegion); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxBlockMatchRegion); - wrapper->maxBoxFilterBlockSize = DecodeAllocator::Allocate(); - wrapper->maxBoxFilterBlockSize->decoded_value = &(value->maxBoxFilterBlockSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxBoxFilterBlockSize); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderWarpsPerCore)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceNestedCommandBufferFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* 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)); + bytes_read += PreloadDecodePNextStruct((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->nestedCommandBuffer)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nestedCommandBufferRendering)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nestedCommandBufferSimultaneousUse)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreBuiltins)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceNestedCommandBufferPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxCommandBufferNestingLevel)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreMask)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderWarpsPerCore)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkExternalMemoryAcquireUnmodifiedEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkExternalMemoryAcquireUnmodifiedEXT* value = wrapper->decoded_value; + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* 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->acquireUnmodifiedMemory)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineLibraryGroupHandles)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->extendedDynamicState3TessellationDomainOrigin)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3DepthClampEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3PolygonMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3RasterizationSamples)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3SampleMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3AlphaToCoverageEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3AlphaToOneEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3LogicOpEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorBlendEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorBlendEquation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorWriteMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3RasterizationStream)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ConservativeRasterizationMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ExtraPrimitiveOverestimationSize)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3DepthClipEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3SampleLocationsEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ColorBlendAdvanced)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ProvokingVertexMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3LineRasterizationMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3LineStippleEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3DepthClipNegativeOneToOne)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ViewportWScalingEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ViewportSwizzle)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageToColorEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageToColorLocation)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageModulationMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageModulationTableEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageModulationTable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3CoverageReductionMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3RepresentativeFragmentTestEnable)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedDynamicState3ShadingRateImageEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineLibraryGroupHandles)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* 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->dynamicRenderingUnusedAttachments)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->dynamicPrimitiveTopologyUnrestricted)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicRenderingUnusedAttachments)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkColorBlendEquationEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySleepModeInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkColorBlendEquationEXT* value = wrapper->decoded_value; + VkLatencySleepModeInfoNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcColorBlendFactor)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstColorBlendFactor)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->colorBlendOp)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcAlphaBlendFactor)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstAlphaBlendFactor)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->alphaBlendOp)); + 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->lowLatencyMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lowLatencyBoost)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minimumIntervalUs)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkColorBlendAdvancedEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySleepInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkColorBlendAdvancedEXT* value = wrapper->decoded_value; + VkLatencySleepInfoNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->advancedBlendOp)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->srcPremultiplied)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dstPremultiplied)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->blendOverlap)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clampResults)); + 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->signalSemaphore)); + value->signalSemaphore = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->value)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSetLatencyMarkerInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* value = wrapper->decoded_value; + VkSetLatencyMarkerInfoNV* 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->subpassMergeFeedback)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->marker)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreationControlEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencyTimingsFrameReportNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassCreationControlEXT* value = wrapper->decoded_value; + VkLatencyTimingsFrameReportNV* 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->disallowMerging)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputSampleTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->simStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->simEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderSubmitStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderSubmitEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->osRenderQueueStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->osRenderQueueEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gpuRenderStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gpuRenderEndTimeUs)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreationFeedbackInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGetLatencyMarkerInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassCreationFeedbackInfoEXT* value = wrapper->decoded_value; + VkGetLatencyMarkerInfoNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->postMergeSubpassCount)); + 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->timingCount)); + wrapper->pTimings = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pTimings->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTimings = wrapper->pTimings->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassCreationFeedbackCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySubmissionPresentIdNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassCreationFeedbackCreateInfoEXT* value = wrapper->decoded_value; + VkLatencySubmissionPresentIdNV* 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->pRenderPassFeedback = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pRenderPassFeedback->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pRenderPassFeedback = wrapper->pRenderPassFeedback->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainLatencyCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassSubpassFeedbackInfoEXT* value = wrapper->decoded_value; + VkSwapchainLatencyCreateInfoNV* value = wrapper->decoded_value; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->subpassMergeStatus)); - 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->postMergeIndex)); + 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->latencyModeEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackCreateInfoEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOutOfBandQueueTypeInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkRenderPassSubpassFeedbackCreateInfoEXT* value = wrapper->decoded_value; + VkOutOfBandQueueTypeInfoNV* 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->pSubpassFeedback = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSubpassFeedback->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSubpassFeedback = wrapper->pSubpassFeedback->GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingInfoLUNARG* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySurfaceCapabilitiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDirectDriverLoadingInfoLUNARG* value = wrapper->decoded_value; + VkLatencySurfaceCapabilitiesNV* 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->pfnGetInstanceProcAddr)); - value->pfnGetInstanceProcAddr = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentModeCount)); + bytes_read += wrapper->pPresentModes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentModes = wrapper->pPresentModes.GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingListLUNARG* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySleepModeInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkDirectDriverLoadingListLUNARG* value = wrapper->decoded_value; + VkLatencySleepModeInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->mode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverCount)); - wrapper->pDrivers = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pDrivers->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pDrivers = wrapper->pDrivers->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lowLatencyMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lowLatencyBoost)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minimumIntervalUs)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySleepInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* value = wrapper->decoded_value; + VkLatencySleepInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderModuleIdentifier)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->signalSemaphore)); + value->signalSemaphore = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->value)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSetLatencyMarkerInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* value = wrapper->decoded_value; + VkSetLatencyMarkerInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->shaderModuleIdentifierAlgorithmUUID.SetExternalMemory(value->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE); - bytes_read += wrapper->shaderModuleIdentifierAlgorithmUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->marker)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineShaderStageModuleIdentifierCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencyTimingsFrameReportNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPipelineShaderStageModuleIdentifierCreateInfoEXT* value = wrapper->decoded_value; + VkLatencyTimingsFrameReportNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->identifierSize)); - bytes_read += wrapper->pIdentifier.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - value->pIdentifier = wrapper->pIdentifier.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputSampleTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->simStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->simEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderSubmitStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderSubmitEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->osRenderQueueStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->osRenderQueueEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gpuRenderStartTimeUs)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gpuRenderEndTimeUs)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderModuleIdentifierEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGetLatencyMarkerInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkShaderModuleIdentifierEXT* value = wrapper->decoded_value; + VkGetLatencyMarkerInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->identifierSize)); - wrapper->identifier.SetExternalMemory(value->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT); - bytes_read += wrapper->identifier.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->timingCount)); + wrapper->pTimings = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pTimings->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTimings = wrapper->pTimings->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpticalFlowFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySubmissionPresentIdNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceOpticalFlowFeaturesNV* value = wrapper->decoded_value; + VkLatencySubmissionPresentIdNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->opticalFlow)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentID)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpticalFlowPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainLatencyCreateInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceOpticalFlowPropertiesNV* value = wrapper->decoded_value; + VkSwapchainLatencyCreateInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->supportedOutputGridSizes)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedHintGridSizes)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->hintSupported)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->costSupported)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bidirectionalFlowSupported)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->globalFlowSupported)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minWidth)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minHeight)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxWidth)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxHeight)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxNumRegionsOfInterest)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->latencyModeEnable)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowImageFormatInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOutOfBandQueueTypeInfoNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkOpticalFlowImageFormatInfoNV* value = wrapper->decoded_value; + VkOutOfBandQueueTypeInfoNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->usage)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->queueType)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowImageFormatPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySurfaceCapabilitiesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkOpticalFlowImageFormatPropertiesNV* value = wrapper->decoded_value; + VkLatencySurfaceCapabilitiesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->format)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentModeCount)); + bytes_read += wrapper->pPresentModes.PreloadDecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPresentModes = wrapper->pPresentModes.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowSessionCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkOpticalFlowSessionCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* 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->width)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->height)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageFormat)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flowVectorFormat)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->costFormat)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->outputGridSize)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->hintGridSize)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->performanceLevel)); - 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->multiviewPerViewRenderAreas)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowSessionCreatePrivateDataInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkOpticalFlowSessionCreatePrivateDataInfoNV* value = wrapper->decoded_value; + VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* 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->id)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); - bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pPrivateData)); - value->pPrivateData = nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewRenderAreaCount)); + wrapper->pPerViewRenderAreas = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pPerViewRenderAreas->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPerViewRenderAreas = wrapper->pPerViewRenderAreas->GetPointer(); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOpticalFlowExecuteInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkOpticalFlowExecuteInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->regionCount)); - 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->multiviewPerViewRenderAreas)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyDitheringFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLegacyDitheringFeaturesEXT* value = wrapper->decoded_value; + VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->legacyDithering)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perViewRenderAreaCount)); + wrapper->pPerViewRenderAreas = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pPerViewRenderAreas->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPerViewRenderAreas = wrapper->pPerViewRenderAreas->GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* wrapper) +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; - VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* value = wrapper->decoded_value; + 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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pipelineProtectedAccess)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perStageDescriptorSet)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicPipelineLayout)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* value = wrapper->decoded_value; + 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)); + bytes_read += PreloadDecodePNextStruct((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->externalFormatResolve)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->perStageDescriptorSet)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicPipelineLayout)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* value = wrapper->decoded_value; + VkPhysicalDeviceImageProcessing2FeaturesQCOM* 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->nullColorAttachmentWithExternalFormatResolve)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormatResolveChromaOffsetX)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->externalFormatResolveChromaOffsetY)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureBlockMatch2)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatResolvePropertiesANDROID* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2PropertiesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAndroidHardwareBufferFormatResolvePropertiesANDROID* value = wrapper->decoded_value; + VkPhysicalDeviceImageProcessing2PropertiesQCOM* 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->colorAttachmentFormat)); + wrapper->maxBlockMatchWindow = DecodeAllocator::Allocate(); + wrapper->maxBlockMatchWindow->decoded_value = &(value->maxBlockMatchWindow); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxBlockMatchWindow); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerBlockMatchWindowCreateInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderObjectFeaturesEXT* value = wrapper->decoded_value; + VkSamplerBlockMatchWindowCreateInfoQCOM* 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->shaderObject)); + wrapper->windowExtent = DecodeAllocator::Allocate(); + wrapper->windowExtent->decoded_value = &(value->windowExtent); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->windowExtent); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->windowCompareMode)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderObjectPropertiesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImageProcessing2FeaturesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->shaderBinaryUUID.SetExternalMemory(value->shaderBinaryUUID, VK_UUID_SIZE); - bytes_read += wrapper->shaderBinaryUUID.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderBinaryVersion)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->textureBlockMatch2)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2PropertiesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkShaderCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceImageProcessing2PropertiesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->stage)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->nextStage)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->codeType)); - bytes_read += ValueDecoder::DecodeSizeTValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->codeSize)); - bytes_read += wrapper->pCode.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); - value->pCode = wrapper->pCode.GetPointer(); - bytes_read += wrapper->pName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pName = wrapper->pName.GetPointer(); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->setLayoutCount)); - bytes_read += wrapper->pSetLayouts.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSetLayouts = nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushConstantRangeCount)); - wrapper->pPushConstantRanges = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pPushConstantRanges->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPushConstantRanges = wrapper->pPushConstantRanges->GetPointer(); - wrapper->pSpecializationInfo = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSpecializationInfo->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSpecializationInfo = wrapper->pSpecializationInfo->GetPointer(); + wrapper->maxBlockMatchWindow = PreloadDecodeAllocator::Allocate(); + wrapper->maxBlockMatchWindow->decoded_value = &(value->maxBlockMatchWindow); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxBlockMatchWindow); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerBlockMatchWindowCreateInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceTilePropertiesFeaturesQCOM* value = wrapper->decoded_value; + VkSamplerBlockMatchWindowCreateInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->tileProperties)); + wrapper->windowExtent = PreloadDecodeAllocator::Allocate(); + wrapper->windowExtent->decoded_value = &(value->windowExtent); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->windowExtent); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->windowCompareMode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTilePropertiesQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicWeightsFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkTilePropertiesQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceCubicWeightsFeaturesQCOM* 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->tileSize = DecodeAllocator::Allocate(); - wrapper->tileSize->decoded_value = &(value->tileSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->tileSize); - wrapper->apronSize = DecodeAllocator::Allocate(); - wrapper->apronSize->decoded_value = &(value->apronSize); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->apronSize); - wrapper->origin = DecodeAllocator::Allocate(); - wrapper->origin->decoded_value = &(value->origin); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->origin); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->selectableCubicWeights)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAmigoProfilingFeaturesSEC* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerCubicWeightsCreateInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceAmigoProfilingFeaturesSEC* value = wrapper->decoded_value; + VkSamplerCubicWeightsCreateInfoQCOM* 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->amigoProfiling)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->cubicWeights)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAmigoProfilingSubmitInfoSEC* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBlitImageCubicWeightsInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkAmigoProfilingSubmitInfoSEC* value = wrapper->decoded_value; + VkBlitImageCubicWeightsInfoQCOM* 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->firstDrawTimestamp)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->swapBufferTimestamp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->cubicWeights)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicWeightsFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceCubicWeightsFeaturesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->multiviewPerViewViewports)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->selectableCubicWeights)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerCubicWeightsCreateInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* value = wrapper->decoded_value; + VkSamplerCubicWeightsCreateInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->rayTracingInvocationReorderReorderingHint)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->cubicWeights)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBlitImageCubicWeightsInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* value = wrapper->decoded_value; + VkBlitImageCubicWeightsInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->rayTracingInvocationReorder)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->cubicWeights)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* 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->extendedSparseAddressSpace)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrDegamma)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* value = wrapper->decoded_value; + VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* 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->extendedSparseAddressSpaceSize)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseImageUsageFlags)); - bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->extendedSparseBufferUsageFlags)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enableYDegamma)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enableCbCrDegamma)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->legacyVertexAttributes)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->ycbcrDegamma)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* value = wrapper->decoded_value; + VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->nativeUnalignedPerformance)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enableYDegamma)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enableCbCrDegamma)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLayerSettingEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicClampFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkLayerSettingEXT* value = wrapper->decoded_value; + VkPhysicalDeviceCubicClampFeaturesQCOM* value = wrapper->decoded_value; - bytes_read += wrapper->pLayerName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pLayerName = wrapper->pLayerName.GetPointer(); - bytes_read += wrapper->pSettingName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSettingName = wrapper->pSettingName.GetPointer(); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->valueCount)); - bytes_read += wrapper->pValues.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); - value->pValues = wrapper->pValues.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::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cubicRangeClamp)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLayerSettingsCreateInfoEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicClampFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkLayerSettingsCreateInfoEXT* value = wrapper->decoded_value; + VkPhysicalDeviceCubicClampFeaturesQCOM* 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)); + bytes_read += PreloadDecodePNextStruct((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->settingCount)); - wrapper->pSettings = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pSettings->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pSettings = wrapper->pSettings->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->cubicRangeClamp)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* value = wrapper->decoded_value; + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* 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->shaderCoreBuiltins)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentFeedbackLoopDynamicState)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* value = wrapper->decoded_value; + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->shaderCoreMask)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreCount)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderWarpsPerCore)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->attachmentFeedbackLoopDynamicState)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredDriverPropertiesMSFT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceLayeredDriverPropertiesMSFT* 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->pipelineLibraryGroupHandles)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->underlyingAPI)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredDriverPropertiesMSFT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* value = wrapper->decoded_value; + VkPhysicalDeviceLayeredDriverPropertiesMSFT* 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)); + bytes_read += PreloadDecodePNextStruct((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->dynamicRenderingUnusedAttachments)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->underlyingAPI)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySleepModeInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkLatencySleepModeInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* 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->lowLatencyMode)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->lowLatencyBoost)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minimumIntervalUs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorPoolOverallocation)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySleepInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkLatencySleepInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->signalSemaphore)); - value->signalSemaphore = VK_NULL_HANDLE; - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->value)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorPoolOverallocation)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSetLatencyMarkerInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRawAccessChainsFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSetLatencyMarkerInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceRawAccessChainsFeaturesNV* 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->presentID)); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->marker)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRawAccessChains)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencyTimingsFrameReportNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRawAccessChainsFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkLatencyTimingsFrameReportNV* value = wrapper->decoded_value; + VkPhysicalDeviceRawAccessChainsFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->presentID)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->inputSampleTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->simStartTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->simEndTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderSubmitStartTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderSubmitEndTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentStartTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->presentEndTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverStartTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->driverEndTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->osRenderQueueStartTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->osRenderQueueEndTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gpuRenderStartTimeUs)); - bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->gpuRenderEndTimeUs)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderRawAccessChains)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGetLatencyMarkerInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkGetLatencyMarkerInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* 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->timingCount)); - wrapper->pTimings = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pTimings->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pTimings = wrapper->pTimings->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderFloat16VectorAtomics)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySubmissionPresentIdNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkLatencySubmissionPresentIdNV* value = wrapper->decoded_value; + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->presentID)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderFloat16VectorAtomics)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSwapchainLatencyCreateInfoNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSwapchainLatencyCreateInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* 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->latencyModeEnable)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderReplicatedComposites)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkOutOfBandQueueTypeInfoNV* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkOutOfBandQueueTypeInfoNV* value = wrapper->decoded_value; + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* 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)); + bytes_read += PreloadDecodePNextStruct((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->queueType)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderReplicatedComposites)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLatencySurfaceCapabilitiesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkLatencySurfaceCapabilitiesNV* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingValidationFeaturesNV* 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->presentModeCount)); - bytes_read += wrapper->pPresentModes.DecodeEnum((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPresentModes = wrapper->pPresentModes.GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingValidation)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceRayTracingValidationFeaturesNV* 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)); + bytes_read += PreloadDecodePNextStruct((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->multiviewPerViewRenderAreas)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingValidation)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceImageAlignmentControlFeaturesMESA* 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->perViewRenderAreaCount)); - wrapper->pPerViewRenderAreas = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pPerViewRenderAreas->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pPerViewRenderAreas = wrapper->pPerViewRenderAreas->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageAlignmentControl)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDevicePerStageDescriptorSetFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceImageAlignmentControlPropertiesMESA* 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->perStageDescriptorSet)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicPipelineLayout)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedImageAlignmentMask)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageAlignmentControlCreateInfoMESA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageProcessing2FeaturesQCOM* value = wrapper->decoded_value; + VkImageAlignmentControlCreateInfoMESA* 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->textureBlockMatch2)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maximumRequestedAlignment)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2PropertiesQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageProcessing2PropertiesQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceImageAlignmentControlFeaturesMESA* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->maxBlockMatchWindow = DecodeAllocator::Allocate(); - wrapper->maxBlockMatchWindow->decoded_value = &(value->maxBlockMatchWindow); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->maxBlockMatchWindow); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->imageAlignmentControl)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerBlockMatchWindowCreateInfoQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSamplerBlockMatchWindowCreateInfoQCOM* value = wrapper->decoded_value; + VkPhysicalDeviceImageAlignmentControlPropertiesMESA* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->windowExtent = DecodeAllocator::Allocate(); - wrapper->windowExtent->decoded_value = &(value->windowExtent); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->windowExtent); - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->windowCompareMode)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedImageAlignmentMask)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicWeightsFeaturesQCOM* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageAlignmentControlCreateInfoMESA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCubicWeightsFeaturesQCOM* value = wrapper->decoded_value; + VkImageAlignmentControlCreateInfoMESA* 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)); + bytes_read += PreloadDecodePNextStruct((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->selectableCubicWeights)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maximumRequestedAlignment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerCubicWeightsCreateInfoQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildRangeInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSamplerCubicWeightsCreateInfoQCOM* value = wrapper->decoded_value; + VkAccelerationStructureBuildRangeInfoKHR* 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->cubicWeights)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->firstVertex)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->transformOffset)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBlitImageCubicWeightsInfoQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryTrianglesDataKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkBlitImageCubicWeightsInfoQCOM* value = wrapper->decoded_value; + VkAccelerationStructureGeometryTrianglesDataKHR* 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->cubicWeights)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexFormat)); + wrapper->vertexData = DecodeAllocator::Allocate(); + wrapper->vertexData->decoded_value = &(value->vertexData); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->vertexData); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertex)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); + wrapper->indexData = DecodeAllocator::Allocate(); + wrapper->indexData->decoded_value = &(value->indexData); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->indexData); + wrapper->transformData = DecodeAllocator::Allocate(); + wrapper->transformData->decoded_value = &(value->transformData); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformData); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryAabbsDataKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* value = wrapper->decoded_value; + VkAccelerationStructureGeometryAabbsDataKHR* 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->ycbcrDegamma)); + wrapper->data = DecodeAllocator::Allocate(); + wrapper->data->decoded_value = &(value->data); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryInstancesDataKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* value = wrapper->decoded_value; + VkAccelerationStructureGeometryInstancesDataKHR* 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->enableYDegamma)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->enableCbCrDegamma)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->arrayOfPointers)); + wrapper->data = DecodeAllocator::Allocate(); + wrapper->data->decoded_value = &(value->data); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicClampFeaturesQCOM* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildGeometryInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceCubicClampFeaturesQCOM* value = wrapper->decoded_value; + VkAccelerationStructureBuildGeometryInfoKHR* 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->cubicRangeClamp)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + 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->mode)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->srcAccelerationStructure)); + value->srcAccelerationStructure = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstAccelerationStructure)); + value->dstAccelerationStructure = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryCount)); + wrapper->pGeometries = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pGeometries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pGeometries = wrapper->pGeometries->GetPointer(); + wrapper->ppGeometries = DecodeAllocator::Allocate>(); + bytes_read += wrapper->ppGeometries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->ppGeometries = wrapper->ppGeometries->GetPointer(); + wrapper->scratchData = DecodeAllocator::Allocate(); + wrapper->scratchData->decoded_value = &(value->scratchData); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->scratchData); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* value = wrapper->decoded_value; + VkAccelerationStructureCreateInfoKHR* 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->attachmentFeedbackLoopDynamicState)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->createFlags)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); + value->buffer = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->offset)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredDriverPropertiesMSFT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetAccelerationStructureKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceLayeredDriverPropertiesMSFT* value = wrapper->decoded_value; + VkWriteDescriptorSetAccelerationStructureKHR* 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->underlyingAPI)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureCount)); + bytes_read += wrapper->pAccelerationStructures.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pAccelerationStructures = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAccelerationStructureFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceAccelerationStructureFeaturesKHR* 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->descriptorPoolOverallocation)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructure)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureIndirectBuild)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureHostCommands)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->descriptorBindingAccelerationStructureUpdateAfterBind)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRawAccessChainsFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAccelerationStructurePropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRawAccessChainsFeaturesNV* value = wrapper->decoded_value; + VkPhysicalDeviceAccelerationStructurePropertiesKHR* 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->shaderRawAccessChains)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxGeometryCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInstanceCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPrimitiveCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorAccelerationStructures)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPerStageDescriptorUpdateAfterBindAccelerationStructures)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetAccelerationStructures)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDescriptorSetUpdateAfterBindAccelerationStructures)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->minAccelerationStructureScratchOffsetAlignment)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureDeviceAddressInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* value = wrapper->decoded_value; + VkAccelerationStructureDeviceAddressInfoKHR* 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->shaderFloat16VectorAtomics)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->accelerationStructure)); + value->accelerationStructure = VK_NULL_HANDLE; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureVersionInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* value = wrapper->decoded_value; + VkAccelerationStructureVersionInfoKHR* 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->shaderReplicatedComposites)); + bytes_read += wrapper->pVersionData.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVersionData = wrapper->pVersionData.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyAccelerationStructureToMemoryInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceRayTracingValidationFeaturesNV* value = wrapper->decoded_value; + VkCopyAccelerationStructureToMemoryInfoKHR* 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->rayTracingValidation)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->src)); + value->src = VK_NULL_HANDLE; + wrapper->dst = DecodeAllocator::Allocate(); + wrapper->dst->decoded_value = &(value->dst); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dst); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMemoryToAccelerationStructureInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageAlignmentControlFeaturesMESA* value = wrapper->decoded_value; + VkCopyMemoryToAccelerationStructureInfoKHR* 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->imageAlignmentControl)); + wrapper->src = DecodeAllocator::Allocate(); + wrapper->src->decoded_value = &(value->src); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->src); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dst)); + value->dst = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyAccelerationStructureInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkPhysicalDeviceImageAlignmentControlPropertiesMESA* value = wrapper->decoded_value; + VkCopyAccelerationStructureInfoKHR* 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->supportedImageAlignmentMask)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->src)); + value->src = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dst)); + value->dst = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageAlignmentControlCreateInfoMESA* wrapper) +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildSizesInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); size_t bytes_read = 0; - VkImageAlignmentControlCreateInfoMESA* value = wrapper->decoded_value; + VkAccelerationStructureBuildSizesInfoKHR* 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->maximumRequestedAlignment)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->updateScratchSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->buildScratchSize)); return bytes_read; } - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildRangeInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildRangeInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19700,7 +39393,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryTrianglesDataKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryTrianglesDataKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19708,26 +39401,26 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler VkAccelerationStructureGeometryTrianglesDataKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->vertexFormat)); - wrapper->vertexData = DecodeAllocator::Allocate(); + wrapper->vertexData = PreloadDecodeAllocator::Allocate(); wrapper->vertexData->decoded_value = &(value->vertexData); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->vertexData); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->vertexData); bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexStride)); bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertex)); bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); - wrapper->indexData = DecodeAllocator::Allocate(); + wrapper->indexData = PreloadDecodeAllocator::Allocate(); wrapper->indexData->decoded_value = &(value->indexData); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->indexData); - wrapper->transformData = DecodeAllocator::Allocate(); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->indexData); + wrapper->transformData = PreloadDecodeAllocator::Allocate(); wrapper->transformData->decoded_value = &(value->transformData); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformData); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->transformData); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryAabbsDataKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryAabbsDataKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19735,17 +39428,17 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler VkAccelerationStructureGeometryAabbsDataKHR* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->data = DecodeAllocator::Allocate(); + wrapper->data = PreloadDecodeAllocator::Allocate(); wrapper->data->decoded_value = &(value->data); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data); bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryInstancesDataKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryInstancesDataKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19753,17 +39446,17 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler VkAccelerationStructureGeometryInstancesDataKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->arrayOfPointers)); - wrapper->data = DecodeAllocator::Allocate(); + wrapper->data = PreloadDecodeAllocator::Allocate(); wrapper->data->decoded_value = &(value->data); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildGeometryInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildGeometryInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19771,7 +39464,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler VkAccelerationStructureBuildGeometryInfoKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->type)); bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); @@ -19781,20 +39474,20 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dstAccelerationStructure)); value->dstAccelerationStructure = VK_NULL_HANDLE; bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->geometryCount)); - wrapper->pGeometries = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pGeometries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->pGeometries = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pGeometries->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); value->pGeometries = wrapper->pGeometries->GetPointer(); - wrapper->ppGeometries = DecodeAllocator::Allocate>(); - bytes_read += wrapper->ppGeometries->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + wrapper->ppGeometries = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->ppGeometries->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); value->ppGeometries = wrapper->ppGeometries->GetPointer(); - wrapper->scratchData = DecodeAllocator::Allocate(); + wrapper->scratchData = PreloadDecodeAllocator::Allocate(); wrapper->scratchData->decoded_value = &(value->scratchData); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->scratchData); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->scratchData); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureCreateInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureCreateInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19802,7 +39495,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler VkAccelerationStructureCreateInfoKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->createFlags)); bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->buffer)); @@ -19815,7 +39508,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetAccelerationStructureKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetAccelerationStructureKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19823,16 +39516,16 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteDe VkWriteDescriptorSetAccelerationStructureKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->accelerationStructureCount)); - bytes_read += wrapper->pAccelerationStructures.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += wrapper->pAccelerationStructures.PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); value->pAccelerationStructures = nullptr; return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAccelerationStructureFeaturesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAccelerationStructureFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19840,7 +39533,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica VkPhysicalDeviceAccelerationStructureFeaturesKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->accelerationStructure)); bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->accelerationStructureCaptureReplay)); @@ -19851,7 +39544,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAccelerationStructurePropertiesKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAccelerationStructurePropertiesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19859,7 +39552,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica VkPhysicalDeviceAccelerationStructurePropertiesKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->maxGeometryCount)); bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxInstanceCount)); @@ -19873,7 +39566,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureDeviceAddressInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureDeviceAddressInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19881,7 +39574,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler VkAccelerationStructureDeviceAddressInfoKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->accelerationStructure)); value->accelerationStructure = VK_NULL_HANDLE; @@ -19889,7 +39582,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureVersionInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureVersionInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19897,15 +39590,15 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler VkAccelerationStructureVersionInfoKHR* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += wrapper->pVersionData.DecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += wrapper->pVersionData.PreloadDecodeUInt8((buffer + bytes_read), (buffer_size - bytes_read)); value->pVersionData = wrapper->pVersionData.GetPointer(); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyAccelerationStructureToMemoryInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyAccelerationStructureToMemoryInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19913,19 +39606,19 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyAcc VkCopyAccelerationStructureToMemoryInfoKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->src)); value->src = VK_NULL_HANDLE; - wrapper->dst = DecodeAllocator::Allocate(); + wrapper->dst = PreloadDecodeAllocator::Allocate(); wrapper->dst->decoded_value = &(value->dst); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dst); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->dst); bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMemoryToAccelerationStructureInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMemoryToAccelerationStructureInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19933,11 +39626,11 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMem VkCopyMemoryToAccelerationStructureInfoKHR* 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)); + bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - wrapper->src = DecodeAllocator::Allocate(); + wrapper->src = PreloadDecodeAllocator::Allocate(); wrapper->src->decoded_value = &(value->src); - bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->src); + bytes_read += PreloadDecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->src); bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->dst)); value->dst = VK_NULL_HANDLE; bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); @@ -19945,7 +39638,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyMem return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyAccelerationStructureInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyAccelerationStructureInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19953,7 +39646,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyAcc VkCopyAccelerationStructureInfoKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->src)); value->src = VK_NULL_HANDLE; @@ -19964,7 +39657,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCopyAcc return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildSizesInfoKHR* wrapper) +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildSizesInfoKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19972,7 +39665,7 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAcceler VkAccelerationStructureBuildSizesInfoKHR* 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)); + bytes_read += PreloadDecodePNextStruct((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->accelerationStructureSize)); bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->updateScratchSize)); @@ -20124,6 +39817,149 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTraceRa return bytes_read; } +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRayTracingShaderGroupCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRayTracingShaderGroupCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->generalShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->closestHitShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->anyHitShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->intersectionShader)); + bytes_read += ValueDecoder::DecodeAddress((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pShaderGroupCaptureReplayHandle)); + value->pShaderGroupCaptureReplayHandle = nullptr; + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRayTracingPipelineInterfaceCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRayTracingPipelineInterfaceCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxPipelineRayPayloadSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPipelineRayHitAttributeSize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRayTracingPipelineCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRayTracingPipelineCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->stageCount)); + wrapper->pStages = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pStages->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStages = wrapper->pStages->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupCount)); + wrapper->pGroups = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pGroups->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pGroups = wrapper->pGroups->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPipelineRayRecursionDepth)); + wrapper->pLibraryInfo = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pLibraryInfo->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLibraryInfo = wrapper->pLibraryInfo->GetPointer(); + wrapper->pLibraryInterface = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pLibraryInterface->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLibraryInterface = wrapper->pLibraryInterface->GetPointer(); + wrapper->pDynamicState = PreloadDecodeAllocator::Allocate>(); + bytes_read += wrapper->pDynamicState->PreloadDecode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDynamicState = wrapper->pDynamicState->GetPointer(); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->layout)); + value->layout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->basePipelineHandle)); + value->basePipelineHandle = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->basePipelineIndex)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPipelineFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceRayTracingPipelineFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->rayTracingPipeline)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPipelineShaderGroupHandleCaptureReplay)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPipelineShaderGroupHandleCaptureReplayMixed)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTracingPipelineTraceRaysIndirect)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->rayTraversalPrimitiveCulling)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPipelinePropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceRayTracingPipelinePropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->shaderGroupHandleSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRayRecursionDepth)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxShaderGroupStride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderGroupBaseAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderGroupHandleCaptureReplaySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRayDispatchInvocationCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderGroupHandleAlignment)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRayHitAttributeSize)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkStridedDeviceAddressRegionKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkStridedDeviceAddressRegionKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTraceRaysIndirectCommandKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkTraceRaysIndirectCommandKHR* value = wrapper->decoded_value; + + 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_VkPhysicalDeviceRayQueryFeaturesKHR* wrapper) { @@ -20139,6 +39975,20 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica return bytes_read; } +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayQueryFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceRayQueryFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->rayQuery)); + + return bytes_read; +} size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderFeaturesEXT* wrapper) { @@ -20218,6 +40068,84 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrawMes return bytes_read; } +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderFeaturesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMeshShaderFeaturesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->taskShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->multiviewMeshShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->primitiveFragmentShadingRateMeshShader)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshShaderQueries)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderPropertiesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceMeshShaderPropertiesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += PreloadDecodePNextStruct((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->maxTaskWorkGroupTotalCount)); + wrapper->maxTaskWorkGroupCount.SetExternalMemory(value->maxTaskWorkGroupCount, 3); + bytes_read += wrapper->maxTaskWorkGroupCount.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskWorkGroupInvocations)); + wrapper->maxTaskWorkGroupSize.SetExternalMemory(value->maxTaskWorkGroupSize, 3); + bytes_read += wrapper->maxTaskWorkGroupSize.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskPayloadSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskSharedMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxTaskPayloadAndSharedMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshWorkGroupTotalCount)); + wrapper->maxMeshWorkGroupCount.SetExternalMemory(value->maxMeshWorkGroupCount, 3); + bytes_read += wrapper->maxMeshWorkGroupCount.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshWorkGroupInvocations)); + wrapper->maxMeshWorkGroupSize.SetExternalMemory(value->maxMeshWorkGroupSize, 3); + bytes_read += wrapper->maxMeshWorkGroupSize.PreloadDecodeUInt32((buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshSharedMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshPayloadAndSharedMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshPayloadAndOutputMemorySize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputComponents)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputVertices)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputPrimitives)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshOutputLayers)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxMeshMultiviewViewCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshOutputPerVertexGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->meshOutputPerPrimitiveGranularity)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPreferredTaskWorkGroupInvocations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPreferredMeshWorkGroupInvocations)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersLocalInvocationVertexOutput)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersLocalInvocationPrimitiveOutput)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersCompactVertexOutput)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->prefersCompactPrimitiveOutput)); + + return bytes_read; +} + +size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrawMeshTasksIndirectCommandEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDrawMeshTasksIndirectCommandEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupCountX)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupCountY)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->groupCountZ)); + + return bytes_read; +} GFXRECON_END_NAMESPACE(decode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/generated/generated_vulkan_struct_decoders_forward.h b/framework/generated/generated_vulkan_struct_decoders_forward.h index 0bd3c5e9e5..a270f6b489 100644 --- a/framework/generated/generated_vulkan_struct_decoders_forward.h +++ b/framework/generated/generated_vulkan_struct_decoders_forward.h @@ -415,6 +415,190 @@ 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_VkImageCopy* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageResolve* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassBeginInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH264SpsVuiFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH264HrdParameters* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH264SequenceParameterSetVui* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH264SpsFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH264ScalingLists* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH264SequenceParameterSet* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH264PpsFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH264PictureParameterSet* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeH264PictureInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeH264PictureInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeH264ReferenceInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeH264ReferenceInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264WeightTableFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264WeightTable* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264SliceHeaderFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264PictureInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264ReferenceInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264ReferenceListsInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264RefListModEntry* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264RefPicMarkingEntry* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264ReferenceListsInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264PictureInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264ReferenceInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH264SliceHeader* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265ProfileTierLevelFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265ProfileTierLevel* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265DecPicBufMgr* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265SubLayerHrdParameters* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265HrdFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265HrdParameters* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265VpsFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265VideoParameterSet* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265ScalingLists* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265ShortTermRefPicSetFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265ShortTermRefPicSet* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265LongTermRefPicsSps* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265SpsVuiFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265SequenceParameterSetVui* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265PredictorPaletteEntries* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265SpsFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265SequenceParameterSet* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265PpsFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoH265PictureParameterSet* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeH265PictureInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeH265PictureInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeH265ReferenceInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeH265ReferenceInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265WeightTableFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265WeightTable* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265LongTermRefPics* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265SliceSegmentHeaderFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265SliceSegmentHeader* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265ReferenceListsInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265ReferenceListsInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265PictureInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265PictureInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265ReferenceInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoEncodeH265ReferenceInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1ColorConfigFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1ColorConfig* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1TimingInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1TimingInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1SequenceHeaderFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1SequenceHeader* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1LoopFilterFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1LoopFilter* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1QuantizationFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1Quantization* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1Segmentation* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1TileInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1TileInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1CDEF* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1LoopRestoration* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1GlobalMotion* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1FilmGrainFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoAV1FilmGrain* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeAV1PictureInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeAV1PictureInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeAV1ReferenceInfoFlags* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_StdVideoDecodeAV1ReferenceInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExtent2D* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExtent3D* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOffset2D* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOffset3D* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRect2D* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferMemoryBarrier* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDispatchIndirectCommand* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrawIndexedIndirectCommand* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrawIndirectCommand* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageSubresourceRange* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageMemoryBarrier* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryBarrier* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCacheHeaderVersionOne* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAllocationCallbacks* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkApplicationInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFormatProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageFormatProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkInstanceCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryHeap* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryType* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLimits* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSparseProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceQueueCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExtensionProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLayerProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubmitInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMappedMemoryRange* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryAllocateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryRequirements* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSparseMemoryBind* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSparseBufferMemoryBindInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSparseImageOpaqueMemoryBindInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageSubresource* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSparseImageMemoryBind* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSparseImageMemoryBindInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindSparseInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSparseImageFormatProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSparseImageMemoryRequirements* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFenceCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkEventCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueryPoolCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferViewCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubresourceLayout* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkComponentMapping* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderModuleCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCacheCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSpecializationMapEntry* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSpecializationInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineShaderStageCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkComputePipelineCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVertexInputBindingDescription* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVertexInputAttributeDescription* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineVertexInputStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineInputAssemblyStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineTessellationStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkViewport* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineMultisampleStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkStencilOpState* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineDepthStencilStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineColorBlendAttachmentState* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineColorBlendStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineDynamicStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGraphicsPipelineCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPushConstantRange* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineLayoutCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyDescriptorSet* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorBufferInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorPoolSize* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorPoolCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetAllocateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutBinding* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAttachmentDescription* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAttachmentReference* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFramebufferCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassDescription* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassDependency* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandPoolCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferAllocateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferBeginInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferCopy* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageSubresourceLayers* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferImageCopy* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkClearDepthStencilValue* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkClearAttachment* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkClearRect* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageBlit* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageCopy* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageResolve* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassBeginInfo* wrapper); struct Decoded_VkPhysicalDeviceSubgroupProperties; struct Decoded_VkBindBufferMemoryInfo; @@ -553,6 +737,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_VkPhysicalDeviceMaintenance3Properties* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutSupport* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderDrawParametersFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindBufferMemoryInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindImageMemoryInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevice16BitStorageFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryDedicatedRequirements* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryDedicatedAllocateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryAllocateFlagsInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupRenderPassBeginInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupCommandBufferBeginInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupSubmitInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupBindSparseInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindBufferMemoryDeviceGroupInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindImageMemoryDeviceGroupInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGroupProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupDeviceCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferMemoryRequirementsInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageMemoryRequirementsInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageSparseMemoryRequirementsInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryRequirements2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSparseImageMemoryRequirements2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFeatures2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProperties2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFormatProperties2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageFormatProperties2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageFormatInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyProperties2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryProperties2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSparseImageFormatProperties2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSparseImageFormatInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePointClippingProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkInputAttachmentAspectReference* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassInputAttachmentAspectCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewUsageCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineTessellationDomainOriginStateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassMultiviewCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVariablePointersFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProtectedMemoryFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProtectedMemoryProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceQueueInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkProtectedSubmitInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindImagePlaneMemoryInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImagePlaneMemoryRequirementsInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSamplerYcbcrConversionFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionImageFormatProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorUpdateTemplateEntry* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorUpdateTemplateCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalMemoryProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalImageFormatInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalImageFormatProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalBufferInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalBufferProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceIDProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalMemoryImageCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalMemoryBufferCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportMemoryAllocateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFenceInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalFenceProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportFenceCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportSemaphoreCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalSemaphoreInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalSemaphoreProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance3Properties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutSupport* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderDrawParametersFeatures* wrapper); struct Decoded_VkPhysicalDeviceVulkan11Features; struct Decoded_VkPhysicalDeviceVulkan11Properties; @@ -657,6 +909,57 @@ 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_VkBufferOpaqueCaptureAddressCreateInfo* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryOpaqueCaptureAddressAllocateInfo* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceMemoryOpaqueCaptureAddressInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan11Features* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan11Properties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan12Features* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkConformanceVersion* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan12Properties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageFormatListCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAttachmentDescription2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAttachmentReference2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassDescription2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassDependency2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassCreateInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassBeginInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassEndInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevice8BitStorageFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDriverProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicInt64Features* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderFloat16Int8Features* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFloatControlsProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutBindingFlagsCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorIndexingFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorIndexingProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetVariableDescriptorCountAllocateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetVariableDescriptorCountLayoutSupport* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassDescriptionDepthStencilResolve* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthStencilResolveProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceScalarBlockLayoutFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageStencilUsageCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerReductionModeCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSamplerFilterMinmaxProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkanMemoryModelFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImagelessFramebufferFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFramebufferAttachmentImageInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFramebufferAttachmentsCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassAttachmentBeginInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceUniformBufferStandardLayoutFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAttachmentReferenceStencilLayout* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAttachmentDescriptionStencilLayout* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostQueryResetFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTimelineSemaphoreFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTimelineSemaphoreProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreTypeCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTimelineSemaphoreSubmitInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreWaitInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreSignalInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBufferDeviceAddressFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferDeviceAddressInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferOpaqueCaptureAddressCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryOpaqueCaptureAddressAllocateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceMemoryOpaqueCaptureAddressInfo* wrapper); struct Decoded_VkPhysicalDeviceVulkan13Features; struct Decoded_VkPhysicalDeviceVulkan13Properties; @@ -765,12 +1068,67 @@ 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_VkPhysicalDeviceMaintenance4Properties* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceBufferMemoryRequirements* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceImageMemoryRequirements* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan13Features* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVulkan13Properties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCreationFeedback* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCreationFeedbackCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTerminateInvocationFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceToolProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrivateDataFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDevicePrivateDataCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPrivateDataSlotCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineCreationCacheControlFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryBarrier2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferMemoryBarrier2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageMemoryBarrier2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDependencyInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreSubmitInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferSubmitInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubmitInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSynchronization2Features* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageRobustnessFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferCopy2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyBufferInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageCopy2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyImageInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferImageCopy2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyBufferToImageInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyImageToBufferInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageBlit2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBlitImageInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageResolve2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkResolveImageInfo2* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupSizeControlFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubgroupSizeControlProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInlineUniformBlockFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInlineUniformBlockProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetInlineUniformBlock* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorPoolInlineUniformBlockCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTextureCompressionASTCHDRFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingAttachmentInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRenderingCreateInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceRenderingInfo* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerDotProductFeatures* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerDotProductProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTexelBufferAlignmentProperties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFormatProperties3* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance4Features* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance4Properties* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceBufferMemoryRequirements* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceImageMemoryRequirements* wrapper); struct Decoded_VkSurfaceCapabilitiesKHR; struct Decoded_VkSurfaceFormatKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceFormatKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceFormatKHR* wrapper); struct Decoded_VkSwapchainCreateInfoKHR; struct Decoded_VkPresentInfoKHR; @@ -789,6 +1147,14 @@ 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_VkDeviceGroupPresentCapabilitiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupPresentInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupSwapchainCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageSwapchainCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindImageMemorySwapchainInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAcquireNextImageInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupPresentCapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupPresentInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceGroupSwapchainCreateInfoKHR* wrapper); struct Decoded_VkDisplayModeParametersKHR; struct Decoded_VkDisplayModeCreateInfoKHR; @@ -805,30 +1171,43 @@ 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_VkDisplayPlanePropertiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPropertiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplaySurfaceCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayModeParametersKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayModeCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayModePropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPlaneCapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPlanePropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplaySurfaceCreateInfoKHR* wrapper); struct Decoded_VkDisplayPresentInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPresentInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPresentInfoKHR* wrapper); struct Decoded_VkXlibSurfaceCreateInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkXlibSurfaceCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkXlibSurfaceCreateInfoKHR* wrapper); struct Decoded_VkXcbSurfaceCreateInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkXcbSurfaceCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkXcbSurfaceCreateInfoKHR* wrapper); struct Decoded_VkWaylandSurfaceCreateInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWaylandSurfaceCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWaylandSurfaceCreateInfoKHR* wrapper); struct Decoded_VkAndroidSurfaceCreateInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAndroidSurfaceCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAndroidSurfaceCreateInfoKHR* wrapper); struct Decoded_VkWin32SurfaceCreateInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWin32SurfaceCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWin32SurfaceCreateInfoKHR* wrapper); struct Decoded_VkQueueFamilyQueryResultStatusPropertiesKHR; struct Decoded_VkQueueFamilyVideoPropertiesKHR; @@ -865,6 +1244,23 @@ 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_VkVideoBeginCodingInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEndCodingInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoCodingControlInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyQueryResultStatusPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyVideoPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoProfileInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoProfileListInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoCapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoFormatInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoFormatPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoPictureResourceInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoReferenceSlotInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoSessionMemoryRequirementsKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindVideoSessionMemoryInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoSessionCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoSessionParametersCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoSessionParametersUpdateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoBeginCodingInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEndCodingInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoCodingControlInfoKHR* wrapper); struct Decoded_VkVideoDecodeCapabilitiesKHR; struct Decoded_VkVideoDecodeUsageInfoKHR; @@ -873,6 +1269,9 @@ struct Decoded_VkVideoDecodeInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeCapabilitiesKHR* wrapper); 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); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeCapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeUsageInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeInfoKHR* wrapper); struct Decoded_VkVideoEncodeH264CapabilitiesKHR; struct Decoded_VkVideoEncodeH264QpKHR; @@ -907,6 +1306,22 @@ 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_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); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264CapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QpKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264QualityLevelPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersAddInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersGetInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264SessionParametersFeedbackInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264NaluSliceInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264PictureInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264DpbSlotInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264ProfileInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264FrameSizeKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264RateControlLayerInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH264GopRemainingFrameInfoKHR* wrapper); struct Decoded_VkVideoEncodeH265CapabilitiesKHR; struct Decoded_VkVideoEncodeH265SessionCreateInfoKHR; @@ -941,6 +1356,22 @@ 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_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); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265CapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QpKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265QualityLevelPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersAddInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersGetInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265SessionParametersFeedbackInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265NaluSliceSegmentInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265PictureInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265DpbSlotInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265ProfileInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265FrameSizeKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265RateControlLayerInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeH265GopRemainingFrameInfoKHR* wrapper); struct Decoded_VkVideoDecodeH264ProfileInfoKHR; struct Decoded_VkVideoDecodeH264CapabilitiesKHR; @@ -955,6 +1386,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_VkVideoDecodeH264SessionParametersCreateInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH264PictureInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH264DpbSlotInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH264ProfileInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH264CapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH264SessionParametersAddInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH264SessionParametersCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH264PictureInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH264DpbSlotInfoKHR* wrapper); struct Decoded_VkRenderingFragmentShadingRateAttachmentInfoKHR; struct Decoded_VkRenderingFragmentDensityMapAttachmentInfoEXT; @@ -965,6 +1402,10 @@ 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_VkRenderingFragmentDensityMapAttachmentInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAttachmentSampleCountInfoAMD* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultiviewPerViewAttributesInfoNVX* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingFragmentShadingRateAttachmentInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingFragmentDensityMapAttachmentInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAttachmentSampleCountInfoAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultiviewPerViewAttributesInfoNVX* wrapper); struct Decoded_VkImportMemoryWin32HandleInfoKHR; struct Decoded_VkExportMemoryWin32HandleInfoKHR; @@ -975,6 +1416,10 @@ 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_VkExportMemoryWin32HandleInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryWin32HandlePropertiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryGetWin32HandleInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportMemoryWin32HandleInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryWin32HandlePropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryGetWin32HandleInfoKHR* wrapper); struct Decoded_VkImportMemoryFdInfoKHR; struct Decoded_VkMemoryFdPropertiesKHR; @@ -983,10 +1428,14 @@ struct Decoded_VkMemoryGetFdInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportMemoryFdInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryFdPropertiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryGetFdInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportMemoryFdInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryFdPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryGetFdInfoKHR* wrapper); struct Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoKHR* wrapper); struct Decoded_VkImportSemaphoreWin32HandleInfoKHR; struct Decoded_VkExportSemaphoreWin32HandleInfoKHR; @@ -997,16 +1446,23 @@ 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_VkExportSemaphoreWin32HandleInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkD3D12FenceSubmitInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreGetWin32HandleInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportSemaphoreWin32HandleInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportSemaphoreWin32HandleInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkD3D12FenceSubmitInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreGetWin32HandleInfoKHR* wrapper); struct Decoded_VkImportSemaphoreFdInfoKHR; struct Decoded_VkSemaphoreGetFdInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportSemaphoreFdInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreGetFdInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportSemaphoreFdInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreGetFdInfoKHR* wrapper); struct Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePushDescriptorPropertiesKHR* wrapper); struct Decoded_VkRectLayerKHR; struct Decoded_VkPresentRegionKHR; @@ -1015,10 +1471,14 @@ struct Decoded_VkPresentRegionsKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRectLayerKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentRegionKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentRegionsKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRectLayerKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentRegionKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentRegionsKHR* wrapper); struct Decoded_VkSharedPresentSurfaceCapabilitiesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSharedPresentSurfaceCapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSharedPresentSurfaceCapabilitiesKHR* wrapper); struct Decoded_VkImportFenceWin32HandleInfoKHR; struct Decoded_VkExportFenceWin32HandleInfoKHR; @@ -1027,12 +1487,17 @@ struct Decoded_VkFenceGetWin32HandleInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportFenceWin32HandleInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportFenceWin32HandleInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFenceGetWin32HandleInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportFenceWin32HandleInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportFenceWin32HandleInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFenceGetWin32HandleInfoKHR* wrapper); struct Decoded_VkImportFenceFdInfoKHR; struct Decoded_VkFenceGetFdInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportFenceFdInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFenceGetFdInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportFenceFdInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFenceGetFdInfoKHR* wrapper); struct Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR; struct Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR; @@ -1049,6 +1514,13 @@ 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_VkQueryPoolPerformanceCreateInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAcquireProfilingLockInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceQuerySubmitInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerformanceQueryPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceCounterKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceCounterDescriptionKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueryPoolPerformanceCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAcquireProfilingLockInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceQuerySubmitInfoKHR* wrapper); struct Decoded_VkPhysicalDeviceSurfaceInfo2KHR; struct Decoded_VkSurfaceCapabilities2KHR; @@ -1057,6 +1529,9 @@ struct Decoded_VkSurfaceFormat2KHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSurfaceInfo2KHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilities2KHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceFormat2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSurfaceInfo2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilities2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceFormat2KHR* wrapper); struct Decoded_VkDisplayProperties2KHR; struct Decoded_VkDisplayPlaneProperties2KHR; @@ -1069,16 +1544,24 @@ 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_VkDisplayModeProperties2KHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPlaneInfo2KHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPlaneCapabilities2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayProperties2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPlaneProperties2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayModeProperties2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPlaneInfo2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPlaneCapabilities2KHR* wrapper); struct Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR; struct Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePortabilitySubsetPropertiesKHR* wrapper); struct Decoded_VkPhysicalDeviceShaderClockFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderClockFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderClockFeaturesKHR* wrapper); struct Decoded_VkVideoDecodeH265ProfileInfoKHR; struct Decoded_VkVideoDecodeH265CapabilitiesKHR; @@ -1093,6 +1576,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_VkVideoDecodeH265SessionParametersCreateInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH265PictureInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH265DpbSlotInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH265ProfileInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH265CapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH265SessionParametersAddInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH265SessionParametersCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH265PictureInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeH265DpbSlotInfoKHR* wrapper); struct Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR; struct Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR; @@ -1101,6 +1590,9 @@ struct Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceQueueGlobalPriorityCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyGlobalPriorityPropertiesKHR* wrapper); struct Decoded_VkFragmentShadingRateAttachmentInfoKHR; struct Decoded_VkPipelineFragmentShadingRateStateCreateInfoKHR; @@ -1113,6 +1605,11 @@ 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_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFragmentShadingRateAttachmentInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineFragmentShadingRateStateCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRatePropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateKHR* wrapper); struct Decoded_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR; struct Decoded_VkRenderingAttachmentLocationInfoKHR; @@ -1121,18 +1618,24 @@ struct Decoded_VkRenderingInputAttachmentIndexInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingAttachmentLocationInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingInputAttachmentIndexInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingAttachmentLocationInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingInputAttachmentIndexInfoKHR* wrapper); struct Decoded_VkPhysicalDeviceShaderQuadControlFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderQuadControlFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderQuadControlFeaturesKHR* wrapper); struct Decoded_VkSurfaceProtectedCapabilitiesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceProtectedCapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceProtectedCapabilitiesKHR* wrapper); struct Decoded_VkPhysicalDevicePresentWaitFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentWaitFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentWaitFeaturesKHR* wrapper); struct Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; struct Decoded_VkPipelineInfoKHR; @@ -1147,22 +1650,33 @@ 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_VkPipelineExecutableInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineExecutableStatisticKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineExecutableInternalRepresentationKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineExecutablePropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineExecutableInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineExecutableStatisticKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineExecutableInternalRepresentationKHR* wrapper); struct Decoded_VkMemoryMapInfoKHR; struct Decoded_VkMemoryUnmapInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryMapInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryUnmapInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryMapInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryUnmapInfoKHR* wrapper); struct Decoded_VkPipelineLibraryCreateInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineLibraryCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineLibraryCreateInfoKHR* wrapper); struct Decoded_VkPresentIdKHR; struct Decoded_VkPhysicalDevicePresentIdFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentIdKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentIdFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentIdKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentIdFeaturesKHR* wrapper); struct Decoded_VkVideoEncodeInfoKHR; struct Decoded_VkVideoEncodeCapabilitiesKHR; @@ -1187,40 +1701,61 @@ 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_VkVideoEncodeQualityLevelInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersGetInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersFeedbackInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeCapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeUsageInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeRateControlLayerInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeRateControlInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeQualityLevelInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersGetInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoEncodeSessionParametersFeedbackInfoKHR* wrapper); struct Decoded_VkQueueFamilyCheckpointProperties2NV; struct Decoded_VkCheckpointData2NV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointProperties2NV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCheckpointData2NV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointProperties2NV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCheckpointData2NV* wrapper); struct Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; struct Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* wrapper); struct Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR; struct Decoded_VkTraceRaysIndirectCommand2KHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTraceRaysIndirectCommand2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTraceRaysIndirectCommand2KHR* wrapper); struct Decoded_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR; struct Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR; @@ -1239,10 +1774,19 @@ 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_VkSubresourceLayout2KHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCreateFlags2CreateInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferUsageFlags2CreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingAreaInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageSubresource2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceImageSubresourceInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubresourceLayout2KHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCreateFlags2CreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferUsageFlags2CreateInfoKHR* wrapper); struct Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* wrapper); struct Decoded_VkCooperativeMatrixPropertiesKHR; struct Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR; @@ -1251,6 +1795,9 @@ struct Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCooperativeMatrixPropertiesKHR* wrapper); 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); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCooperativeMatrixPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* wrapper); struct Decoded_VkVideoDecodeAV1ProfileInfoKHR; struct Decoded_VkVideoDecodeAV1CapabilitiesKHR; @@ -1263,12 +1810,19 @@ 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_VkVideoDecodeAV1SessionParametersCreateInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1PictureInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1DpbSlotInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1ProfileInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1CapabilitiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1SessionParametersCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1PictureInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoDecodeAV1DpbSlotInfoKHR* 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); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVideoMaintenance1FeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVideoInlineQueryInfoKHR* wrapper); struct Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR; struct Decoded_VkVertexInputBindingDivisorDescriptionKHR; @@ -1279,14 +1833,20 @@ 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_VkVertexInputBindingDivisorDescriptionKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVertexInputBindingDivisorDescriptionKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceShaderFloatControls2FeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderFloatControls2FeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceIndexTypeUint8FeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceIndexTypeUint8FeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceLineRasterizationFeaturesKHR; struct Decoded_VkPhysicalDeviceLineRasterizationPropertiesKHR; @@ -1295,14 +1855,19 @@ struct Decoded_VkPipelineRasterizationLineStateCreateInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationFeaturesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationPropertiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationLineStateCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLineRasterizationPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationLineStateCreateInfoKHR* wrapper); struct Decoded_VkCalibratedTimestampInfoKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoKHR* wrapper); struct Decoded_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderExpectAssumeFeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR; struct Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR; @@ -1321,10 +1886,19 @@ 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_VkPushDescriptorSetInfoKHR* 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); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6FeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance6PropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindMemoryStatusKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindDescriptorSetsInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPushConstantsInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPushDescriptorSetInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSetDescriptorBufferOffsetsInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindDescriptorBufferEmbeddedSamplersInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceMaintenance7FeaturesKHR; struct Decoded_VkPhysicalDeviceMaintenance7PropertiesKHR; @@ -1337,14 +1911,21 @@ 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_VkPhysicalDeviceLayeredApiPropertiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiPropertiesListKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance7FeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance7PropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiPropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiPropertiesListKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredApiVulkanPropertiesKHR* wrapper); struct Decoded_VkDebugReportCallbackCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugReportCallbackCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugReportCallbackCreateInfoEXT* wrapper); struct Decoded_VkPipelineRasterizationStateRasterizationOrderAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateRasterizationOrderAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateRasterizationOrderAMD* wrapper); struct Decoded_VkDebugMarkerObjectNameInfoEXT; struct Decoded_VkDebugMarkerObjectTagInfoEXT; @@ -1353,6 +1934,9 @@ struct Decoded_VkDebugMarkerMarkerInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectTagInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugMarkerMarkerInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugMarkerObjectTagInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugMarkerMarkerInfoEXT* wrapper); struct Decoded_VkDedicatedAllocationImageCreateInfoNV; struct Decoded_VkDedicatedAllocationBufferCreateInfoNV; @@ -1361,6 +1945,9 @@ struct Decoded_VkDedicatedAllocationMemoryAllocateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDedicatedAllocationImageCreateInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDedicatedAllocationBufferCreateInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDedicatedAllocationMemoryAllocateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDedicatedAllocationImageCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDedicatedAllocationBufferCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDedicatedAllocationMemoryAllocateInfoNV* wrapper); struct Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT; struct Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT; @@ -1369,64 +1956,84 @@ struct Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTransformFeedbackPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationStateStreamCreateInfoEXT* wrapper); struct Decoded_VkImageViewHandleInfoNVX; 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); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewHandleInfoNVX* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewAddressPropertiesNVX* wrapper); struct Decoded_VkTextureLODGatherFormatPropertiesAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTextureLODGatherFormatPropertiesAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTextureLODGatherFormatPropertiesAMD* wrapper); struct Decoded_VkShaderResourceUsageAMD; struct Decoded_VkShaderStatisticsInfoAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderResourceUsageAMD* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderStatisticsInfoAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderResourceUsageAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderStatisticsInfoAMD* wrapper); struct Decoded_VkStreamDescriptorSurfaceCreateInfoGGP; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkStreamDescriptorSurfaceCreateInfoGGP* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkStreamDescriptorSurfaceCreateInfoGGP* wrapper); struct Decoded_VkPhysicalDeviceCornerSampledImageFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCornerSampledImageFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCornerSampledImageFeaturesNV* wrapper); struct Decoded_VkExternalImageFormatPropertiesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalImageFormatPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalImageFormatPropertiesNV* wrapper); struct Decoded_VkExternalMemoryImageCreateInfoNV; struct Decoded_VkExportMemoryAllocateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalMemoryImageCreateInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportMemoryAllocateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalMemoryImageCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportMemoryAllocateInfoNV* wrapper); struct Decoded_VkImportMemoryWin32HandleInfoNV; struct Decoded_VkExportMemoryWin32HandleInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportMemoryWin32HandleInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportMemoryWin32HandleInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExportMemoryWin32HandleInfoNV* wrapper); struct Decoded_VkWin32KeyedMutexAcquireReleaseInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWin32KeyedMutexAcquireReleaseInfoNV* wrapper); struct Decoded_VkValidationFlagsEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkValidationFlagsEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkValidationFlagsEXT* wrapper); struct Decoded_VkViSurfaceCreateInfoNN; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkViSurfaceCreateInfoNN* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkViSurfaceCreateInfoNN* wrapper); struct Decoded_VkImageViewASTCDecodeModeEXT; struct Decoded_VkPhysicalDeviceASTCDecodeFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewASTCDecodeModeEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceASTCDecodeFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewASTCDecodeModeEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceASTCDecodeFeaturesEXT* wrapper); struct Decoded_VkPhysicalDevicePipelineRobustnessFeaturesEXT; struct Decoded_VkPhysicalDevicePipelineRobustnessPropertiesEXT; @@ -1435,6 +2042,9 @@ struct Decoded_VkPipelineRobustnessCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRobustnessCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineRobustnessPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRobustnessCreateInfoEXT* wrapper); struct Decoded_VkConditionalRenderingBeginInfoEXT; struct Decoded_VkPhysicalDeviceConditionalRenderingFeaturesEXT; @@ -1443,16 +2053,22 @@ struct Decoded_VkCommandBufferInheritanceConditionalRenderingInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkConditionalRenderingBeginInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConditionalRenderingFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceConditionalRenderingInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkConditionalRenderingBeginInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConditionalRenderingFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceConditionalRenderingInfoEXT* wrapper); struct Decoded_VkViewportWScalingNV; struct Decoded_VkPipelineViewportWScalingStateCreateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkViewportWScalingNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportWScalingStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkViewportWScalingNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportWScalingStateCreateInfoNV* wrapper); struct Decoded_VkSurfaceCapabilities2EXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilities2EXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilities2EXT* wrapper); struct Decoded_VkDisplayPowerInfoEXT; struct Decoded_VkDeviceEventInfoEXT; @@ -1463,6 +2079,10 @@ 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_VkDeviceEventInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayEventInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainCounterCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayPowerInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceEventInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayEventInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainCounterCreateInfoEXT* wrapper); struct Decoded_VkRefreshCycleDurationGOOGLE; struct Decoded_VkPastPresentationTimingGOOGLE; @@ -1473,52 +2093,70 @@ 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_VkPastPresentationTimingGOOGLE* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentTimeGOOGLE* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentTimesInfoGOOGLE* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRefreshCycleDurationGOOGLE* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPastPresentationTimingGOOGLE* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentTimeGOOGLE* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentTimesInfoGOOGLE* wrapper); struct Decoded_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* wrapper); struct Decoded_VkViewportSwizzleNV; struct Decoded_VkPipelineViewportSwizzleStateCreateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkViewportSwizzleNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportSwizzleStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkViewportSwizzleNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportSwizzleStateCreateInfoNV* wrapper); struct Decoded_VkPhysicalDeviceDiscardRectanglePropertiesEXT; struct Decoded_VkPipelineDiscardRectangleStateCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiscardRectanglePropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineDiscardRectangleStateCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiscardRectanglePropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineDiscardRectangleStateCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceConservativeRasterizationPropertiesEXT; struct Decoded_VkPipelineRasterizationConservativeStateCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationConservativeStateCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationConservativeStateCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceDepthClipEnableFeaturesEXT; struct Decoded_VkPipelineRasterizationDepthClipStateCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipEnableFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationDepthClipStateCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipEnableFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationDepthClipStateCreateInfoEXT* wrapper); struct Decoded_VkXYColorEXT; struct Decoded_VkHdrMetadataEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkXYColorEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkHdrMetadataEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkXYColorEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkHdrMetadataEXT* wrapper); struct Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* wrapper); struct Decoded_VkIOSSurfaceCreateInfoMVK; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIOSSurfaceCreateInfoMVK* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIOSSurfaceCreateInfoMVK* wrapper); struct Decoded_VkMacOSSurfaceCreateInfoMVK; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMacOSSurfaceCreateInfoMVK* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMacOSSurfaceCreateInfoMVK* wrapper); struct Decoded_VkDebugUtilsLabelEXT; struct Decoded_VkDebugUtilsObjectNameInfoEXT; @@ -1531,6 +2169,11 @@ 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_VkDebugUtilsMessengerCallbackDataEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugUtilsMessengerCreateInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugUtilsObjectTagInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugUtilsLabelEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugUtilsObjectNameInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugUtilsMessengerCallbackDataEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugUtilsMessengerCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugUtilsObjectTagInfoEXT* wrapper); struct Decoded_VkAndroidHardwareBufferUsageANDROID; struct Decoded_VkAndroidHardwareBufferPropertiesANDROID; @@ -1547,6 +2190,13 @@ 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_VkMemoryGetAndroidHardwareBufferInfoANDROID* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalFormatANDROID* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatProperties2ANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferUsageANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferPropertiesANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatPropertiesANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportAndroidHardwareBufferInfoANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryGetAndroidHardwareBufferInfoANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalFormatANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatProperties2ANDROID* wrapper); struct Decoded_VkSampleLocationEXT; struct Decoded_VkSampleLocationsInfoEXT; @@ -1565,6 +2215,14 @@ 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_VkPipelineSampleLocationsStateCreateInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSampleLocationsPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultisamplePropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSampleLocationEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSampleLocationsInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAttachmentSampleLocationsEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassSampleLocationsEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassSampleLocationsBeginInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineSampleLocationsStateCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSampleLocationsPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultisamplePropertiesEXT* wrapper); struct Decoded_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; struct Decoded_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; @@ -1573,20 +2231,27 @@ struct Decoded_VkPipelineColorBlendAdvancedStateCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineColorBlendAdvancedStateCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineColorBlendAdvancedStateCreateInfoEXT* wrapper); struct Decoded_VkPipelineCoverageToColorStateCreateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCoverageToColorStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCoverageToColorStateCreateInfoNV* wrapper); struct Decoded_VkPipelineCoverageModulationStateCreateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCoverageModulationStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCoverageModulationStateCreateInfoNV* wrapper); struct Decoded_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; struct Decoded_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* wrapper); struct Decoded_VkDrmFormatModifierPropertiesEXT; struct Decoded_VkDrmFormatModifierPropertiesListEXT; @@ -1605,12 +2270,22 @@ 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_VkImageDrmFormatModifierPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrmFormatModifierProperties2EXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesList2EXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesListEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierListCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierExplicitCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageDrmFormatModifierPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrmFormatModifierProperties2EXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrmFormatModifierPropertiesList2EXT* wrapper); struct Decoded_VkValidationCacheCreateInfoEXT; struct Decoded_VkShaderModuleValidationCacheCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkValidationCacheCreateInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderModuleValidationCacheCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkValidationCacheCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderModuleValidationCacheCreateInfoEXT* wrapper); struct Decoded_VkShadingRatePaletteNV; struct Decoded_VkPipelineViewportShadingRateImageStateCreateInfoNV; @@ -1627,6 +2302,13 @@ 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_VkCoarseSampleLocationNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCoarseSampleOrderCustomNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShadingRatePaletteNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportShadingRateImageStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShadingRateImageFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShadingRateImagePropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCoarseSampleLocationNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCoarseSampleOrderCustomNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* wrapper); struct Decoded_VkRayTracingShaderGroupCreateInfoNV; struct Decoded_VkRayTracingPipelineCreateInfoNV; @@ -1659,18 +2341,37 @@ 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_VkTransformMatrixKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAabbPositionsKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureInstanceKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRayTracingShaderGroupCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRayTracingPipelineCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeometryTrianglesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeometryAABBNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeometryDataNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeometryNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindAccelerationStructureMemoryInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetAccelerationStructureNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureMemoryRequirementsInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTransformMatrixKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAabbPositionsKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureInstanceKHR* wrapper); struct Decoded_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; struct Decoded_VkPipelineRepresentativeFragmentTestStateCreateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* wrapper); struct Decoded_VkPhysicalDeviceImageViewImageFormatInfoEXT; struct Decoded_VkFilterCubicImageViewImageFormatPropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewImageFormatInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFilterCubicImageViewImageFormatPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewImageFormatInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFilterCubicImageViewImageFormatPropertiesEXT* wrapper); struct Decoded_VkImportMemoryHostPointerInfoEXT; struct Decoded_VkMemoryHostPointerPropertiesEXT; @@ -1679,30 +2380,39 @@ struct Decoded_VkPhysicalDeviceExternalMemoryHostPropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportMemoryHostPointerInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryHostPointerPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportMemoryHostPointerInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryHostPointerPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* wrapper); struct Decoded_VkPipelineCompilerControlCreateInfoAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCompilerControlCreateInfoAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCompilerControlCreateInfoAMD* wrapper); struct Decoded_VkPhysicalDeviceShaderCorePropertiesAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesAMD* wrapper); struct Decoded_VkDeviceMemoryOverallocationCreateInfoAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceMemoryOverallocationCreateInfoAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceMemoryOverallocationCreateInfoAMD* wrapper); struct Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* wrapper); struct Decoded_VkPresentFrameTokenGGP; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentFrameTokenGGP* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPresentFrameTokenGGP* wrapper); struct Decoded_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceMeshShaderFeaturesNV; struct Decoded_VkPhysicalDeviceMeshShaderPropertiesNV; @@ -1711,26 +2421,35 @@ struct Decoded_VkDrawMeshTasksIndirectCommandNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderPropertiesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrawMeshTasksIndirectCommandNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrawMeshTasksIndirectCommandNV* wrapper); struct Decoded_VkPhysicalDeviceShaderImageFootprintFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderImageFootprintFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderImageFootprintFeaturesNV* wrapper); struct Decoded_VkPipelineViewportExclusiveScissorStateCreateInfoNV; struct Decoded_VkPhysicalDeviceExclusiveScissorFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportExclusiveScissorStateCreateInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExclusiveScissorFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportExclusiveScissorStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExclusiveScissorFeaturesNV* wrapper); struct Decoded_VkQueueFamilyCheckpointPropertiesNV; struct Decoded_VkCheckpointDataNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointPropertiesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCheckpointDataNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueueFamilyCheckpointPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCheckpointDataNV* wrapper); struct Decoded_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* wrapper); struct Decoded_VkInitializePerformanceApiInfoINTEL; struct Decoded_VkQueryPoolPerformanceQueryCreateInfoINTEL; @@ -1745,24 +2464,35 @@ 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_VkPerformanceStreamMarkerInfoINTEL* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceOverrideInfoINTEL* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceConfigurationAcquireInfoINTEL* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkInitializePerformanceApiInfoINTEL* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueryPoolPerformanceQueryCreateInfoINTEL* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceMarkerInfoINTEL* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceStreamMarkerInfoINTEL* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceOverrideInfoINTEL* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceConfigurationAcquireInfoINTEL* wrapper); struct Decoded_VkPhysicalDevicePCIBusInfoPropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePCIBusInfoPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePCIBusInfoPropertiesEXT* wrapper); struct Decoded_VkDisplayNativeHdrSurfaceCapabilitiesAMD; struct Decoded_VkSwapchainDisplayNativeHdrCreateInfoAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayNativeHdrSurfaceCapabilitiesAMD* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainDisplayNativeHdrCreateInfoAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDisplayNativeHdrSurfaceCapabilitiesAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainDisplayNativeHdrCreateInfoAMD* wrapper); struct Decoded_VkImagePipeSurfaceCreateInfoFUCHSIA; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImagePipeSurfaceCreateInfoFUCHSIA* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImagePipeSurfaceCreateInfoFUCHSIA* wrapper); struct Decoded_VkMetalSurfaceCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMetalSurfaceCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMetalSurfaceCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceFragmentDensityMapFeaturesEXT; struct Decoded_VkPhysicalDeviceFragmentDensityMapPropertiesEXT; @@ -1771,42 +2501,55 @@ struct Decoded_VkRenderPassFragmentDensityMapCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassFragmentDensityMapCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassFragmentDensityMapCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceShaderCoreProperties2AMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreProperties2AMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreProperties2AMD* wrapper); struct Decoded_VkPhysicalDeviceCoherentMemoryFeaturesAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCoherentMemoryFeaturesAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCoherentMemoryFeaturesAMD* wrapper); struct Decoded_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceMemoryBudgetPropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryBudgetPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryBudgetPropertiesEXT* wrapper); struct Decoded_VkPhysicalDeviceMemoryPriorityFeaturesEXT; struct Decoded_VkMemoryPriorityAllocateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryPriorityFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryPriorityAllocateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMemoryPriorityFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryPriorityAllocateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; struct Decoded_VkBufferDeviceAddressCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferDeviceAddressCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBufferDeviceAddressCreateInfoEXT* wrapper); struct Decoded_VkValidationFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkValidationFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkValidationFeaturesEXT* wrapper); struct Decoded_VkCooperativeMatrixPropertiesNV; struct Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesNV; @@ -1815,6 +2558,9 @@ struct Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCooperativeMatrixPropertiesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCooperativeMatrixPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesNV* wrapper); struct Decoded_VkPhysicalDeviceCoverageReductionModeFeaturesNV; struct Decoded_VkPipelineCoverageReductionStateCreateInfoNV; @@ -1823,14 +2569,19 @@ struct Decoded_VkFramebufferMixedSamplesCombinationNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCoverageReductionModeFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCoverageReductionStateCreateInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFramebufferMixedSamplesCombinationNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCoverageReductionModeFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCoverageReductionStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFramebufferMixedSamplesCombinationNV* wrapper); struct Decoded_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceProvokingVertexFeaturesEXT; struct Decoded_VkPhysicalDeviceProvokingVertexPropertiesEXT; @@ -1839,6 +2590,9 @@ struct Decoded_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProvokingVertexFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProvokingVertexPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProvokingVertexFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceProvokingVertexPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* wrapper); struct Decoded_VkSurfaceFullScreenExclusiveInfoEXT; struct Decoded_VkSurfaceCapabilitiesFullScreenExclusiveEXT; @@ -1847,18 +2601,24 @@ struct Decoded_VkSurfaceFullScreenExclusiveWin32InfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceFullScreenExclusiveInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesFullScreenExclusiveEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceFullScreenExclusiveWin32InfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceFullScreenExclusiveInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesFullScreenExclusiveEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceFullScreenExclusiveWin32InfoEXT* wrapper); struct Decoded_VkHeadlessSurfaceCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkHeadlessSurfaceCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkHeadlessSurfaceCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceHostImageCopyFeaturesEXT; struct Decoded_VkPhysicalDeviceHostImageCopyPropertiesEXT; @@ -1881,6 +2641,16 @@ 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_VkHostImageLayoutTransitionInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubresourceHostMemcpySizeEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkHostImageCopyDevicePerformanceQueryEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostImageCopyFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostImageCopyPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryToImageCopyEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageToMemoryCopyEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyMemoryToImageInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyImageToMemoryInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyImageToImageInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkHostImageLayoutTransitionInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubresourceHostMemcpySizeEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkHostImageCopyDevicePerformanceQueryEXT* wrapper); struct Decoded_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT; struct Decoded_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT; @@ -1889,10 +2659,14 @@ struct Decoded_VkMemoryMapPlacedInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryMapPlacedInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMapMemoryPlacedFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMapMemoryPlacedPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryMapPlacedInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* wrapper); struct Decoded_VkSurfacePresentModeEXT; struct Decoded_VkSurfacePresentScalingCapabilitiesEXT; @@ -1901,6 +2675,9 @@ struct Decoded_VkSurfacePresentModeCompatibilityEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfacePresentModeEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfacePresentScalingCapabilitiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfacePresentModeCompatibilityEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfacePresentModeEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfacePresentScalingCapabilitiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfacePresentModeCompatibilityEXT* wrapper); struct Decoded_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT; struct Decoded_VkSwapchainPresentFenceInfoEXT; @@ -1915,6 +2692,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_VkSwapchainPresentModeInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainPresentScalingCreateInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkReleaseSwapchainImagesInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainPresentFenceInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainPresentModesCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainPresentModeInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainPresentScalingCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkReleaseSwapchainImagesInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; struct Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; @@ -1943,22 +2726,40 @@ 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_VkIndirectCommandsLayoutCreateInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeneratedCommandsInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeneratedCommandsMemoryRequirementsInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGraphicsShaderGroupCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGraphicsPipelineShaderGroupsCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindShaderGroupIndirectCommandNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindIndexBufferIndirectCommandNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindVertexBufferIndirectCommandNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSetStateFlagsIndirectCommandNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectCommandsStreamNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutTokenNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeneratedCommandsInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeneratedCommandsMemoryRequirementsInfoNV* wrapper); struct Decoded_VkPhysicalDeviceInheritedViewportScissorFeaturesNV; struct Decoded_VkCommandBufferInheritanceViewportScissorInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceViewportScissorInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInheritedViewportScissorFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceViewportScissorInfoNV* wrapper); struct Decoded_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* wrapper); struct Decoded_VkRenderPassTransformBeginInfoQCOM; struct Decoded_VkCommandBufferInheritanceRenderPassTransformInfoQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassTransformBeginInfoQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassTransformBeginInfoQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCommandBufferInheritanceRenderPassTransformInfoQCOM* wrapper); struct Decoded_VkPhysicalDeviceDepthBiasControlFeaturesEXT; struct Decoded_VkDepthBiasInfoEXT; @@ -1967,6 +2768,9 @@ struct Decoded_VkDepthBiasRepresentationInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthBiasControlFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDepthBiasInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDepthBiasRepresentationInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthBiasControlFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDepthBiasInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDepthBiasRepresentationInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; struct Decoded_VkDeviceMemoryReportCallbackDataEXT; @@ -1975,12 +2779,17 @@ struct Decoded_VkDeviceDeviceMemoryReportCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceMemoryReportCallbackDataEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceDeviceMemoryReportCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceMemoryReportCallbackDataEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceDeviceMemoryReportCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceRobustness2FeaturesEXT; struct Decoded_VkPhysicalDeviceRobustness2PropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRobustness2FeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRobustness2PropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRobustness2FeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRobustness2PropertiesEXT* wrapper); struct Decoded_VkSamplerCustomBorderColorCreateInfoEXT; struct Decoded_VkPhysicalDeviceCustomBorderColorPropertiesEXT; @@ -1989,6 +2798,9 @@ struct Decoded_VkPhysicalDeviceCustomBorderColorFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerCustomBorderColorCreateInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCustomBorderColorPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCustomBorderColorFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerCustomBorderColorCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCustomBorderColorPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCustomBorderColorFeaturesEXT* wrapper); struct Decoded_VkPhysicalDevicePresentBarrierFeaturesNV; struct Decoded_VkSurfaceCapabilitiesPresentBarrierNV; @@ -1997,16 +2809,22 @@ struct Decoded_VkSwapchainPresentBarrierCreateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentBarrierFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesPresentBarrierNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainPresentBarrierCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePresentBarrierFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSurfaceCapabilitiesPresentBarrierNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainPresentBarrierCreateInfoNV* wrapper); struct Decoded_VkPhysicalDeviceDiagnosticsConfigFeaturesNV; struct Decoded_VkDeviceDiagnosticsConfigCreateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceDiagnosticsConfigCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDiagnosticsConfigFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceDiagnosticsConfigCreateInfoNV* wrapper); struct Decoded_VkQueryLowLatencySupportNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueryLowLatencySupportNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkQueryLowLatencySupportNV* wrapper); struct Decoded_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; struct Decoded_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; @@ -2015,10 +2833,14 @@ struct Decoded_VkGraphicsPipelineLibraryCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGraphicsPipelineLibraryCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGraphicsPipelineLibraryCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* wrapper); struct Decoded_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; struct Decoded_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; @@ -2027,6 +2849,9 @@ struct Decoded_VkPipelineFragmentShadingRateEnumStateCreateInfoNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineFragmentShadingRateEnumStateCreateInfoNV* wrapper); struct Decoded_VkAccelerationStructureGeometryMotionTrianglesDataNV; struct Decoded_VkAccelerationStructureMotionInfoNV; @@ -2041,20 +2866,30 @@ 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_VkSRTDataNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureSRTMotionInstanceNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryMotionTrianglesDataNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureMotionInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureMatrixMotionInstanceNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSRTDataNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureSRTMotionInstanceNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; struct Decoded_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* wrapper); struct Decoded_VkCopyCommandTransformInfoQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyCommandTransformInfoQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyCommandTransformInfoQCOM* wrapper); struct Decoded_VkPhysicalDeviceImageCompressionControlFeaturesEXT; struct Decoded_VkImageCompressionControlEXT; @@ -2063,14 +2898,19 @@ struct Decoded_VkImageCompressionPropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageCompressionControlEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageCompressionPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageCompressionControlEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageCompressionPropertiesEXT* wrapper); struct Decoded_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* wrapper); struct Decoded_VkPhysicalDevice4444FormatsFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevice4444FormatsFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevice4444FormatsFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceFaultFeaturesEXT; struct Decoded_VkDeviceFaultCountsEXT; @@ -2085,18 +2925,27 @@ 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_VkDeviceFaultVendorInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceFaultInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceFaultVendorBinaryHeaderVersionOneEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFaultFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceFaultCountsEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceFaultAddressInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceFaultVendorInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceFaultInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceFaultVendorBinaryHeaderVersionOneEXT* wrapper); struct Decoded_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* wrapper); struct Decoded_VkDirectFBSurfaceCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDirectFBSurfaceCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDirectFBSurfaceCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; struct Decoded_VkMutableDescriptorTypeListEXT; @@ -2105,6 +2954,9 @@ struct Decoded_VkMutableDescriptorTypeCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeListEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeListEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMutableDescriptorTypeCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; struct Decoded_VkVertexInputBindingDescription2EXT; @@ -2113,26 +2965,35 @@ struct Decoded_VkVertexInputAttributeDescription2EXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVertexInputBindingDescription2EXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVertexInputAttributeDescription2EXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVertexInputBindingDescription2EXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVertexInputAttributeDescription2EXT* wrapper); struct Decoded_VkPhysicalDeviceDrmPropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDrmPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDrmPropertiesEXT* wrapper); struct Decoded_VkPhysicalDeviceAddressBindingReportFeaturesEXT; struct Decoded_VkDeviceAddressBindingCallbackDataEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAddressBindingReportFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceAddressBindingCallbackDataEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAddressBindingReportFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceAddressBindingCallbackDataEXT* wrapper); struct Decoded_VkPhysicalDeviceDepthClipControlFeaturesEXT; struct Decoded_VkPipelineViewportDepthClipControlCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipControlFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportDepthClipControlCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClipControlFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportDepthClipControlCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* wrapper); struct Decoded_VkImportMemoryZirconHandleInfoFUCHSIA; struct Decoded_VkMemoryZirconHandlePropertiesFUCHSIA; @@ -2141,28 +3002,38 @@ struct Decoded_VkMemoryGetZirconHandleInfoFUCHSIA; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportMemoryZirconHandleInfoFUCHSIA* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryZirconHandlePropertiesFUCHSIA* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryGetZirconHandleInfoFUCHSIA* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportMemoryZirconHandleInfoFUCHSIA* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryZirconHandlePropertiesFUCHSIA* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryGetZirconHandleInfoFUCHSIA* wrapper); struct Decoded_VkImportSemaphoreZirconHandleInfoFUCHSIA; struct Decoded_VkSemaphoreGetZirconHandleInfoFUCHSIA; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportSemaphoreZirconHandleInfoFUCHSIA* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreGetZirconHandleInfoFUCHSIA* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImportSemaphoreZirconHandleInfoFUCHSIA* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSemaphoreGetZirconHandleInfoFUCHSIA* wrapper); struct Decoded_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* wrapper); struct Decoded_VkMemoryGetRemoteAddressInfoNV; struct Decoded_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryGetRemoteAddressInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMemoryGetRemoteAddressInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceFrameBoundaryFeaturesEXT; struct Decoded_VkFrameBoundaryEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFrameBoundaryFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFrameBoundaryEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFrameBoundaryFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkFrameBoundaryEXT* wrapper); struct Decoded_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; struct Decoded_VkSubpassResolvePerformanceQueryEXT; @@ -2171,30 +3042,40 @@ struct Decoded_VkMultisampledRenderToSingleSampledInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassResolvePerformanceQueryEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultisampledRenderToSingleSampledInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassResolvePerformanceQueryEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultisampledRenderToSingleSampledInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* wrapper); struct Decoded_VkScreenSurfaceCreateInfoQNX; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkScreenSurfaceCreateInfoQNX* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkScreenSurfaceCreateInfoQNX* wrapper); struct Decoded_VkPhysicalDeviceColorWriteEnableFeaturesEXT; struct Decoded_VkPipelineColorWriteCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceColorWriteEnableFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineColorWriteCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceColorWriteEnableFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineColorWriteCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceImageViewMinLodFeaturesEXT; struct Decoded_VkImageViewMinLodCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewMinLodFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewMinLodCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageViewMinLodFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewMinLodCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceMultiDrawFeaturesEXT; struct Decoded_VkPhysicalDeviceMultiDrawPropertiesEXT; @@ -2205,16 +3086,23 @@ 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_VkPhysicalDeviceMultiDrawPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultiDrawInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultiDrawIndexedInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiDrawFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiDrawPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultiDrawInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMultiDrawIndexedInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceShaderTileImageFeaturesEXT; struct Decoded_VkPhysicalDeviceShaderTileImagePropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTileImageFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTileImagePropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTileImageFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderTileImagePropertiesEXT* wrapper); struct Decoded_VkMicromapUsageEXT; struct Decoded_VkMicromapBuildInfoEXT; @@ -2241,6 +3129,18 @@ 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_VkMicromapBuildSizesInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesOpacityMicromapEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMicromapTriangleEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMicromapUsageEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMicromapBuildInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMicromapCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpacityMicromapFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpacityMicromapPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMicromapVersionInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyMicromapToMemoryInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyMemoryToMicromapInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyMicromapInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMicromapBuildSizesInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesOpacityMicromapEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkMicromapTriangleEXT* wrapper); struct Decoded_VkPhysicalDeviceDisplacementMicromapFeaturesNV; struct Decoded_VkPhysicalDeviceDisplacementMicromapPropertiesNV; @@ -2249,6 +3149,9 @@ struct Decoded_VkAccelerationStructureTrianglesDisplacementMicromapNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapPropertiesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesDisplacementMicromapNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDisplacementMicromapPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureTrianglesDisplacementMicromapNV* wrapper); struct Decoded_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; struct Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; @@ -2257,20 +3160,27 @@ struct Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* wrapper); struct Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; struct Decoded_VkSamplerBorderColorComponentMappingCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerBorderColorComponentMappingCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerBorderColorComponentMappingCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceShaderCorePropertiesARM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesARM* wrapper); struct Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM; struct Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM; @@ -2279,12 +3189,17 @@ struct Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM* wrapper); struct Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; struct Decoded_VkImageViewSlicedCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewSlicedCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewSlicedCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; struct Decoded_VkDescriptorSetBindingReferenceVALVE; @@ -2293,14 +3208,19 @@ struct Decoded_VkDescriptorSetLayoutHostMappingInfoVALVE; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetBindingReferenceVALVE* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutHostMappingInfoVALVE* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetBindingReferenceVALVE* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorSetLayoutHostMappingInfoVALVE* wrapper); struct Decoded_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM; struct Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM; @@ -2313,6 +3233,11 @@ 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_VkRenderPassStripeInfoARM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassStripeBeginInfoARM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassStripeSubmitInfoARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassStripeInfoARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassStripeBeginInfoARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassStripeSubmitInfoARM* wrapper); struct Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; struct Decoded_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; @@ -2321,6 +3246,9 @@ struct Decoded_VkSubpassFragmentDensityMapOffsetEndInfoQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* wrapper); struct Decoded_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; struct Decoded_VkComputePipelineIndirectBufferInfoNV; @@ -2331,14 +3259,20 @@ 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_VkComputePipelineIndirectBufferInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineIndirectDeviceAddressInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindPipelineIndirectCommandNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkComputePipelineIndirectBufferInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineIndirectDeviceAddressInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindPipelineIndirectCommandNV* wrapper); struct Decoded_VkPhysicalDeviceLinearColorAttachmentFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLinearColorAttachmentFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLinearColorAttachmentFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* wrapper); struct Decoded_VkImageViewSampleWeightCreateInfoQCOM; struct Decoded_VkPhysicalDeviceImageProcessingFeaturesQCOM; @@ -2347,16 +3281,22 @@ struct Decoded_VkPhysicalDeviceImageProcessingPropertiesQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewSampleWeightCreateInfoQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingFeaturesQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingPropertiesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageViewSampleWeightCreateInfoQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingFeaturesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessingPropertiesQCOM* wrapper); struct Decoded_VkPhysicalDeviceNestedCommandBufferFeaturesEXT; struct Decoded_VkPhysicalDeviceNestedCommandBufferPropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNestedCommandBufferPropertiesEXT* wrapper); struct Decoded_VkExternalMemoryAcquireUnmodifiedEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalMemoryAcquireUnmodifiedEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkExternalMemoryAcquireUnmodifiedEXT* wrapper); struct Decoded_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT; struct Decoded_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT; @@ -2367,6 +3307,10 @@ 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_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkColorBlendEquationEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkColorBlendAdvancedEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkColorBlendEquationEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkColorBlendAdvancedEXT* wrapper); struct Decoded_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT; struct Decoded_VkRenderPassCreationControlEXT; @@ -2381,12 +3325,20 @@ 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_VkRenderPassCreationFeedbackCreateInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassCreationControlEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassCreationFeedbackInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassCreationFeedbackCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassSubpassFeedbackCreateInfoEXT* wrapper); struct Decoded_VkDirectDriverLoadingInfoLUNARG; struct Decoded_VkDirectDriverLoadingListLUNARG; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingInfoLUNARG* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingListLUNARG* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingInfoLUNARG* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDirectDriverLoadingListLUNARG* wrapper); struct Decoded_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT; struct Decoded_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; @@ -2397,6 +3349,10 @@ 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_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineShaderStageModuleIdentifierCreateInfoEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderModuleIdentifierEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineShaderStageModuleIdentifierCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderModuleIdentifierEXT* wrapper); struct Decoded_VkPhysicalDeviceOpticalFlowFeaturesNV; struct Decoded_VkPhysicalDeviceOpticalFlowPropertiesNV; @@ -2413,14 +3369,23 @@ 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_VkOpticalFlowSessionCreateInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOpticalFlowSessionCreatePrivateDataInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOpticalFlowExecuteInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpticalFlowFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceOpticalFlowPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOpticalFlowImageFormatInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOpticalFlowImageFormatPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOpticalFlowSessionCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOpticalFlowSessionCreatePrivateDataInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOpticalFlowExecuteInfoNV* wrapper); struct Decoded_VkPhysicalDeviceLegacyDitheringFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyDitheringFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyDitheringFeaturesEXT* wrapper); struct Decoded_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID; struct Decoded_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID; @@ -2429,6 +3394,9 @@ struct Decoded_VkAndroidHardwareBufferFormatResolvePropertiesANDROID; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatResolvePropertiesANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolveFeaturesANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExternalFormatResolvePropertiesANDROID* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAndroidHardwareBufferFormatResolvePropertiesANDROID* wrapper); struct Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT; struct Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT; @@ -2437,60 +3405,80 @@ struct Decoded_VkShaderCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM; struct Decoded_VkTilePropertiesQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTilePropertiesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTilePropertiesQCOM* wrapper); struct Decoded_VkPhysicalDeviceAmigoProfilingFeaturesSEC; struct Decoded_VkAmigoProfilingSubmitInfoSEC; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAmigoProfilingFeaturesSEC* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAmigoProfilingSubmitInfoSEC* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAmigoProfilingFeaturesSEC* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAmigoProfilingSubmitInfoSEC* wrapper); struct Decoded_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* wrapper); struct Decoded_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV; struct Decoded_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; struct Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* wrapper); struct Decoded_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT; struct Decoded_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT* wrapper); struct Decoded_VkLayerSettingEXT; struct Decoded_VkLayerSettingsCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLayerSettingEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLayerSettingsCreateInfoEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLayerSettingEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLayerSettingsCreateInfoEXT* wrapper); struct Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; struct Decoded_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* wrapper); struct Decoded_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT* wrapper); struct Decoded_VkLatencySleepModeInfoNV; struct Decoded_VkLatencySleepInfoNV; @@ -2511,16 +3499,28 @@ 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_VkSwapchainLatencyCreateInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOutOfBandQueueTypeInfoNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLatencySurfaceCapabilitiesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLatencySleepModeInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLatencySleepInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSetLatencyMarkerInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLatencyTimingsFrameReportNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGetLatencyMarkerInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLatencySubmissionPresentIdNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSwapchainLatencyCreateInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkOutOfBandQueueTypeInfoNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLatencySurfaceCapabilitiesNV* wrapper); struct Decoded_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; 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); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* wrapper); +size_t PreloadDecodeStruct(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); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDevicePerStageDescriptorSetFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM; struct Decoded_VkPhysicalDeviceImageProcessing2PropertiesQCOM; @@ -2529,6 +3529,9 @@ struct Decoded_VkSamplerBlockMatchWindowCreateInfoQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2PropertiesQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerBlockMatchWindowCreateInfoQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2FeaturesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageProcessing2PropertiesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerBlockMatchWindowCreateInfoQCOM* wrapper); struct Decoded_VkPhysicalDeviceCubicWeightsFeaturesQCOM; struct Decoded_VkSamplerCubicWeightsCreateInfoQCOM; @@ -2537,44 +3540,57 @@ struct Decoded_VkBlitImageCubicWeightsInfoQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicWeightsFeaturesQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerCubicWeightsCreateInfoQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBlitImageCubicWeightsInfoQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicWeightsFeaturesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerCubicWeightsCreateInfoQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBlitImageCubicWeightsInfoQCOM* wrapper); struct Decoded_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM; struct Decoded_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceYcbcrDegammaFeaturesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM* wrapper); struct Decoded_VkPhysicalDeviceCubicClampFeaturesQCOM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicClampFeaturesQCOM* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCubicClampFeaturesQCOM* wrapper); struct Decoded_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceLayeredDriverPropertiesMSFT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredDriverPropertiesMSFT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceLayeredDriverPropertiesMSFT* wrapper); struct Decoded_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceRawAccessChainsFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRawAccessChainsFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRawAccessChainsFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* wrapper); struct Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV* wrapper); struct Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA; struct Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA; @@ -2583,6 +3599,9 @@ struct Decoded_VkImageAlignmentControlCreateInfoMESA; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageAlignmentControlCreateInfoMESA* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageAlignmentControlCreateInfoMESA* wrapper); struct Decoded_VkAccelerationStructureBuildRangeInfoKHR; struct Decoded_VkAccelerationStructureGeometryTrianglesDataKHR; @@ -2615,6 +3634,21 @@ 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_VkCopyMemoryToAccelerationStructureInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyAccelerationStructureInfoKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildSizesInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildRangeInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryTrianglesDataKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryAabbsDataKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryInstancesDataKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildGeometryInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWriteDescriptorSetAccelerationStructureKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAccelerationStructureFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceAccelerationStructurePropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureDeviceAddressInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureVersionInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyAccelerationStructureToMemoryInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyMemoryToAccelerationStructureInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCopyAccelerationStructureInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildSizesInfoKHR* wrapper); struct Decoded_VkRayTracingShaderGroupCreateInfoKHR; struct Decoded_VkRayTracingPipelineInterfaceCreateInfoKHR; @@ -2631,10 +3665,18 @@ 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_VkPhysicalDeviceRayTracingPipelinePropertiesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkStridedDeviceAddressRegionKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTraceRaysIndirectCommandKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRayTracingShaderGroupCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRayTracingPipelineInterfaceCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRayTracingPipelineCreateInfoKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPipelineFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPipelinePropertiesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkStridedDeviceAddressRegionKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkTraceRaysIndirectCommandKHR* wrapper); struct Decoded_VkPhysicalDeviceRayQueryFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayQueryFeaturesKHR* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayQueryFeaturesKHR* wrapper); struct Decoded_VkPhysicalDeviceMeshShaderFeaturesEXT; struct Decoded_VkPhysicalDeviceMeshShaderPropertiesEXT; @@ -2643,6 +3685,9 @@ struct Decoded_VkDrawMeshTasksIndirectCommandEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrawMeshTasksIndirectCommandEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderFeaturesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMeshShaderPropertiesEXT* wrapper); +size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrawMeshTasksIndirectCommandEXT* wrapper); GFXRECON_END_NAMESPACE(decode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/generated/generated_vulkan_struct_packet.h b/framework/generated/generated_vulkan_struct_packet.h new file mode 100644 index 0000000000..5062170a37 --- /dev/null +++ b/framework/generated/generated_vulkan_struct_packet.h @@ -0,0 +1,6669 @@ +/* +** Copyright (c) 2020 Samsung +** Copyright (c) 2023 Google +** Copyright (c) 2023 LunarG, Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and associated documentation files (the "Software"), +** to deal in the Software without restriction, including without limitation +** the rights to use, copy, modify, merge, publish, distribute, sublicense, +** and/or sell copies of the Software, and to permit persons to whom the +** Software is furnished to do so, subject to the following conditions: +** +** The above copyright notice and this permission notice shall be included in +** all copies or substantial portions of the Software. +** +** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +** DEALINGS IN THE SOFTWARE. +*/ + +/* +** This file is generated from the Khronos Vulkan XML API Registry. +** +*/ + +#include "generated/generated_vulkan_cpp_consumer.h" + +#include "decode/vulkan_cpp_consumer_base.h" +#include "decode/vulkan_cpp_structs.h" +#include "generated/generated_vulkan_cpp_structs.h" +#include "generated/generated_vulkan_enum_to_string.h" +#include "generated/generated_vulkan_cpp_consumer_extension.h" +#include "decode/handle_pointer_decoder.h" +#include "decode/pointer_decoder.h" +#include "decode/string_decoder.h" +#include "decode/struct_pointer_decoder.h" +#include "decode/custom_vulkan_struct_handle_mappers.h" +#include "generated/generated_vulkan_struct_decoders.h" +#include "util/defines.h" +#include "format/packet_call_id.h" +#include "vulkan/vulkan.h" +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#include "vk_video/vulkan_video_codecs_common.h" + +#include +#include + +GFXRECON_BEGIN_NAMESPACE(gfxrecon) +GFXRECON_BEGIN_NAMESPACE(decode) + +struct Packet_vkAllocateCommandBuffers +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pAllocateInfo; + HandlePointerDecoder pCommandBuffers; +}; + + +struct Packet_vkAllocateDescriptorSets +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pAllocateInfo; + HandlePointerDecoder pDescriptorSets; +}; + + +struct Packet_vkAllocateMemory +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pAllocateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pMemory; +}; + + +struct Packet_vkBeginCommandBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId commandBuffer; + StructPointerDecoder pBeginInfo; +}; + + +struct Packet_vkBindBufferMemory +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId buffer; + format::HandleId memory; + VkDeviceSize memoryOffset; +}; + + +struct Packet_vkBindImageMemory +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId image; + format::HandleId memory; + VkDeviceSize memoryOffset; +}; + + +struct Packet_vkCmdBeginQuery +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t query; + VkQueryControlFlags flags; +}; + + +struct Packet_vkCmdBeginRenderPass +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pRenderPassBegin; + VkSubpassContents contents; +}; + + +struct Packet_vkCmdBindDescriptorSets +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + HandlePointerDecoder pDescriptorSets; + uint32_t dynamicOffsetCount; + PointerDecoder pDynamicOffsets; +}; + + +struct Packet_vkCmdBindIndexBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + VkIndexType indexType; +}; + + +struct Packet_vkCmdBindPipeline +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId pipeline; +}; + + +struct Packet_vkCmdBindVertexBuffers +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstBinding; + uint32_t bindingCount; + HandlePointerDecoder pBuffers; + PointerDecoder pOffsets; +}; + + +struct Packet_vkCmdBlitImage +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId srcImage; + VkImageLayout srcImageLayout; + format::HandleId dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + StructPointerDecoder pRegions; + VkFilter filter; +}; + + +struct Packet_vkCmdClearAttachments +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t attachmentCount; + StructPointerDecoder pAttachments; + uint32_t rectCount; + StructPointerDecoder pRects; +}; + + +struct Packet_vkCmdClearColorImage +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId image; + VkImageLayout imageLayout; + StructPointerDecoder pColor; + uint32_t rangeCount; + StructPointerDecoder pRanges; +}; + + +struct Packet_vkCmdClearDepthStencilImage +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId image; + VkImageLayout imageLayout; + StructPointerDecoder pDepthStencil; + uint32_t rangeCount; + StructPointerDecoder pRanges; +}; + + +struct Packet_vkCmdCopyBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId srcBuffer; + format::HandleId dstBuffer; + uint32_t regionCount; + StructPointerDecoder pRegions; +}; + + +struct Packet_vkCmdCopyBufferToImage +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId srcBuffer; + format::HandleId dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + StructPointerDecoder pRegions; +}; + + +struct Packet_vkCmdCopyImage +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId srcImage; + VkImageLayout srcImageLayout; + format::HandleId dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + StructPointerDecoder pRegions; +}; + + +struct Packet_vkCmdCopyImageToBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId srcImage; + VkImageLayout srcImageLayout; + format::HandleId dstBuffer; + uint32_t regionCount; + StructPointerDecoder pRegions; +}; + + +struct Packet_vkCmdCopyQueryPoolResults +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + VkDeviceSize stride; + VkQueryResultFlags flags; +}; + + +struct Packet_vkCmdDispatch +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +}; + + +struct Packet_vkCmdDispatchIndirect +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; +}; + + +struct Packet_vkCmdDraw +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +}; + + +struct Packet_vkCmdDrawIndexed +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +}; + + +struct Packet_vkCmdDrawIndexedIndirect +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + uint32_t drawCount; + uint32_t stride; +}; + + +struct Packet_vkCmdDrawIndirect +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + uint32_t drawCount; + uint32_t stride; +}; + + +struct Packet_vkCmdEndQuery +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t query; +}; + + +struct Packet_vkCmdEndRenderPass +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; +}; + + +struct Packet_vkCmdExecuteCommands +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t commandBufferCount; + HandlePointerDecoder pCommandBuffers; +}; + + +struct Packet_vkCmdFillBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + VkDeviceSize size; + uint32_t data; +}; + + +struct Packet_vkCmdNextSubpass +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkSubpassContents contents; +}; + + +struct Packet_vkCmdPipelineBarrier +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkDependencyFlags dependencyFlags; + uint32_t memoryBarrierCount; + StructPointerDecoder pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + StructPointerDecoder pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + StructPointerDecoder pImageMemoryBarriers; +}; + + +struct Packet_vkCmdPushConstants +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + PointerDecoder pValues; +}; + + +struct Packet_vkCmdResetEvent +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId event; + VkPipelineStageFlags stageMask; +}; + + +struct Packet_vkCmdResetQueryPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; +}; + + +struct Packet_vkCmdResolveImage +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId srcImage; + VkImageLayout srcImageLayout; + format::HandleId dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + StructPointerDecoder pRegions; +}; + + +struct Packet_vkCmdSetBlendConstants +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + PointerDecoder blendConstants; +}; + + +struct Packet_vkCmdSetDepthBias +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; +}; + + +struct Packet_vkCmdSetDepthBounds +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + float minDepthBounds; + float maxDepthBounds; +}; + + +struct Packet_vkCmdSetEvent +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId event; + VkPipelineStageFlags stageMask; +}; + + +struct Packet_vkCmdSetLineWidth +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + float lineWidth; +}; + + +struct Packet_vkCmdSetScissor +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstScissor; + uint32_t scissorCount; + StructPointerDecoder pScissors; +}; + + +struct Packet_vkCmdSetStencilCompareMask +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + uint32_t compareMask; +}; + + +struct Packet_vkCmdSetStencilReference +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + uint32_t reference; +}; + + +struct Packet_vkCmdSetStencilWriteMask +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + uint32_t writeMask; +}; + + +struct Packet_vkCmdSetViewport +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstViewport; + uint32_t viewportCount; + StructPointerDecoder pViewports; +}; + + +struct Packet_vkCmdUpdateBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + VkDeviceSize dataSize; + PointerDecoder pData; +}; + + +struct Packet_vkCmdWaitEvents +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t eventCount; + HandlePointerDecoder pEvents; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + uint32_t memoryBarrierCount; + StructPointerDecoder pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + StructPointerDecoder pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + StructPointerDecoder pImageMemoryBarriers; +}; + + +struct Packet_vkCmdWriteTimestamp +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineStageFlagBits pipelineStage; + format::HandleId queryPool; + uint32_t query; +}; + + +struct Packet_vkCreateBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pBuffer; +}; + + +struct Packet_vkCreateBufferView +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pView; +}; + + +struct Packet_vkCreateCommandPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pCommandPool; +}; + + +struct Packet_vkCreateComputePipelines +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId pipelineCache; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; +}; + + +struct Packet_vkCreateDescriptorPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDescriptorPool; +}; + + +struct Packet_vkCreateDescriptorSetLayout +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSetLayout; +}; + + +struct Packet_vkCreateDevice +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDevice; +}; + + +struct Packet_vkCreateEvent +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pEvent; +}; + + +struct Packet_vkCreateFence +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pFence; +}; + + +struct Packet_vkCreateFramebuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pFramebuffer; +}; + + +struct Packet_vkCreateGraphicsPipelines +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId pipelineCache; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; +}; + + +struct Packet_vkCreateImage +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pImage; +}; + + +struct Packet_vkCreateImageView +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pView; +}; + + +struct Packet_vkCreateInstance +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pInstance; +}; + + +struct Packet_vkCreatePipelineCache +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelineCache; +}; + + +struct Packet_vkCreatePipelineLayout +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelineLayout; +}; + + +struct Packet_vkCreateQueryPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pQueryPool; +}; + + +struct Packet_vkCreateRenderPass +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pRenderPass; +}; + + +struct Packet_vkCreateSampler +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSampler; +}; + + +struct Packet_vkCreateSemaphore +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSemaphore; +}; + + +struct Packet_vkCreateShaderModule +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pShaderModule; +}; + + +struct Packet_vkDestroyBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId buffer; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyBufferView +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId bufferView; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyCommandPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId commandPool; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyDescriptorPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId descriptorPool; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyDescriptorSetLayout +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId descriptorSetLayout; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyDevice +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyEvent +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId event; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyFence +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId fence; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyFramebuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId framebuffer; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyImage +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId image; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyImageView +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId imageView; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyInstance +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId instance; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyPipeline +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId pipeline; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyPipelineCache +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId pipelineCache; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyPipelineLayout +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId pipelineLayout; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyQueryPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId queryPool; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyRenderPass +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId renderPass; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroySampler +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId sampler; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroySemaphore +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId semaphore; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyShaderModule +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId shaderModule; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDeviceWaitIdle +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; +}; + + +struct Packet_vkEndCommandBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId commandBuffer; +}; + + +struct Packet_vkEnumeratePhysicalDevices +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + PointerDecoder pPhysicalDeviceCount; + HandlePointerDecoder pPhysicalDevices; +}; + + +struct Packet_vkFlushMappedMemoryRanges +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t memoryRangeCount; + StructPointerDecoder pMemoryRanges; +}; + + +struct Packet_vkFreeCommandBuffers +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId commandPool; + uint32_t commandBufferCount; + HandlePointerDecoder pCommandBuffers; +}; + + +struct Packet_vkFreeDescriptorSets +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId descriptorPool; + uint32_t descriptorSetCount; + HandlePointerDecoder pDescriptorSets; +}; + + +struct Packet_vkFreeMemory +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId memory; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetBufferMemoryRequirements +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId buffer; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetDeviceMemoryCommitment +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId memory; + PointerDecoder pCommittedMemoryInBytes; +}; + + +struct Packet_vkGetDeviceQueue +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + uint32_t queueFamilyIndex; + uint32_t queueIndex; + HandlePointerDecoder pQueue; +}; + + +struct Packet_vkGetEventStatus +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId event; +}; + + +struct Packet_vkGetFenceStatus +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId fence; +}; + + +struct Packet_vkGetImageMemoryRequirements +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId image; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetImageSparseMemoryRequirements +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId image; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; +}; + + +struct Packet_vkGetImageSubresourceLayout +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId image; + StructPointerDecoder pSubresource; + StructPointerDecoder pLayout; +}; + + +struct Packet_vkGetPhysicalDeviceFeatures +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pFeatures; +}; + + +struct Packet_vkGetPhysicalDeviceFormatProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + VkFormat format; + StructPointerDecoder pFormatProperties; +}; + + +struct Packet_vkGetPhysicalDeviceImageFormatProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; + StructPointerDecoder pImageFormatProperties; +}; + + +struct Packet_vkGetPhysicalDeviceMemoryProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pMemoryProperties; +}; + + +struct Packet_vkGetPhysicalDeviceProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetPhysicalDeviceQueueFamilyProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + PointerDecoder pQueueFamilyPropertyCount; + StructPointerDecoder pQueueFamilyProperties; +}; + + +struct Packet_vkGetPhysicalDeviceSparseImageFormatProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetPipelineCacheData +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId pipelineCache; + PointerDecoder pDataSize; + PointerDecoder pData; +}; + + +struct Packet_vkGetQueryPoolResults +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; + size_t dataSize; + PointerDecoder pData; + VkDeviceSize stride; + VkQueryResultFlags flags; +}; + + +struct Packet_vkGetRenderAreaGranularity +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId renderPass; + StructPointerDecoder pGranularity; +}; + + +struct Packet_vkInvalidateMappedMemoryRanges +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t memoryRangeCount; + StructPointerDecoder pMemoryRanges; +}; + + +struct Packet_vkMapMemory +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId memory; + VkDeviceSize offset; + VkDeviceSize size; + VkMemoryMapFlags flags; + PointerDecoder ppData; +}; + + +struct Packet_vkMergePipelineCaches +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId dstCache; + uint32_t srcCacheCount; + HandlePointerDecoder pSrcCaches; +}; + + +struct Packet_vkQueueBindSparse +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId queue; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfo; + format::HandleId fence; +}; + + +struct Packet_vkQueueSubmit +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId queue; + uint32_t submitCount; + StructPointerDecoder pSubmits; + format::HandleId fence; +}; + + +struct Packet_vkQueueWaitIdle +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId queue; +}; + + +struct Packet_vkResetCommandBuffer +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId commandBuffer; + VkCommandBufferResetFlags flags; +}; + + +struct Packet_vkResetCommandPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId commandPool; + VkCommandPoolResetFlags flags; +}; + + +struct Packet_vkResetDescriptorPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId descriptorPool; + VkDescriptorPoolResetFlags flags; +}; + + +struct Packet_vkResetEvent +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId event; +}; + + +struct Packet_vkResetFences +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t fenceCount; + HandlePointerDecoder pFences; +}; + + +struct Packet_vkSetEvent +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId event; +}; + + +struct Packet_vkUnmapMemory +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId memory; +}; + + +struct Packet_vkUpdateDescriptorSets +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + uint32_t descriptorWriteCount; + StructPointerDecoder pDescriptorWrites; + uint32_t descriptorCopyCount; + StructPointerDecoder pDescriptorCopies; +}; + + +struct Packet_vkWaitForFences +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t fenceCount; + HandlePointerDecoder pFences; + VkBool32 waitAll; + uint64_t timeout; +}; + +struct Packet_vkBindBufferMemory2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; +}; + + +struct Packet_vkBindImageMemory2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; +}; + + +struct Packet_vkCmdDispatchBase +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t baseGroupX; + uint32_t baseGroupY; + uint32_t baseGroupZ; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +}; + + +struct Packet_vkCmdSetDeviceMask +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t deviceMask; +}; + + +struct Packet_vkCreateDescriptorUpdateTemplate +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDescriptorUpdateTemplate; +}; + + +struct Packet_vkCreateSamplerYcbcrConversion +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pYcbcrConversion; +}; + + +struct Packet_vkDestroyDescriptorUpdateTemplate +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId descriptorUpdateTemplate; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroySamplerYcbcrConversion +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId ycbcrConversion; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkEnumeratePhysicalDeviceGroups +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + PointerDecoder pPhysicalDeviceGroupCount; + StructPointerDecoder pPhysicalDeviceGroupProperties; +}; + + +struct Packet_vkGetBufferMemoryRequirements2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetDescriptorSetLayoutSupport +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pSupport; +}; + + +struct Packet_vkGetDeviceGroupPeerMemoryFeatures +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + uint32_t heapIndex; + uint32_t localDeviceIndex; + uint32_t remoteDeviceIndex; + PointerDecoder pPeerMemoryFeatures; +}; + + +struct Packet_vkGetDeviceQueue2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pQueueInfo; + HandlePointerDecoder pQueue; +}; + + +struct Packet_vkGetImageMemoryRequirements2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetImageSparseMemoryRequirements2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; +}; + + +struct Packet_vkGetPhysicalDeviceExternalBufferProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pExternalBufferInfo; + StructPointerDecoder pExternalBufferProperties; +}; + + +struct Packet_vkGetPhysicalDeviceExternalFenceProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pExternalFenceInfo; + StructPointerDecoder pExternalFenceProperties; +}; + + +struct Packet_vkGetPhysicalDeviceExternalSemaphoreProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pExternalSemaphoreInfo; + StructPointerDecoder pExternalSemaphoreProperties; +}; + + +struct Packet_vkGetPhysicalDeviceFeatures2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pFeatures; +}; + + +struct Packet_vkGetPhysicalDeviceFormatProperties2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + VkFormat format; + StructPointerDecoder pFormatProperties; +}; + + +struct Packet_vkGetPhysicalDeviceImageFormatProperties2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pImageFormatInfo; + StructPointerDecoder pImageFormatProperties; +}; + + +struct Packet_vkGetPhysicalDeviceMemoryProperties2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pMemoryProperties; +}; + + +struct Packet_vkGetPhysicalDeviceProperties2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetPhysicalDeviceQueueFamilyProperties2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + PointerDecoder pQueueFamilyPropertyCount; + StructPointerDecoder pQueueFamilyProperties; +}; + + +struct Packet_vkGetPhysicalDeviceSparseImageFormatProperties2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pFormatInfo; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkTrimCommandPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId commandPool; + VkCommandPoolTrimFlags flags; +}; + +struct Packet_vkCmdBeginRenderPass2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pRenderPassBegin; + StructPointerDecoder pSubpassBeginInfo; +}; + + +struct Packet_vkCmdDrawIndexedIndirectCount +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; +}; + + +struct Packet_vkCmdDrawIndirectCount +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; +}; + + +struct Packet_vkCmdEndRenderPass2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pSubpassEndInfo; +}; + + +struct Packet_vkCmdNextSubpass2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pSubpassBeginInfo; + StructPointerDecoder pSubpassEndInfo; +}; + + +struct Packet_vkCreateRenderPass2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pRenderPass; +}; + + +struct Packet_vkGetBufferDeviceAddress +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkDeviceAddress return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkGetBufferOpaqueCaptureAddress +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + uint64_t return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkGetDeviceMemoryOpaqueCaptureAddress +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + uint64_t return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkGetSemaphoreCounterValue +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId semaphore; + PointerDecoder pValue; +}; + + +struct Packet_vkResetQueryPool +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; +}; + + +struct Packet_vkSignalSemaphore +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pSignalInfo; +}; + + +struct Packet_vkWaitSemaphores +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pWaitInfo; + uint64_t timeout; +}; + +struct Packet_vkCmdBeginRendering +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pRenderingInfo; +}; + + +struct Packet_vkCmdBindVertexBuffers2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstBinding; + uint32_t bindingCount; + HandlePointerDecoder pBuffers; + PointerDecoder pOffsets; + PointerDecoder pSizes; + PointerDecoder pStrides; +}; + + +struct Packet_vkCmdBlitImage2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pBlitImageInfo; +}; + + +struct Packet_vkCmdCopyBuffer2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pCopyBufferInfo; +}; + + +struct Packet_vkCmdCopyBufferToImage2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pCopyBufferToImageInfo; +}; + + +struct Packet_vkCmdCopyImage2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pCopyImageInfo; +}; + + +struct Packet_vkCmdCopyImageToBuffer2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pCopyImageToBufferInfo; +}; + + +struct Packet_vkCmdEndRendering +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; +}; + + +struct Packet_vkCmdPipelineBarrier2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pDependencyInfo; +}; + + +struct Packet_vkCmdResetEvent2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId event; + VkPipelineStageFlags2 stageMask; +}; + + +struct Packet_vkCmdResolveImage2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pResolveImageInfo; +}; + + +struct Packet_vkCmdSetCullMode +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkCullModeFlags cullMode; +}; + + +struct Packet_vkCmdSetDepthBiasEnable +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthBiasEnable; +}; + + +struct Packet_vkCmdSetDepthBoundsTestEnable +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthBoundsTestEnable; +}; + + +struct Packet_vkCmdSetDepthCompareOp +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkCompareOp depthCompareOp; +}; + + +struct Packet_vkCmdSetDepthTestEnable +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthTestEnable; +}; + + +struct Packet_vkCmdSetDepthWriteEnable +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthWriteEnable; +}; + + +struct Packet_vkCmdSetEvent2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId event; + StructPointerDecoder pDependencyInfo; +}; + + +struct Packet_vkCmdSetFrontFace +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkFrontFace frontFace; +}; + + +struct Packet_vkCmdSetPrimitiveRestartEnable +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 primitiveRestartEnable; +}; + + +struct Packet_vkCmdSetPrimitiveTopology +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPrimitiveTopology primitiveTopology; +}; + + +struct Packet_vkCmdSetRasterizerDiscardEnable +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 rasterizerDiscardEnable; +}; + + +struct Packet_vkCmdSetScissorWithCount +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t scissorCount; + StructPointerDecoder pScissors; +}; + + +struct Packet_vkCmdSetStencilOp +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; +}; + + +struct Packet_vkCmdSetStencilTestEnable +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 stencilTestEnable; +}; + + +struct Packet_vkCmdSetViewportWithCount +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t viewportCount; + StructPointerDecoder pViewports; +}; + + +struct Packet_vkCmdWaitEvents2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t eventCount; + HandlePointerDecoder pEvents; + StructPointerDecoder pDependencyInfos; +}; + + +struct Packet_vkCmdWriteTimestamp2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineStageFlags2 stage; + format::HandleId queryPool; + uint32_t query; +}; + + +struct Packet_vkCreatePrivateDataSlot +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPrivateDataSlot; +}; + + +struct Packet_vkDestroyPrivateDataSlot +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId privateDataSlot; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetDeviceBufferMemoryRequirements +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetDeviceImageMemoryRequirements +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetDeviceImageSparseMemoryRequirements +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; +}; + + +struct Packet_vkGetPhysicalDeviceToolProperties +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pToolCount; + StructPointerDecoder pToolProperties; +}; + + +struct Packet_vkGetPrivateData +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + VkObjectType objectType; + uint64_t objectHandle; + format::HandleId privateDataSlot; + PointerDecoder pData; +}; + + +struct Packet_vkQueueSubmit2 +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId queue; + uint32_t submitCount; + StructPointerDecoder pSubmits; + format::HandleId fence; +}; + + +struct Packet_vkSetPrivateData +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + VkObjectType objectType; + uint64_t objectHandle; + format::HandleId privateDataSlot; + uint64_t data; +}; + +struct Packet_vkDestroySurfaceKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId instance; + format::HandleId surface; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetPhysicalDeviceSurfaceCapabilitiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId surface; + StructPointerDecoder pSurfaceCapabilities; +}; + + +struct Packet_vkGetPhysicalDeviceSurfaceFormatsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId surface; + PointerDecoder pSurfaceFormatCount; + StructPointerDecoder pSurfaceFormats; +}; + + +struct Packet_vkGetPhysicalDeviceSurfacePresentModesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId surface; + PointerDecoder pPresentModeCount; + PointerDecoder pPresentModes; +}; + + +struct Packet_vkGetPhysicalDeviceSurfaceSupportKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + format::HandleId surface; + PointerDecoder pSupported; +}; + +struct Packet_vkAcquireNextImage2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pAcquireInfo; + PointerDecoder pImageIndex; +}; + + +struct Packet_vkAcquireNextImageKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; + uint64_t timeout; + format::HandleId semaphore; + format::HandleId fence; + PointerDecoder pImageIndex; +}; + + +struct Packet_vkCreateSwapchainKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSwapchain; +}; + + +struct Packet_vkDestroySwapchainKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetDeviceGroupPresentCapabilitiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pDeviceGroupPresentCapabilities; +}; + + +struct Packet_vkGetDeviceGroupSurfacePresentModesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId surface; + PointerDecoder pModes; +}; + + +struct Packet_vkGetPhysicalDevicePresentRectanglesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId surface; + PointerDecoder pRectCount; + StructPointerDecoder pRects; +}; + + +struct Packet_vkGetSwapchainImagesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; + PointerDecoder pSwapchainImageCount; + HandlePointerDecoder pSwapchainImages; +}; + + +struct Packet_vkQueuePresentKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId queue; + StructPointerDecoder pPresentInfo; +}; + +struct Packet_vkCreateDisplayModeKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId display; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pMode; +}; + + +struct Packet_vkCreateDisplayPlaneSurfaceKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + + +struct Packet_vkGetDisplayModePropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId display; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetDisplayPlaneCapabilitiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId mode; + uint32_t planeIndex; + StructPointerDecoder pCapabilities; +}; + + +struct Packet_vkGetDisplayPlaneSupportedDisplaysKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + uint32_t planeIndex; + PointerDecoder pDisplayCount; + HandlePointerDecoder pDisplays; +}; + + +struct Packet_vkGetPhysicalDeviceDisplayPlanePropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetPhysicalDeviceDisplayPropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + +struct Packet_vkCreateSharedSwapchainsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t swapchainCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSwapchains; +}; + +struct Packet_vkCreateXlibSurfaceKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + + +struct Packet_vkGetPhysicalDeviceXlibPresentationSupportKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkBool32 return_value; + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t dpy; + size_t visualID; +}; + +struct Packet_vkCreateXcbSurfaceKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + + +struct Packet_vkGetPhysicalDeviceXcbPresentationSupportKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkBool32 return_value; + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t connection; + uint32_t visual_id; +}; + +struct Packet_vkCreateWaylandSurfaceKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + + +struct Packet_vkGetPhysicalDeviceWaylandPresentationSupportKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkBool32 return_value; + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t display; +}; + +struct Packet_vkCreateAndroidSurfaceKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + +struct Packet_vkCreateWin32SurfaceKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + + +struct Packet_vkGetPhysicalDeviceWin32PresentationSupportKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkBool32 return_value; + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; +}; + +struct Packet_vkBindVideoSessionMemoryKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId videoSession; + uint32_t bindSessionMemoryInfoCount; + StructPointerDecoder pBindSessionMemoryInfos; +}; + + +struct Packet_vkCmdBeginVideoCodingKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pBeginInfo; +}; + + +struct Packet_vkCmdControlVideoCodingKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pCodingControlInfo; +}; + + +struct Packet_vkCmdEndVideoCodingKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pEndCodingInfo; +}; + + +struct Packet_vkCreateVideoSessionKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pVideoSession; +}; + + +struct Packet_vkCreateVideoSessionParametersKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pVideoSessionParameters; +}; + + +struct Packet_vkDestroyVideoSessionKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId videoSession; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkDestroyVideoSessionParametersKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId videoSessionParameters; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetPhysicalDeviceVideoCapabilitiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pVideoProfile; + StructPointerDecoder pCapabilities; +}; + + +struct Packet_vkGetPhysicalDeviceVideoFormatPropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pVideoFormatInfo; + PointerDecoder pVideoFormatPropertyCount; + StructPointerDecoder pVideoFormatProperties; +}; + + +struct Packet_vkGetVideoSessionMemoryRequirementsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId videoSession; + PointerDecoder pMemoryRequirementsCount; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkUpdateVideoSessionParametersKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId videoSessionParameters; + StructPointerDecoder pUpdateInfo; +}; + +struct Packet_vkCmdDecodeVideoKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pDecodeInfo; +}; + +struct Packet_vkCmdBeginRenderingKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pRenderingInfo; +}; + + +struct Packet_vkCmdEndRenderingKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; +}; + +struct Packet_vkGetPhysicalDeviceFeatures2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pFeatures; +}; + + +struct Packet_vkGetPhysicalDeviceFormatProperties2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + VkFormat format; + StructPointerDecoder pFormatProperties; +}; + + +struct Packet_vkGetPhysicalDeviceImageFormatProperties2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pImageFormatInfo; + StructPointerDecoder pImageFormatProperties; +}; + + +struct Packet_vkGetPhysicalDeviceMemoryProperties2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pMemoryProperties; +}; + + +struct Packet_vkGetPhysicalDeviceProperties2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetPhysicalDeviceQueueFamilyProperties2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + PointerDecoder pQueueFamilyPropertyCount; + StructPointerDecoder pQueueFamilyProperties; +}; + + +struct Packet_vkGetPhysicalDeviceSparseImageFormatProperties2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pFormatInfo; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + +struct Packet_vkCmdDispatchBaseKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t baseGroupX; + uint32_t baseGroupY; + uint32_t baseGroupZ; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +}; + + +struct Packet_vkCmdSetDeviceMaskKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t deviceMask; +}; + + +struct Packet_vkGetDeviceGroupPeerMemoryFeaturesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + uint32_t heapIndex; + uint32_t localDeviceIndex; + uint32_t remoteDeviceIndex; + PointerDecoder pPeerMemoryFeatures; +}; + +struct Packet_vkTrimCommandPoolKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId commandPool; + VkCommandPoolTrimFlags flags; +}; + +struct Packet_vkEnumeratePhysicalDeviceGroupsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + PointerDecoder pPhysicalDeviceGroupCount; + StructPointerDecoder pPhysicalDeviceGroupProperties; +}; + +struct Packet_vkGetPhysicalDeviceExternalBufferPropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pExternalBufferInfo; + StructPointerDecoder pExternalBufferProperties; +}; + +struct Packet_vkGetMemoryWin32HandleKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pGetWin32HandleInfo; + PointerDecoder pHandle; +}; + + +struct Packet_vkGetMemoryWin32HandlePropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + VkExternalMemoryHandleTypeFlagBits handleType; + uint64_t handle; + StructPointerDecoder pMemoryWin32HandleProperties; +}; + +struct Packet_vkGetMemoryFdKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pGetFdInfo; + PointerDecoder pFd; +}; + + +struct Packet_vkGetMemoryFdPropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; + StructPointerDecoder pMemoryFdProperties; +}; + +struct Packet_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pExternalSemaphoreInfo; + StructPointerDecoder pExternalSemaphoreProperties; +}; + +struct Packet_vkGetSemaphoreWin32HandleKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pGetWin32HandleInfo; + PointerDecoder pHandle; +}; + + +struct Packet_vkImportSemaphoreWin32HandleKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pImportSemaphoreWin32HandleInfo; +}; + +struct Packet_vkGetSemaphoreFdKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pGetFdInfo; + PointerDecoder pFd; +}; + + +struct Packet_vkImportSemaphoreFdKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pImportSemaphoreFdInfo; +}; + +struct Packet_vkCmdPushDescriptorSetKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId layout; + uint32_t set; + uint32_t descriptorWriteCount; + StructPointerDecoder pDescriptorWrites; +}; + +struct Packet_vkCreateDescriptorUpdateTemplateKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDescriptorUpdateTemplate; +}; + + +struct Packet_vkDestroyDescriptorUpdateTemplateKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId descriptorUpdateTemplate; + StructPointerDecoder pAllocator; +}; + +struct Packet_vkCmdBeginRenderPass2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pRenderPassBegin; + StructPointerDecoder pSubpassBeginInfo; +}; + + +struct Packet_vkCmdEndRenderPass2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pSubpassEndInfo; +}; + + +struct Packet_vkCmdNextSubpass2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pSubpassBeginInfo; + StructPointerDecoder pSubpassEndInfo; +}; + + +struct Packet_vkCreateRenderPass2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pRenderPass; +}; + +struct Packet_vkGetSwapchainStatusKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; +}; + +struct Packet_vkGetPhysicalDeviceExternalFencePropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pExternalFenceInfo; + StructPointerDecoder pExternalFenceProperties; +}; + +struct Packet_vkGetFenceWin32HandleKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pGetWin32HandleInfo; + PointerDecoder pHandle; +}; + + +struct Packet_vkImportFenceWin32HandleKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pImportFenceWin32HandleInfo; +}; + +struct Packet_vkGetFenceFdKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pGetFdInfo; + PointerDecoder pFd; +}; + + +struct Packet_vkImportFenceFdKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pImportFenceFdInfo; +}; + +struct Packet_vkAcquireProfilingLockKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + PointerDecoder pCounterCount; + StructPointerDecoder pCounters; + StructPointerDecoder pCounterDescriptions; +}; + + +struct Packet_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + StructPointerDecoder pPerformanceQueryCreateInfo; + PointerDecoder pNumPasses; +}; + + +struct Packet_vkReleaseProfilingLockKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; +}; + +struct Packet_vkGetPhysicalDeviceSurfaceCapabilities2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pSurfaceInfo; + StructPointerDecoder pSurfaceCapabilities; +}; + + +struct Packet_vkGetPhysicalDeviceSurfaceFormats2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pSurfaceInfo; + PointerDecoder pSurfaceFormatCount; + StructPointerDecoder pSurfaceFormats; +}; + +struct Packet_vkGetDisplayModeProperties2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId display; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetDisplayPlaneCapabilities2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pDisplayPlaneInfo; + StructPointerDecoder pCapabilities; +}; + + +struct Packet_vkGetPhysicalDeviceDisplayPlaneProperties2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetPhysicalDeviceDisplayProperties2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + +struct Packet_vkGetBufferMemoryRequirements2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetImageMemoryRequirements2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetImageSparseMemoryRequirements2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; +}; + +struct Packet_vkCreateSamplerYcbcrConversionKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pYcbcrConversion; +}; + + +struct Packet_vkDestroySamplerYcbcrConversionKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId ycbcrConversion; + StructPointerDecoder pAllocator; +}; + +struct Packet_vkBindBufferMemory2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; +}; + + +struct Packet_vkBindImageMemory2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; +}; + +struct Packet_vkGetDescriptorSetLayoutSupportKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pSupport; +}; + +struct Packet_vkCmdDrawIndexedIndirectCountKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; +}; + + +struct Packet_vkCmdDrawIndirectCountKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; +}; + +struct Packet_vkGetSemaphoreCounterValueKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId semaphore; + PointerDecoder pValue; +}; + + +struct Packet_vkSignalSemaphoreKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pSignalInfo; +}; + + +struct Packet_vkWaitSemaphoresKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pWaitInfo; + uint64_t timeout; +}; + +struct Packet_vkCmdSetFragmentShadingRateKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pFragmentSize; + PointerDecoder combinerOps; +}; + + +struct Packet_vkGetPhysicalDeviceFragmentShadingRatesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pFragmentShadingRateCount; + StructPointerDecoder pFragmentShadingRates; +}; + +struct Packet_vkCmdSetRenderingAttachmentLocationsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pLocationInfo; +}; + + +struct Packet_vkCmdSetRenderingInputAttachmentIndicesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pInputAttachmentIndexInfo; +}; + +struct Packet_vkWaitForPresentKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; + uint64_t presentId; + uint64_t timeout; +}; + +struct Packet_vkGetBufferDeviceAddressKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkDeviceAddress return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkGetBufferOpaqueCaptureAddressKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + uint64_t return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkGetDeviceMemoryOpaqueCaptureAddressKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + uint64_t return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + +struct Packet_vkCreateDeferredOperationKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pAllocator; + HandlePointerDecoder pDeferredOperation; +}; + + +struct Packet_vkDeferredOperationJoinKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId operation; +}; + + +struct Packet_vkDestroyDeferredOperationKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId operation; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetDeferredOperationMaxConcurrencyKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + uint32_t return_value; + format::HandleId device; + format::HandleId operation; +}; + + +struct Packet_vkGetDeferredOperationResultKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId operation; +}; + +struct Packet_vkGetPipelineExecutableInternalRepresentationsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pExecutableInfo; + PointerDecoder pInternalRepresentationCount; + StructPointerDecoder pInternalRepresentations; +}; + + +struct Packet_vkGetPipelineExecutablePropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pPipelineInfo; + PointerDecoder pExecutableCount; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetPipelineExecutableStatisticsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pExecutableInfo; + PointerDecoder pStatisticCount; + StructPointerDecoder pStatistics; +}; + +struct Packet_vkMapMemory2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pMemoryMapInfo; + PointerDecoder ppData; +}; + + +struct Packet_vkUnmapMemory2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pMemoryUnmapInfo; +}; + +struct Packet_vkCmdEncodeVideoKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pEncodeInfo; +}; + + +struct Packet_vkGetEncodedVideoSessionParametersKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pVideoSessionParametersInfo; + StructPointerDecoder pFeedbackInfo; + PointerDecoder pDataSize; + PointerDecoder pData; +}; + + +struct Packet_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pQualityLevelInfo; + StructPointerDecoder pQualityLevelProperties; +}; + +struct Packet_vkCmdPipelineBarrier2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pDependencyInfo; +}; + + +struct Packet_vkCmdResetEvent2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId event; + VkPipelineStageFlags2 stageMask; +}; + + +struct Packet_vkCmdSetEvent2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId event; + StructPointerDecoder pDependencyInfo; +}; + + +struct Packet_vkCmdWaitEvents2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t eventCount; + HandlePointerDecoder pEvents; + StructPointerDecoder pDependencyInfos; +}; + + +struct Packet_vkCmdWriteBufferMarker2AMD +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineStageFlags2 stage; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + uint32_t marker; +}; + + +struct Packet_vkCmdWriteTimestamp2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineStageFlags2 stage; + format::HandleId queryPool; + uint32_t query; +}; + + +struct Packet_vkGetQueueCheckpointData2NV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId queue; + PointerDecoder pCheckpointDataCount; + StructPointerDecoder pCheckpointData; +}; + + +struct Packet_vkQueueSubmit2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId queue; + uint32_t submitCount; + StructPointerDecoder pSubmits; + format::HandleId fence; +}; + +struct Packet_vkCmdBlitImage2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pBlitImageInfo; +}; + + +struct Packet_vkCmdCopyBuffer2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pCopyBufferInfo; +}; + + +struct Packet_vkCmdCopyBufferToImage2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pCopyBufferToImageInfo; +}; + + +struct Packet_vkCmdCopyImage2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pCopyImageInfo; +}; + + +struct Packet_vkCmdCopyImageToBuffer2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pCopyImageToBufferInfo; +}; + + +struct Packet_vkCmdResolveImage2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pResolveImageInfo; +}; + +struct Packet_vkCmdTraceRaysIndirect2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkDeviceAddress indirectDeviceAddress; +}; + +struct Packet_vkGetDeviceBufferMemoryRequirementsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetDeviceImageMemoryRequirementsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetDeviceImageSparseMemoryRequirementsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pSparseMemoryRequirementCount; + StructPointerDecoder pSparseMemoryRequirements; +}; + +struct Packet_vkCmdBindIndexBuffer2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkIndexType indexType; +}; + + +struct Packet_vkGetDeviceImageSubresourceLayoutKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pLayout; +}; + + +struct Packet_vkGetImageSubresourceLayout2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId image; + StructPointerDecoder pSubresource; + StructPointerDecoder pLayout; +}; + + +struct Packet_vkGetRenderingAreaGranularityKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pRenderingAreaInfo; + StructPointerDecoder pGranularity; +}; + +struct Packet_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + +struct Packet_vkCmdSetLineStippleKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +}; + +struct Packet_vkGetCalibratedTimestampsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t timestampCount; + StructPointerDecoder pTimestampInfos; + PointerDecoder pTimestamps; + PointerDecoder pMaxDeviation; +}; + + +struct Packet_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pTimeDomainCount; + PointerDecoder pTimeDomains; +}; + +struct Packet_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pBindDescriptorBufferEmbeddedSamplersInfo; +}; + + +struct Packet_vkCmdBindDescriptorSets2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pBindDescriptorSetsInfo; +}; + + +struct Packet_vkCmdPushConstants2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pPushConstantsInfo; +}; + + +struct Packet_vkCmdPushDescriptorSet2KHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pPushDescriptorSetInfo; +}; + + +struct Packet_vkCmdSetDescriptorBufferOffsets2EXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pSetDescriptorBufferOffsetsInfo; +}; + +struct Packet_vkFrameBoundaryANDROID +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId semaphore; + format::HandleId image; +}; + +struct Packet_vkCreateDebugReportCallbackEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pCallback; +}; + + +struct Packet_vkDebugReportMessageEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId instance; + VkDebugReportFlagsEXT flags; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + size_t location; + int32_t messageCode; + StringDecoder pLayerPrefix; + StringDecoder pMessage; +}; + + +struct Packet_vkDestroyDebugReportCallbackEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId instance; + format::HandleId callback; + StructPointerDecoder pAllocator; +}; + +struct Packet_vkCmdDebugMarkerBeginEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pMarkerInfo; +}; + + +struct Packet_vkCmdDebugMarkerEndEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; +}; + + +struct Packet_vkCmdDebugMarkerInsertEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pMarkerInfo; +}; + + +struct Packet_vkDebugMarkerSetObjectNameEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pNameInfo; +}; + + +struct Packet_vkDebugMarkerSetObjectTagEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pTagInfo; +}; + +struct Packet_vkCmdBeginQueryIndexedEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t query; + VkQueryControlFlags flags; + uint32_t index; +}; + + +struct Packet_vkCmdBeginTransformFeedbackEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstCounterBuffer; + uint32_t counterBufferCount; + HandlePointerDecoder pCounterBuffers; + PointerDecoder pCounterBufferOffsets; +}; + + +struct Packet_vkCmdBindTransformFeedbackBuffersEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstBinding; + uint32_t bindingCount; + HandlePointerDecoder pBuffers; + PointerDecoder pOffsets; + PointerDecoder pSizes; +}; + + +struct Packet_vkCmdDrawIndirectByteCountEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t instanceCount; + uint32_t firstInstance; + format::HandleId counterBuffer; + VkDeviceSize counterBufferOffset; + uint32_t counterOffset; + uint32_t vertexStride; +}; + + +struct Packet_vkCmdEndQueryIndexedEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId queryPool; + uint32_t query; + uint32_t index; +}; + + +struct Packet_vkCmdEndTransformFeedbackEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstCounterBuffer; + uint32_t counterBufferCount; + HandlePointerDecoder pCounterBuffers; + PointerDecoder pCounterBufferOffsets; +}; + +struct Packet_vkGetImageViewAddressNVX +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId imageView; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetImageViewHandleNVX +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + uint32_t return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + +struct Packet_vkCmdDrawIndexedIndirectCountAMD +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; +}; + + +struct Packet_vkCmdDrawIndirectCountAMD +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; +}; + +struct Packet_vkGetShaderInfoAMD +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId pipeline; + VkShaderStageFlagBits shaderStage; + VkShaderInfoTypeAMD infoType; + PointerDecoder pInfoSize; + PointerDecoder pInfo; +}; + +struct Packet_vkCreateStreamDescriptorSurfaceGGP +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + +struct Packet_vkGetPhysicalDeviceExternalImageFormatPropertiesNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; + VkExternalMemoryHandleTypeFlagsNV externalHandleType; + StructPointerDecoder pExternalImageFormatProperties; +}; + +struct Packet_vkGetMemoryWin32HandleNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId memory; + VkExternalMemoryHandleTypeFlagsNV handleType; + PointerDecoder pHandle; +}; + +struct Packet_vkCreateViSurfaceNN +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + +struct Packet_vkCmdBeginConditionalRenderingEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pConditionalRenderingBegin; +}; + + +struct Packet_vkCmdEndConditionalRenderingEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; +}; + +struct Packet_vkCmdSetViewportWScalingNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstViewport; + uint32_t viewportCount; + StructPointerDecoder pViewportWScalings; +}; + +struct Packet_vkReleaseDisplayEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId display; +}; + +struct Packet_vkAcquireXlibDisplayEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + uint64_t dpy; + format::HandleId display; +}; + + +struct Packet_vkGetRandROutputDisplayEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + uint64_t dpy; + size_t rrOutput; + HandlePointerDecoder pDisplay; +}; + +struct Packet_vkGetPhysicalDeviceSurfaceCapabilities2EXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId surface; + StructPointerDecoder pSurfaceCapabilities; +}; + +struct Packet_vkDisplayPowerControlEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId display; + StructPointerDecoder pDisplayPowerInfo; +}; + + +struct Packet_vkGetSwapchainCounterEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; + VkSurfaceCounterFlagBitsEXT counter; + PointerDecoder pCounterValue; +}; + + +struct Packet_vkRegisterDeviceEventEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pDeviceEventInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pFence; +}; + + +struct Packet_vkRegisterDisplayEventEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId display; + StructPointerDecoder pDisplayEventInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pFence; +}; + +struct Packet_vkGetPastPresentationTimingGOOGLE +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; + PointerDecoder pPresentationTimingCount; + StructPointerDecoder pPresentationTimings; +}; + + +struct Packet_vkGetRefreshCycleDurationGOOGLE +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pDisplayTimingProperties; +}; + +struct Packet_vkCmdSetDiscardRectangleEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstDiscardRectangle; + uint32_t discardRectangleCount; + StructPointerDecoder pDiscardRectangles; +}; + + +struct Packet_vkCmdSetDiscardRectangleEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 discardRectangleEnable; +}; + + +struct Packet_vkCmdSetDiscardRectangleModeEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkDiscardRectangleModeEXT discardRectangleMode; +}; + +struct Packet_vkSetHdrMetadataEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + uint32_t swapchainCount; + HandlePointerDecoder pSwapchains; + StructPointerDecoder pMetadata; +}; + +struct Packet_vkCreateIOSSurfaceMVK +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + +struct Packet_vkCreateMacOSSurfaceMVK +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + +struct Packet_vkCmdBeginDebugUtilsLabelEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pLabelInfo; +}; + + +struct Packet_vkCmdEndDebugUtilsLabelEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; +}; + + +struct Packet_vkCmdInsertDebugUtilsLabelEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pLabelInfo; +}; + + +struct Packet_vkCreateDebugUtilsMessengerEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pMessenger; +}; + + +struct Packet_vkDestroyDebugUtilsMessengerEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId instance; + format::HandleId messenger; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkQueueBeginDebugUtilsLabelEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId queue; + StructPointerDecoder pLabelInfo; +}; + + +struct Packet_vkQueueEndDebugUtilsLabelEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId queue; +}; + + +struct Packet_vkQueueInsertDebugUtilsLabelEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId queue; + StructPointerDecoder pLabelInfo; +}; + + +struct Packet_vkSetDebugUtilsObjectNameEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pNameInfo; +}; + + +struct Packet_vkSetDebugUtilsObjectTagEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pTagInfo; +}; + + +struct Packet_vkSubmitDebugUtilsMessageEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId instance; + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageTypes; + StructPointerDecoder pCallbackData; +}; + +struct Packet_vkGetAndroidHardwareBufferPropertiesANDROID +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint64_t buffer; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetMemoryAndroidHardwareBufferANDROID +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pInfo; + PointerDecoder pBuffer; +}; + +struct Packet_vkCmdSetSampleLocationsEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pSampleLocationsInfo; +}; + + +struct Packet_vkGetPhysicalDeviceMultisamplePropertiesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId physicalDevice; + VkSampleCountFlagBits samples; + StructPointerDecoder pMultisampleProperties; +}; + +struct Packet_vkGetImageDrmFormatModifierPropertiesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId image; + StructPointerDecoder pProperties; +}; + +struct Packet_vkCreateValidationCacheEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pValidationCache; +}; + + +struct Packet_vkDestroyValidationCacheEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId validationCache; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetValidationCacheDataEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId validationCache; + PointerDecoder pDataSize; + PointerDecoder pData; +}; + + +struct Packet_vkMergeValidationCachesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId dstCache; + uint32_t srcCacheCount; + HandlePointerDecoder pSrcCaches; +}; + +struct Packet_vkCmdBindShadingRateImageNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId imageView; + VkImageLayout imageLayout; +}; + + +struct Packet_vkCmdSetCoarseSampleOrderNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + StructPointerDecoder pCustomSampleOrders; +}; + + +struct Packet_vkCmdSetViewportShadingRatePaletteNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstViewport; + uint32_t viewportCount; + StructPointerDecoder pShadingRatePalettes; +}; + +struct Packet_vkBindAccelerationStructureMemoryNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t bindInfoCount; + StructPointerDecoder pBindInfos; +}; + + +struct Packet_vkCmdBuildAccelerationStructureNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pInfo; + format::HandleId instanceData; + VkDeviceSize instanceOffset; + VkBool32 update; + format::HandleId dst; + format::HandleId src; + format::HandleId scratch; + VkDeviceSize scratchOffset; +}; + + +struct Packet_vkCmdCopyAccelerationStructureNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId dst; + format::HandleId src; + VkCopyAccelerationStructureModeKHR mode; +}; + + +struct Packet_vkCmdTraceRaysNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId raygenShaderBindingTableBuffer; + VkDeviceSize raygenShaderBindingOffset; + format::HandleId missShaderBindingTableBuffer; + VkDeviceSize missShaderBindingOffset; + VkDeviceSize missShaderBindingStride; + format::HandleId hitShaderBindingTableBuffer; + VkDeviceSize hitShaderBindingOffset; + VkDeviceSize hitShaderBindingStride; + format::HandleId callableShaderBindingTableBuffer; + VkDeviceSize callableShaderBindingOffset; + VkDeviceSize callableShaderBindingStride; + uint32_t width; + uint32_t height; + uint32_t depth; +}; + + +struct Packet_vkCmdWriteAccelerationStructuresPropertiesNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t accelerationStructureCount; + HandlePointerDecoder pAccelerationStructures; + VkQueryType queryType; + format::HandleId queryPool; + uint32_t firstQuery; +}; + + +struct Packet_vkCompileDeferredNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId pipeline; + uint32_t shader; +}; + + +struct Packet_vkCreateAccelerationStructureNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pAccelerationStructure; +}; + + +struct Packet_vkCreateRayTracingPipelinesNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId pipelineCache; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPipelines; +}; + + +struct Packet_vkDestroyAccelerationStructureNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId accelerationStructure; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetAccelerationStructureHandleNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId accelerationStructure; + size_t dataSize; + PointerDecoder pData; +}; + + +struct Packet_vkGetAccelerationStructureMemoryRequirementsNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + + +struct Packet_vkGetRayTracingShaderGroupHandlesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId pipeline; + uint32_t firstGroup; + uint32_t groupCount; + size_t dataSize; + PointerDecoder pData; +}; + + +struct Packet_vkGetRayTracingShaderGroupHandlesNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId pipeline; + uint32_t firstGroup; + uint32_t groupCount; + size_t dataSize; + PointerDecoder pData; +}; + +struct Packet_vkGetMemoryHostPointerPropertiesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + VkExternalMemoryHandleTypeFlagBits handleType; + uint64_t pHostPointer; + StructPointerDecoder pMemoryHostPointerProperties; +}; + +struct Packet_vkCmdWriteBufferMarkerAMD +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineStageFlagBits pipelineStage; + format::HandleId dstBuffer; + VkDeviceSize dstOffset; + uint32_t marker; +}; + +struct Packet_vkGetCalibratedTimestampsEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t timestampCount; + StructPointerDecoder pTimestampInfos; + PointerDecoder pTimestamps; + PointerDecoder pMaxDeviation; +}; + + +struct Packet_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pTimeDomainCount; + PointerDecoder pTimeDomains; +}; + +struct Packet_vkCmdDrawMeshTasksIndirectCountNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; +}; + + +struct Packet_vkCmdDrawMeshTasksIndirectNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + uint32_t drawCount; + uint32_t stride; +}; + + +struct Packet_vkCmdDrawMeshTasksNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t taskCount; + uint32_t firstTask; +}; + +struct Packet_vkCmdSetExclusiveScissorEnableNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstExclusiveScissor; + uint32_t exclusiveScissorCount; + PointerDecoder pExclusiveScissorEnables; +}; + + +struct Packet_vkCmdSetExclusiveScissorNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstExclusiveScissor; + uint32_t exclusiveScissorCount; + StructPointerDecoder pExclusiveScissors; +}; + +struct Packet_vkCmdSetCheckpointNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint64_t pCheckpointMarker; +}; + + +struct Packet_vkGetQueueCheckpointDataNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId queue; + PointerDecoder pCheckpointDataCount; + StructPointerDecoder pCheckpointData; +}; + +struct Packet_vkAcquirePerformanceConfigurationINTEL +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pAcquireInfo; + HandlePointerDecoder pConfiguration; +}; + + +struct Packet_vkCmdSetPerformanceMarkerINTEL +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId commandBuffer; + StructPointerDecoder pMarkerInfo; +}; + + +struct Packet_vkCmdSetPerformanceOverrideINTEL +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId commandBuffer; + StructPointerDecoder pOverrideInfo; +}; + + +struct Packet_vkCmdSetPerformanceStreamMarkerINTEL +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId commandBuffer; + StructPointerDecoder pMarkerInfo; +}; + + +struct Packet_vkGetPerformanceParameterINTEL +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + VkPerformanceParameterTypeINTEL parameter; + StructPointerDecoder pValue; +}; + + +struct Packet_vkInitializePerformanceApiINTEL +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pInitializeInfo; +}; + + +struct Packet_vkQueueSetPerformanceConfigurationINTEL +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId queue; + format::HandleId configuration; +}; + + +struct Packet_vkReleasePerformanceConfigurationINTEL +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId configuration; +}; + + +struct Packet_vkUninitializePerformanceApiINTEL +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; +}; + +struct Packet_vkSetLocalDimmingAMD +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId swapChain; + VkBool32 localDimmingEnable; +}; + +struct Packet_vkCreateImagePipeSurfaceFUCHSIA +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + +struct Packet_vkCreateMetalSurfaceEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + +struct Packet_vkGetBufferDeviceAddressEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkDeviceAddress return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + +struct Packet_vkGetPhysicalDeviceToolPropertiesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pToolCount; + StructPointerDecoder pToolProperties; +}; + +struct Packet_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pPropertyCount; + StructPointerDecoder pProperties; +}; + +struct Packet_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + PointerDecoder pCombinationCount; + StructPointerDecoder pCombinations; +}; + +struct Packet_vkAcquireFullScreenExclusiveModeEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; +}; + + +struct Packet_vkGetDeviceGroupSurfacePresentModes2EXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pSurfaceInfo; + PointerDecoder pModes; +}; + + +struct Packet_vkGetPhysicalDeviceSurfacePresentModes2EXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pSurfaceInfo; + PointerDecoder pPresentModeCount; + PointerDecoder pPresentModes; +}; + + +struct Packet_vkReleaseFullScreenExclusiveModeEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; +}; + +struct Packet_vkCreateHeadlessSurfaceEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + +struct Packet_vkCmdSetLineStippleEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +}; + +struct Packet_vkResetQueryPoolEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId queryPool; + uint32_t firstQuery; + uint32_t queryCount; +}; + +struct Packet_vkCmdBindVertexBuffers2EXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstBinding; + uint32_t bindingCount; + HandlePointerDecoder pBuffers; + PointerDecoder pOffsets; + PointerDecoder pSizes; + PointerDecoder pStrides; +}; + + +struct Packet_vkCmdSetCullModeEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkCullModeFlags cullMode; +}; + + +struct Packet_vkCmdSetDepthBoundsTestEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthBoundsTestEnable; +}; + + +struct Packet_vkCmdSetDepthCompareOpEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkCompareOp depthCompareOp; +}; + + +struct Packet_vkCmdSetDepthTestEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthTestEnable; +}; + + +struct Packet_vkCmdSetDepthWriteEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthWriteEnable; +}; + + +struct Packet_vkCmdSetFrontFaceEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkFrontFace frontFace; +}; + + +struct Packet_vkCmdSetPrimitiveTopologyEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPrimitiveTopology primitiveTopology; +}; + + +struct Packet_vkCmdSetScissorWithCountEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t scissorCount; + StructPointerDecoder pScissors; +}; + + +struct Packet_vkCmdSetStencilOpEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkStencilFaceFlags faceMask; + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; +}; + + +struct Packet_vkCmdSetStencilTestEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 stencilTestEnable; +}; + + +struct Packet_vkCmdSetViewportWithCountEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t viewportCount; + StructPointerDecoder pViewports; +}; + +struct Packet_vkCopyImageToImageEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCopyImageToImageInfo; +}; + + +struct Packet_vkCopyImageToMemoryEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCopyImageToMemoryInfo; +}; + + +struct Packet_vkCopyMemoryToImageEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCopyMemoryToImageInfo; +}; + + +struct Packet_vkGetImageSubresourceLayout2EXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId image; + StructPointerDecoder pSubresource; + StructPointerDecoder pLayout; +}; + + +struct Packet_vkTransitionImageLayoutEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t transitionCount; + StructPointerDecoder pTransitions; +}; + +struct Packet_vkReleaseSwapchainImagesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pReleaseInfo; +}; + +struct Packet_vkCmdBindPipelineShaderGroupNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId pipeline; + uint32_t groupIndex; +}; + + +struct Packet_vkCmdExecuteGeneratedCommandsNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 isPreprocessed; + StructPointerDecoder pGeneratedCommandsInfo; +}; + + +struct Packet_vkCmdPreprocessGeneratedCommandsNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pGeneratedCommandsInfo; +}; + + +struct Packet_vkCreateIndirectCommandsLayoutNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pIndirectCommandsLayout; +}; + + +struct Packet_vkDestroyIndirectCommandsLayoutNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId indirectCommandsLayout; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetGeneratedCommandsMemoryRequirementsNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; +}; + +struct Packet_vkCmdSetDepthBias2EXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pDepthBiasInfo; +}; + +struct Packet_vkAcquireDrmDisplayEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + int32_t drmFd; + format::HandleId display; +}; + + +struct Packet_vkGetDrmDisplayEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + int32_t drmFd; + uint32_t connectorId; + HandlePointerDecoder display; +}; + +struct Packet_vkCreatePrivateDataSlotEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pPrivateDataSlot; +}; + + +struct Packet_vkDestroyPrivateDataSlotEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId privateDataSlot; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetPrivateDataEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + VkObjectType objectType; + uint64_t objectHandle; + format::HandleId privateDataSlot; + PointerDecoder pData; +}; + + +struct Packet_vkSetPrivateDataEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + VkObjectType objectType; + uint64_t objectHandle; + format::HandleId privateDataSlot; + uint64_t data; +}; + +struct Packet_vkCmdSetFragmentShadingRateEnumNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkFragmentShadingRateNV shadingRate; + PointerDecoder combinerOps; +}; + +struct Packet_vkGetDeviceFaultInfoEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pFaultCounts; + StructPointerDecoder pFaultInfo; +}; + +struct Packet_vkAcquireWinrtDisplayNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + format::HandleId display; +}; + + +struct Packet_vkGetWinrtDisplayNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + uint32_t deviceRelativeId; + HandlePointerDecoder pDisplay; +}; + +struct Packet_vkCreateDirectFBSurfaceEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + + +struct Packet_vkGetPhysicalDeviceDirectFBPresentationSupportEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkBool32 return_value; + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t dfb; +}; + +struct Packet_vkCmdSetVertexInputEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t vertexBindingDescriptionCount; + StructPointerDecoder pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + StructPointerDecoder pVertexAttributeDescriptions; +}; + +struct Packet_vkGetMemoryZirconHandleFUCHSIA +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pGetZirconHandleInfo; + PointerDecoder pZirconHandle; +}; + + +struct Packet_vkGetMemoryZirconHandlePropertiesFUCHSIA +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + VkExternalMemoryHandleTypeFlagBits handleType; + uint32_t zirconHandle; + StructPointerDecoder pMemoryZirconHandleProperties; +}; + +struct Packet_vkGetSemaphoreZirconHandleFUCHSIA +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pGetZirconHandleInfo; + PointerDecoder pZirconHandle; +}; + + +struct Packet_vkImportSemaphoreZirconHandleFUCHSIA +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pImportSemaphoreZirconHandleInfo; +}; + +struct Packet_vkCmdBindInvocationMaskHUAWEI +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId imageView; + VkImageLayout imageLayout; +}; + +struct Packet_vkGetMemoryRemoteAddressNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pMemoryGetRemoteAddressInfo; + PointerDecoder pAddress; +}; + +struct Packet_vkCmdSetDepthBiasEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthBiasEnable; +}; + + +struct Packet_vkCmdSetLogicOpEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkLogicOp logicOp; +}; + + +struct Packet_vkCmdSetPatchControlPointsEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t patchControlPoints; +}; + + +struct Packet_vkCmdSetPrimitiveRestartEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 primitiveRestartEnable; +}; + + +struct Packet_vkCmdSetRasterizerDiscardEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 rasterizerDiscardEnable; +}; + +struct Packet_vkCreateScreenSurfaceQNX +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId instance; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSurface; +}; + + +struct Packet_vkGetPhysicalDeviceScreenPresentationSupportQNX +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkBool32 return_value; + format::HandleId physicalDevice; + uint32_t queueFamilyIndex; + uint64_t window; +}; + +struct Packet_vkCmdSetColorWriteEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t attachmentCount; + PointerDecoder pColorWriteEnables; +}; + +struct Packet_vkCmdDrawMultiEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t drawCount; + StructPointerDecoder pVertexInfo; + uint32_t instanceCount; + uint32_t firstInstance; + uint32_t stride; +}; + + +struct Packet_vkCmdDrawMultiIndexedEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t drawCount; + StructPointerDecoder pIndexInfo; + uint32_t instanceCount; + uint32_t firstInstance; + uint32_t stride; + PointerDecoder pVertexOffset; +}; + +struct Packet_vkBuildMicromapsEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId deferredOperation; + uint32_t infoCount; + StructPointerDecoder pInfos; +}; + + +struct Packet_vkCmdBuildMicromapsEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t infoCount; + StructPointerDecoder pInfos; +}; + + +struct Packet_vkCmdCopyMemoryToMicromapEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCmdCopyMicromapEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCmdCopyMicromapToMemoryEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCmdWriteMicromapsPropertiesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t micromapCount; + HandlePointerDecoder pMicromaps; + VkQueryType queryType; + format::HandleId queryPool; + uint32_t firstQuery; +}; + + +struct Packet_vkCopyMemoryToMicromapEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCopyMicromapEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCopyMicromapToMemoryEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCreateMicromapEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pMicromap; +}; + + +struct Packet_vkDestroyMicromapEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId micromap; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetDeviceMicromapCompatibilityEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pVersionInfo; + PointerDecoder pCompatibility; +}; + + +struct Packet_vkGetMicromapBuildSizesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + VkAccelerationStructureBuildTypeKHR buildType; + StructPointerDecoder pBuildInfo; + StructPointerDecoder pSizeInfo; +}; + + +struct Packet_vkWriteMicromapsPropertiesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t micromapCount; + HandlePointerDecoder pMicromaps; + VkQueryType queryType; + size_t dataSize; + PointerDecoder pData; + size_t stride; +}; + +struct Packet_vkCmdDrawClusterHUAWEI +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +}; + + +struct Packet_vkCmdDrawClusterIndirectHUAWEI +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; +}; + +struct Packet_vkSetDeviceMemoryPriorityEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId memory; + float priority; +}; + +struct Packet_vkGetDescriptorSetHostMappingVALVE +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId descriptorSet; + PointerDecoder ppData; +}; + + +struct Packet_vkGetDescriptorSetLayoutHostMappingInfoVALVE +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pBindingReference; + StructPointerDecoder pHostMapping; +}; + +struct Packet_vkCmdUpdatePipelineIndirectBufferNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPipelineBindPoint pipelineBindPoint; + format::HandleId pipeline; +}; + + +struct Packet_vkGetPipelineIndirectDeviceAddressNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkDeviceAddress return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkGetPipelineIndirectMemoryRequirementsNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pMemoryRequirements; +}; + +struct Packet_vkCmdSetAlphaToCoverageEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 alphaToCoverageEnable; +}; + + +struct Packet_vkCmdSetAlphaToOneEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 alphaToOneEnable; +}; + + +struct Packet_vkCmdSetColorBlendAdvancedEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstAttachment; + uint32_t attachmentCount; + StructPointerDecoder pColorBlendAdvanced; +}; + + +struct Packet_vkCmdSetColorBlendEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstAttachment; + uint32_t attachmentCount; + PointerDecoder pColorBlendEnables; +}; + + +struct Packet_vkCmdSetColorBlendEquationEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstAttachment; + uint32_t attachmentCount; + StructPointerDecoder pColorBlendEquations; +}; + + +struct Packet_vkCmdSetColorWriteMaskEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstAttachment; + uint32_t attachmentCount; + PointerDecoder pColorWriteMasks; +}; + + +struct Packet_vkCmdSetConservativeRasterizationModeEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; +}; + + +struct Packet_vkCmdSetCoverageModulationModeNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkCoverageModulationModeNV coverageModulationMode; +}; + + +struct Packet_vkCmdSetCoverageModulationTableEnableNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 coverageModulationTableEnable; +}; + + +struct Packet_vkCmdSetCoverageModulationTableNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t coverageModulationTableCount; + PointerDecoder pCoverageModulationTable; +}; + + +struct Packet_vkCmdSetCoverageReductionModeNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkCoverageReductionModeNV coverageReductionMode; +}; + + +struct Packet_vkCmdSetCoverageToColorEnableNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 coverageToColorEnable; +}; + + +struct Packet_vkCmdSetCoverageToColorLocationNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t coverageToColorLocation; +}; + + +struct Packet_vkCmdSetDepthClampEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthClampEnable; +}; + + +struct Packet_vkCmdSetDepthClipEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 depthClipEnable; +}; + + +struct Packet_vkCmdSetDepthClipNegativeOneToOneEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 negativeOneToOne; +}; + + +struct Packet_vkCmdSetExtraPrimitiveOverestimationSizeEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + float extraPrimitiveOverestimationSize; +}; + + +struct Packet_vkCmdSetLineRasterizationModeEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkLineRasterizationModeEXT lineRasterizationMode; +}; + + +struct Packet_vkCmdSetLineStippleEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 stippledLineEnable; +}; + + +struct Packet_vkCmdSetLogicOpEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 logicOpEnable; +}; + + +struct Packet_vkCmdSetPolygonModeEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkPolygonMode polygonMode; +}; + + +struct Packet_vkCmdSetProvokingVertexModeEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkProvokingVertexModeEXT provokingVertexMode; +}; + + +struct Packet_vkCmdSetRasterizationSamplesEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkSampleCountFlagBits rasterizationSamples; +}; + + +struct Packet_vkCmdSetRasterizationStreamEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t rasterizationStream; +}; + + +struct Packet_vkCmdSetRepresentativeFragmentTestEnableNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 representativeFragmentTestEnable; +}; + + +struct Packet_vkCmdSetSampleLocationsEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 sampleLocationsEnable; +}; + + +struct Packet_vkCmdSetSampleMaskEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkSampleCountFlagBits samples; + PointerDecoder pSampleMask; +}; + + +struct Packet_vkCmdSetShadingRateImageEnableNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 shadingRateImageEnable; +}; + + +struct Packet_vkCmdSetTessellationDomainOriginEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkTessellationDomainOrigin domainOrigin; +}; + + +struct Packet_vkCmdSetViewportSwizzleNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t firstViewport; + uint32_t viewportCount; + StructPointerDecoder pViewportSwizzles; +}; + + +struct Packet_vkCmdSetViewportWScalingEnableNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkBool32 viewportWScalingEnable; +}; + +struct Packet_vkGetShaderModuleCreateInfoIdentifierEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pIdentifier; +}; + + +struct Packet_vkGetShaderModuleIdentifierEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId shaderModule; + StructPointerDecoder pIdentifier; +}; + +struct Packet_vkBindOpticalFlowSessionImageNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId session; + VkOpticalFlowSessionBindingPointNV bindingPoint; + format::HandleId view; + VkImageLayout layout; +}; + + +struct Packet_vkCmdOpticalFlowExecuteNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId session; + StructPointerDecoder pExecuteInfo; +}; + + +struct Packet_vkCreateOpticalFlowSessionNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pSession; +}; + + +struct Packet_vkDestroyOpticalFlowSessionNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId session; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetPhysicalDeviceOpticalFlowImageFormatsNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId physicalDevice; + StructPointerDecoder pOpticalFlowImageFormatInfo; + PointerDecoder pFormatCount; + StructPointerDecoder pImageFormatProperties; +}; + +struct Packet_vkCmdBindShadersEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t stageCount; + PointerDecoder pStages; + HandlePointerDecoder pShaders; +}; + + +struct Packet_vkCreateShadersEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t createInfoCount; + StructPointerDecoder pCreateInfos; + StructPointerDecoder pAllocator; + HandlePointerDecoder pShaders; +}; + + +struct Packet_vkDestroyShaderEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId shader; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetShaderBinaryDataEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId shader; + PointerDecoder pDataSize; + PointerDecoder pData; +}; + +struct Packet_vkGetDynamicRenderingTilePropertiesQCOM +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pRenderingInfo; + StructPointerDecoder pProperties; +}; + + +struct Packet_vkGetFramebufferTilePropertiesQCOM +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId framebuffer; + PointerDecoder pPropertiesCount; + StructPointerDecoder pProperties; +}; + +struct Packet_vkGetLatencyTimingsNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pLatencyMarkerInfo; +}; + + +struct Packet_vkLatencySleepNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pSleepInfo; +}; + + +struct Packet_vkQueueNotifyOutOfBandNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId queue; + StructPointerDecoder pQueueTypeInfo; +}; + + +struct Packet_vkSetLatencyMarkerNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pLatencyMarkerInfo; +}; + + +struct Packet_vkSetLatencySleepModeNV +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId swapchain; + StructPointerDecoder pSleepModeInfo; +}; + +struct Packet_vkCmdSetAttachmentFeedbackLoopEnableEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + VkImageAspectFlags aspectMask; +}; + +struct Packet_vkCmdBuildAccelerationStructuresIndirectKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t infoCount; + StructPointerDecoder pInfos; + PointerDecoder pIndirectDeviceAddresses; + PointerDecoder pIndirectStrides; + PointerDecoder ppMaxPrimitiveCounts; +}; + + +struct Packet_vkCmdBuildAccelerationStructuresKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t infoCount; + StructPointerDecoder pInfos; + StructPointerDecoder ppBuildRangeInfos; +}; + + +struct Packet_vkCmdCopyAccelerationStructureKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCmdCopyAccelerationStructureToMemoryKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCmdCopyMemoryToAccelerationStructureKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCmdWriteAccelerationStructuresPropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t accelerationStructureCount; + HandlePointerDecoder pAccelerationStructures; + VkQueryType queryType; + format::HandleId queryPool; + uint32_t firstQuery; +}; + + +struct Packet_vkCopyAccelerationStructureToMemoryKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCopyMemoryToAccelerationStructureKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId deferredOperation; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkCreateAccelerationStructureKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pAccelerationStructure; +}; + + +struct Packet_vkDestroyAccelerationStructureKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + format::HandleId accelerationStructure; + StructPointerDecoder pAllocator; +}; + + +struct Packet_vkGetAccelerationStructureBuildSizesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + VkAccelerationStructureBuildTypeKHR buildType; + StructPointerDecoder pBuildInfo; + PointerDecoder pMaxPrimitiveCounts; + StructPointerDecoder pSizeInfo; +}; + + +struct Packet_vkGetAccelerationStructureDeviceAddressKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkDeviceAddress return_value; + format::HandleId device; + StructPointerDecoder pInfo; +}; + + +struct Packet_vkGetDeviceAccelerationStructureCompatibilityKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId device; + StructPointerDecoder pVersionInfo; + PointerDecoder pCompatibility; +}; + + +struct Packet_vkWriteAccelerationStructuresPropertiesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + uint32_t accelerationStructureCount; + HandlePointerDecoder pAccelerationStructures; + VkQueryType queryType; + size_t dataSize; + PointerDecoder pData; + size_t stride; +}; + +struct Packet_vkCmdSetRayTracingPipelineStackSizeKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t pipelineStackSize; +}; + + +struct Packet_vkCmdTraceRaysIndirectKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pRaygenShaderBindingTable; + StructPointerDecoder pMissShaderBindingTable; + StructPointerDecoder pHitShaderBindingTable; + StructPointerDecoder pCallableShaderBindingTable; + VkDeviceAddress indirectDeviceAddress; +}; + + +struct Packet_vkCmdTraceRaysKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + StructPointerDecoder pRaygenShaderBindingTable; + StructPointerDecoder pMissShaderBindingTable; + StructPointerDecoder pHitShaderBindingTable; + StructPointerDecoder pCallableShaderBindingTable; + uint32_t width; + uint32_t height; + uint32_t depth; +}; + + +struct Packet_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkResult return_value; + format::HandleId device; + format::HandleId pipeline; + uint32_t firstGroup; + uint32_t groupCount; + size_t dataSize; + PointerDecoder pData; +}; + + +struct Packet_vkGetRayTracingShaderGroupStackSizeKHR +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + VkDeviceSize return_value; + format::HandleId device; + format::HandleId pipeline; + uint32_t group; + VkShaderGroupShaderKHR groupShader; +}; + +struct Packet_vkCmdDrawMeshTasksEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +}; + + +struct Packet_vkCmdDrawMeshTasksIndirectCountEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + format::HandleId countBuffer; + VkDeviceSize countBufferOffset; + uint32_t maxDrawCount; + uint32_t stride; +}; + + +struct Packet_vkCmdDrawMeshTasksIndirectEXT +{ + format::PacketCallId packet_id; + ApiCallInfo call_info; + format::HandleId commandBuffer; + format::HandleId buffer; + VkDeviceSize offset; + uint32_t drawCount; + uint32_t stride; +}; + + +GFXRECON_END_NAMESPACE(decode) +GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/generated/vulkan_generators/gencode.py b/framework/generated/vulkan_generators/gencode.py index 27fb03e157..363285541c 100644 --- a/framework/generated/vulkan_generators/gencode.py +++ b/framework/generated/vulkan_generators/gencode.py @@ -109,6 +109,16 @@ from vulkan_cpp_struct_generator import VulkanCppStructGenerator, VulkanCppStructGeneratorOptions from vulkan_cpp_consumer_extension_generator import VulkanCppConsumerExtensionGenerator, VulkanCppConsumerExtensionGeneratorOptions +# Preload +from vulkan_struct_packet_header_generator import VulkanStructPacketsHeaderGenerator, VulkanStructPacketsHeaderGeneratorOptions +from vulkan_preload_decoder_body_generator import VulkanPreloadDecoderBodyGenerator, VulkanPreloadDecoderBodyGeneratorOptions +from vulkan_preload_decoder_header_generator import VulkanPreloadDecoderHeaderGenerator, VulkanPreloadDecoderHeaderGeneratorOptions +from vulkan_preload_replayer_header_generator import VulkanPreloadReplayerHeaderGenerator, VulkanPreloadReplayerHeaderGeneratorOptions +from vulkan_preload_replayer_body_generator import VulkanPreloadReplayerBodyGenerator, VulkanPreloadReplayerBodyGeneratorOptions +# from vulkan_preload_struct_decoders_forward_generator import VulkanPreloadStructDecodersForwardGenerator, VulkanPreloadStructDecodersForwardGeneratorOptions +# from vulkan_preload_struct_decoders_body_generator import VulkanPreloadStructDecodersBodyGenerator, VulkanPreloadStructDecodersBodyGeneratorOptions +from vulkan_preload_decode_pnext_struct_generator import VulkanPreloadDecodePNextStructGenerator, VulkanPreloadDecodePNextStructGeneratorOptions + # Simple timer functions start_time = None @@ -921,6 +931,87 @@ def make_gen_opts(args): ) ] + gen_opts['generated_vulkan_struct_packet.h'] = [ + VulkanStructPacketsHeaderGenerator, + VulkanStructPacketsHeaderGeneratorOptions( + filename = 'generated_vulkan_struct_packet.h', + directory = directory, + blacklists = blacklists, + platform_types = platform_types, + prefix_text = prefix_strings + vk_prefix_strings, + protect_file = False, + protect_feature = False, + extraVulkanHeaders=extraVulkanHeaders) + ] + + gen_opts['generated_vulkan_preload_decoder.h'] = [ + VulkanPreloadDecoderHeaderGenerator, + VulkanPreloadDecoderHeaderGeneratorOptions( + filename='generated_vulkan_preload_decoder.h', + directory=directory, + blacklists=blacklists, + platform_types=platform_types, + prefix_text=prefix_strings + vk_prefix_strings, + protect_file=True, + protect_feature=False, + extraVulkanHeaders=extraVulkanHeaders + ) + ] + + gen_opts['generated_vulkan_preload_decoder.cpp'] = [ + VulkanPreloadDecoderBodyGenerator, + VulkanPreloadDecoderBodyGeneratorOptions( + filename='generated_vulkan_preload_decoder.cpp', + directory=directory, + blacklists=blacklists, + platform_types=platform_types, + prefix_text=prefix_strings + vk_prefix_strings, + protect_file=False, + protect_feature=False, + extraVulkanHeaders=extraVulkanHeaders + ) + ] + + gen_opts['generated_vulkan_preload_replayer.h'] = [ + VulkanPreloadReplayerHeaderGenerator, + VulkanPreloadReplayerHeaderGeneratorOptions( + filename='generated_vulkan_preload_replayer.h', + directory=directory, + blacklists=blacklists, + platform_types=platform_types, + prefix_text=prefix_strings + vk_prefix_strings, + protect_file=True, + protect_feature=False, + extraVulkanHeaders=extraVulkanHeaders + ) + ] + + gen_opts['generated_vulkan_preload_replayer.cpp'] = [ + VulkanPreloadReplayerBodyGenerator, + VulkanPreloadReplayerBodyGeneratorOptions( + filename='generated_vulkan_preload_replayer.cpp', + directory=directory, + blacklists=blacklists, + platform_types=platform_types, + prefix_text=prefix_strings + vk_prefix_strings, + protect_file=False, + protect_feature=False, + extraVulkanHeaders=extraVulkanHeaders + ) + ] + + gen_opts['generated_vulkan_preload_decode_pnext_struct.cpp'] = [ + VulkanPreloadDecodePNextStructGenerator, + VulkanPreloadDecodePNextStructGeneratorOptions( + filename='generated_vulkan_preload_decode_pnext_struct.cpp', + directory=directory, + prefix_text=prefix_strings + vk_prefix_strings, + protect_file=False, + protect_feature=False, + extraVulkanHeaders=extraVulkanHeaders + ) + ] + def gen_target(args): """Generate a target based on the options in the matching gen_opts{} object. This is encapsulated in a function so it can be profiled and/or timed. diff --git a/framework/generated/vulkan_generators/vulkan_preload_decode_pnext_struct_generator.py b/framework/generated/vulkan_generators/vulkan_preload_decode_pnext_struct_generator.py new file mode 100644 index 0000000000..7ab8313c67 --- /dev/null +++ b/framework/generated/vulkan_generators/vulkan_preload_decode_pnext_struct_generator.py @@ -0,0 +1,237 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2018 Valve Corporation +# Copyright (c) 2018 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. + +import sys +from base_generator import BaseGenerator, BaseGeneratorOptions, write + + +class VulkanPreloadDecodePNextStructGeneratorOptions(BaseGeneratorOptions): + """Eliminates JSON black_lists and platform_types files, which are not necessary for + pNext switch statement generation. + Options for Vulkan API pNext structure decoding C++ code generation. + """ + + def __init__( + self, + filename=None, + directory='.', + prefix_text='', + protect_file=False, + protect_feature=True, + extraVulkanHeaders=[] + ): + BaseGeneratorOptions.__init__( + self, + None, + None, + filename, + directory, + prefix_text, + protect_file, + protect_feature, + extraVulkanHeaders=extraVulkanHeaders + ) + + +class VulkanPreloadDecodePNextStructGenerator(BaseGenerator): + """DecodePNextStructGenerator - subclass of BaseGenerator. + Generates C++ code for Vulkan API pNext structure decoding. + Generate pNext structure decoding C++ code. + """ + + def __init__( + self, err_file=sys.stderr, warn_file=sys.stderr, diag_file=sys.stdout + ): + BaseGenerator.__init__( + self, + process_cmds=False, + process_structs=False, + feature_break=False, + err_file=err_file, + warn_file=warn_file, + diag_file=diag_file + ) + + # Map to store VkStructureType enum values. + self.stype_values = dict() + + def beginFile(self, gen_opts): + """Method override.""" + BaseGenerator.beginFile(self, gen_opts) + + write( + '#include "decode/custom_vulkan_struct_decoders.h"', + file=self.outFile + ) + write('#include "decode/decode_allocator.h"', file=self.outFile) + write('#include "decode/vulkan_pnext_node.h"', file=self.outFile) + write('#include "decode/vulkan_pnext_typed_node.h"', file=self.outFile) + write( + '#include "generated/generated_vulkan_struct_decoders.h"', + file=self.outFile + ) + write( + '#include "generated/generated_vulkan_enum_to_string.h"', + file=self.outFile + ) + write('#include "util/logging.h"', file=self.outFile) + self.newline() + write('#include ', file=self.outFile) + self.newline() + write('GFXRECON_BEGIN_NAMESPACE(gfxrecon)', file=self.outFile) + write('GFXRECON_BEGIN_NAMESPACE(decode)', file=self.outFile) + self.newline() + write( + 'size_t PreloadDecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, PNextNode** pNext)', + file=self.outFile + ) + write('{', file=self.outFile) + write(' assert(pNext != nullptr);', file=self.outFile) + self.newline() + write(' size_t bytes_read = 0;', file=self.outFile) + write(' uint32_t attrib = 0;', file=self.outFile) + self.newline() + write( + ' if ((parameter_buffer != nullptr) && (buffer_size >= sizeof(attrib)))', + file=self.outFile + ) + write(' {', file=self.outFile) + write(' size_t stype_offset = 0;', file=self.outFile) + self.newline() + write( + ' // Peek at the pointer attribute mask to make sure we have a non-NULL value that can be decoded.', + file=self.outFile + ) + write( + ' attrib = *(reinterpret_cast(parameter_buffer));', + file=self.outFile + ) + self.newline() + write( + ' if ((attrib & format::PointerAttributes::kIsNull) != format::PointerAttributes::kIsNull)', + file=self.outFile + ) + write(' {', file=self.outFile) + write( + ' // Offset to VkStructureType, after the pointer encoding preamble.', + file=self.outFile + ) + write(' stype_offset = sizeof(attrib);', file=self.outFile) + self.newline() + write( + ' if ((attrib & format::PointerAttributes::kHasAddress) == format::PointerAttributes::kHasAddress)', + file=self.outFile + ) + write(' {', file=self.outFile) + write( + ' stype_offset += sizeof(format::AddressEncodeType);', + file=self.outFile + ) + write(' }', file=self.outFile) + write(' }', file=self.outFile) + self.newline() + write( + ' if ((stype_offset != 0) && ((buffer_size - stype_offset) >= sizeof(VkStructureType)))', + file=self.outFile + ) + write(' {', file=self.outFile) + write( + ' const VkStructureType* sType = reinterpret_cast(parameter_buffer + stype_offset);', + file=self.outFile + ) + self.newline() + write(' switch (*sType)', file=self.outFile) + write(' {', file=self.outFile) + write(' default:', file=self.outFile) + write( + ' // TODO: This may need to be a fatal error', + file=self.outFile + ) + write( + ' GFXRECON_LOG_ERROR("Failed to decode pNext value with unrecognized VkStructureType = %s", (util::ToString(*sType).c_str()));', + file=self.outFile + ) + write(' break;', file=self.outFile) + + def endFile(self): + """Method override.""" + write(' }', file=self.outFile) + write(' }', file=self.outFile) + write(' }', file=self.outFile) + self.newline() + write(' if ((bytes_read == 0) && (attrib != 0))', file=self.outFile) + write(' {', file=self.outFile) + write( + ' // The encoded pointer attribute mask included kIsNull, or the sType was unrecognized.', + file=self.outFile + ) + write( + ' // We will report that we read the attribute mask, but nothing else was decoded.', + file=self.outFile + ) + write(' bytes_read = sizeof(attrib);', file=self.outFile) + write(' }', file=self.outFile) + self.newline() + write(' return bytes_read;', file=self.outFile) + write('}', file=self.outFile) + self.newline() + write('GFXRECON_END_NAMESPACE(decode)', file=self.outFile) + write('GFXRECON_END_NAMESPACE(gfxrecon)', file=self.outFile) + + # Finish processing in superclass + BaseGenerator.endFile(self) + + def genStruct(self, typeinfo, typename, alias): + """Method override.""" + if not alias: + # Only process struct types that specify a 'structextends' tag, which indicates the struct can be used in a pNext chain. + parent_structs = typeinfo.elem.get('structextends') + if parent_structs: + stype = self.make_structure_type_enum(typeinfo, typename) + if stype: + self.stype_values[typename] = stype + + def need_feature_generation(self): + """Indicates that the current feature has C++ code to generate.""" + if self.stype_values: + return True + return False + + def generate_feature(self): + """Performs C++ code generation for the feature.""" + for struct in self.stype_values: + write( + ' case {}:'.format(self.stype_values[struct]), + file=self.outFile + ) + write( + ' (*pNext) = PreloadDecodeAllocator::Allocate>();' + .format(struct), + file=self.outFile + ) + write( + ' bytes_read = (*pNext)->PreloadDecode(parameter_buffer, buffer_size);', + file=self.outFile + ) + write(' break;', file=self.outFile) + self.stype_values = dict() diff --git a/framework/generated/vulkan_generators/vulkan_preload_decoder_body_generator.py b/framework/generated/vulkan_generators/vulkan_preload_decoder_body_generator.py new file mode 100644 index 0000000000..5f318189a5 --- /dev/null +++ b/framework/generated/vulkan_generators/vulkan_preload_decoder_body_generator.py @@ -0,0 +1,336 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2018-2020 Valve Corporation +# Copyright (c) 2018-2020 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. + +import sys +from base_generator import BaseGenerator, BaseGeneratorOptions, ValueInfo, write +from base_decoder_body_generator import BaseDecoderBodyGenerator + + +class VulkanPreloadDecoderBodyGeneratorOptions(BaseGeneratorOptions): + """Options for generating a C++ class for Vulkan API parameter decoding.""" + + def __init__( + self, + blacklists=None, # Path to JSON file listing apicalls and structs to ignore. + platform_types=None, # Path to JSON file listing platform (WIN32, X11, etc.) defined types. + filename=None, + directory='.', + prefix_text='', + protect_file=False, + protect_feature=True, + extraVulkanHeaders=[] + ): + BaseGeneratorOptions.__init__( + self, + blacklists, + platform_types, + filename, + directory, + prefix_text, + protect_file, + protect_feature, + extraVulkanHeaders=extraVulkanHeaders + ) + + +class VulkanPreloadDecoderBodyGenerator(BaseDecoderBodyGenerator, BaseGenerator): + """VulkanPreloadDecoderBodyGenerator - subclass of BaseGenerator. + Generates C++ member functions for the VulkanPreloadDecoder class responsible for decoding + Vulkan API call parameter data. + Generate a C++ class for Vulkan API parameter decoding. + """ + + def __init__( + self, err_file=sys.stderr, warn_file=sys.stderr, diag_file=sys.stdout + ): + BaseGenerator.__init__( + self, + process_cmds=True, + process_structs=False, + feature_break=True, + err_file=err_file, + warn_file=warn_file, + diag_file=diag_file + ) + + # Names of all Vulkan commands processed by the generator. + self.cmd_names = [] + + def beginFile(self, gen_opts): + """Method override.""" + BaseGenerator.beginFile(self, gen_opts) + + write('#include "decode/handle_pointer_decoder.h"', file=self.outFile) + write('#include "decode/pointer_decoder.h"', file=self.outFile) + write('#include "decode/string_array_decoder.h"', file=self.outFile) + write('#include "decode/string_decoder.h"', file=self.outFile) + write('#include "decode/struct_pointer_decoder.h"', file=self.outFile) + write('#include "decode/value_decoder.h"', file=self.outFile) + write('#include "decode/vulkan_pnext_node.h"', file=self.outFile) + write( + '#include "generated/generated_vulkan_decoder.h"', + file=self.outFile + ) + write( + '#include "generated/generated_vulkan_struct_decoders_forward.h"', + file=self.outFile + ) + write( + '#include "generated/generated_vulkan_struct_packet.h"', + file=self.outFile + ) + write( + '#include "generated/generated_vulkan_preload_decoder.h"', + file=self.outFile + ) + write('#include "util/defines.h"', file=self.outFile) + self.newline() + self.includeVulkanHeaders(gen_opts) + self.newline() + write('#include ', file=self.outFile) + self.newline() + write('GFXRECON_BEGIN_NAMESPACE(gfxrecon)', file=self.outFile) + write('GFXRECON_BEGIN_NAMESPACE(decode)', file=self.outFile) + + def endFile(self): + """Method override.""" + self.newline() + # Generate the VulkanDecoder::DecodeFunctionCall method for all of the commands processed by the generator. + self.generate_decode_cases() + self.newline() + write('GFXRECON_END_NAMESPACE(decode)', file=self.outFile) + write('GFXRECON_END_NAMESPACE(gfxrecon)', file=self.outFile) + + # Finish processing in superclass + BaseGenerator.endFile(self) + + def need_feature_generation(self): + """Indicates that the current feature has C++ code to generate.""" + if self.feature_cmd_params: + return True + return False + + def generate_feature(self): + """Performs C++ code generation for the feature.""" + platform_type = self.get_api_prefix() + + first = True + for cmd in self.get_filtered_cmd_names(): + self.cmd_names.append(cmd) + + info = self.feature_cmd_params[cmd] + return_type = info[0] + values = info[2] + + cmddef = '' if first else '\n' + cmddef += 'size_t {}PreloadDecoder::Decode_{}(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size)\n'.format( + platform_type, cmd + ) + cmddef += '{\n' + cmddef += ' size_t bytes_read = 0;\n' + cmddef += '\n' + cmddef += self.make_cmd_body(return_type, cmd, values) + cmddef += '\n' + cmddef += ' return bytes_read;\n' + cmddef += '}' + + write(cmddef, file=self.outFile) + first = False + + def make_cmd_body(self, return_type, name, values): + """Generate C++ code for the decoder method body.""" + body = '' + arg_names = [] + + # Declarations for decoded types. + for value in values: + decode_type = self.make_decoded_param_type(value) + body += ' {} {};\n'.format(decode_type, value.name) + + if decode_type == 'Decoded_{}'.format(value.base_type): + body += ' {} value_{};\n'.format( + value.base_type, value.name + ) + body += ' {0}.decoded_value = &value_{0};\n'.format( + value.name + ) + + if 'Decoder' in decode_type: + arg_names.append('&{}'.format(value.name)) + else: + arg_names.append(value.name) + + # Vulkan return is very simple. + if return_type and return_type != 'void': + body += ' {} return_value;\n'.format(return_type) + + # Blank line after declarations. + if values or return_type: + body += '\n' + + for value in values: + body += self.make_decode_invocation( + value + ) + if return_type and return_type != 'void': + body += self.make_decode_invocation( + ValueInfo('return_value', return_type, return_type) + ) + + # Blank line after Decode() method invocations. + if values or return_type: + body += '\n' + + # Make the argument list for the API call + arglist = ', '.join([arg_name for arg_name in arg_names]) + if return_type and return_type != 'void': + arglist = ', '.join(['return_value', arglist]) + + + if arglist[-2:] == ', ': + arglist = arglist[:-2] + arglist = 'call_info, ' + arglist + + # Create a packet + body += ' Packet_{}* packet = PreloadDecodeAllocator::Allocate();\n'.format(name, name) + body += ' packet->packet_id = gfxrecon::format::PacketCall_{};\n'.format(name) + body += ' packet->call_info = call_info;\n' + for value in values: + body += ' packet->{} = {};\n'.format(value.name, value.name) + if return_type and return_type != 'void': + body += ' packet->return_value = return_value;\n' + + # Save the packet to the container + body += '\n' + body += ' AddPacket(reinterpret_cast(packet));\n' + + return body + + def make_decode_invocation(self, value): + """Generate parameter decode function/method invocation.""" + buffer_args = '(parameter_buffer + bytes_read), (buffer_size - bytes_read)' + body = '' + + is_struct = False + is_class = False + is_string = False + is_funcp = False + is_handle = False + + type_name = self.make_invocation_type_name(value.base_type) + + if self.is_struct(type_name): + is_struct = True + elif self.is_class(value): + is_class = True + elif type_name in ['String', 'WString']: + is_string = True + elif type_name == 'FunctionPtr': + is_funcp = True + elif self.is_handle(value.base_type): + is_handle = True + + # is_pointer will be False for static arrays. + if value.is_pointer or value.is_array: + if not is_class and type_name in self.EXTERNAL_OBJECT_TYPES and not value.is_array: + if value.pointer_count > 1: + # Pointer to a pointer to an unknown object type (void**), encoded as a pointer to a 64-bit integer ID. + body += ' bytes_read += {}.DecodeVoidPtr({});\n'.format( + value.name, buffer_args + ) + else: + # Pointer to an unknown object type, encoded as a 64-bit integer ID. + body += ' bytes_read += ValueDecoder::DecodeAddress({}, &{});\n'.format( + buffer_args, value.name + ) + else: + if is_struct or is_string or is_handle or ( + is_class and value.pointer_count > 1 + ): + body += ' bytes_read += {}.PreloadDecode({});\n'.format( + value.name, buffer_args + ) + elif is_class and value.pointer_count == 1: + body += ' bytes_read += ValueDecoder::DecodeHandleIdValue({}, &{});\n'.format( + buffer_args, value.name + ) + elif self.has_basetype(value.base_type): + base_type = self.get_basetype(value.base_type) + body += ' bytes_read += {}.PreloadDecode{}({});\n'.format( + value.name, self.encode_types[base_type], buffer_args + ) + else: + body += ' bytes_read += {}.PreloadDecode{}({});\n'.format( + value.name, type_name, buffer_args + ) + else: + if is_struct: + body += ' bytes_read += DecodeStruct({}, &{});\n'.format( + buffer_args, value.name + ) + elif is_funcp: + body += ' bytes_read += ValueDecoder::DecodeAddress({}, &{});\n'.format( + buffer_args, value.name + ) + elif is_handle: + body += ' bytes_read += ValueDecoder::DecodeHandleIdValue({}, &{});\n'.format( + buffer_args, value.name + ) + elif self.has_basetype(type_name) : + base_type = self.get_basetype(type_name) + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &{});\n'.format( + self.encode_types[base_type], buffer_args, value.name + ) + else: + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &{});\n'.format( + type_name, buffer_args, value.name + ) + + return body + + def generate_decode_cases(self): + prefix = self.get_api_prefix() + """Generate the (Platform)Decoder::DecodeFunctionCall method.""" + + body = f'void {prefix}PreloadDecoder::DecodeFunctionCall(format::ApiCallId call_id,\n' + body += ' const ApiCallInfo& call_info,\n' + body += ' const uint8_t* parameter_buffer,\n' + body += ' size_t buffer_size)\n' + body += '{\n' + body += ' switch(call_id)\n' + body += ' {\n' + body += ' default:\n' + body += f' {prefix}PreloadDecoderBase::DecodeFunctionCall(call_id, call_info, parameter_buffer, buffer_size);\n' + body += ' break;\n' + write(body, file=self.outFile) + + for cmd in self.cmd_names: + cmddef = ' case format::ApiCallId::ApiCall_{}:\n'.format(cmd) + cmddef += ' Decode_{}(call_info, parameter_buffer, buffer_size);\n'.format( + cmd + ) + cmddef += ' break;' + write(cmddef, file=self.outFile) + + write(' }', file=self.outFile) + write('}\n', file=self.outFile) \ No newline at end of file diff --git a/framework/generated/vulkan_generators/vulkan_preload_decoder_header_generator.py b/framework/generated/vulkan_generators/vulkan_preload_decoder_header_generator.py new file mode 100644 index 0000000000..b790796c7d --- /dev/null +++ b/framework/generated/vulkan_generators/vulkan_preload_decoder_header_generator.py @@ -0,0 +1,139 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2018 Valve Corporation +# Copyright (c) 2018 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. + +import sys +from base_generator import BaseGenerator, BaseGeneratorOptions, write + + +class VulkanPreloadDecoderHeaderGeneratorOptions(BaseGeneratorOptions): + """Options for generating a C++ class declaration for Vulkan API parameter decoding.""" + + def __init__( + self, + blacklists=None, # Path to JSON file listing apicalls and structs to ignore. + platform_types=None, # Path to JSON file listing platform (WIN32, X11, etc.) defined types. + filename=None, + directory='.', + prefix_text='', + protect_file=False, + protect_feature=True, + extraVulkanHeaders=[] + ): + BaseGeneratorOptions.__init__( + self, + blacklists, + platform_types, + filename, + directory, + prefix_text, + protect_file, + protect_feature, + extraVulkanHeaders=extraVulkanHeaders + ) + + +class VulkanPreloadDecoderHeaderGenerator(BaseGenerator): + """VulkanPreloadDecoderHeaderGenerator - subclass of BaseGenerator. + Generates C++ member declarations for the VulkanPreloadDecoder class responsible for decoding + Vulkan API call parameter data. + Generate a C++ class declaration for Vulkan API parameter decoding. + """ + + def __init__( + self, err_file=sys.stderr, warn_file=sys.stderr, diag_file=sys.stdout + ): + BaseGenerator.__init__( + self, + process_cmds=True, + process_structs=False, + feature_break=True, + err_file=err_file, + warn_file=warn_file, + diag_file=diag_file + ) + + def beginFile(self, gen_opts): + """Method override.""" + BaseGenerator.beginFile(self, gen_opts) + + write('#include "decode/vulkan_preload_decoder_base.h"', file=self.outFile) + write('#include "util/defines.h"', file=self.outFile) + self.newline() + self.includeVulkanHeaders(gen_opts) + self.newline() + write('GFXRECON_BEGIN_NAMESPACE(gfxrecon)', file=self.outFile) + write('GFXRECON_BEGIN_NAMESPACE(decode)', file=self.outFile) + self.newline() + write( + 'class VulkanPreloadDecoder : public VulkanPreloadDecoderBase', + file=self.outFile + ) + write('{', file=self.outFile) + write(' public:', file=self.outFile) + write(' VulkanPreloadDecoder() { }\n', file=self.outFile) + write(' virtual ~VulkanPreloadDecoder() override { }\n', file=self.outFile) + write( + ' virtual void DecodeFunctionCall(format::ApiCallId call_id,', + file=self.outFile + ) + write( + ' const ApiCallInfo& call_info,', + file=self.outFile + ) + write( + ' const uint8_t* parameter_buffer,', + file=self.outFile + ) + write( + ' size_t buffer_size) override;\n', + file=self.outFile + ) + write(' private:', end='', file=self.outFile) + + def endFile(self): + """Method override.""" + write('};', file=self.outFile) + self.newline() + write('GFXRECON_END_NAMESPACE(decode)', file=self.outFile) + write('GFXRECON_END_NAMESPACE(gfxrecon)', file=self.outFile) + + # Finish processing in superclass + BaseGenerator.endFile(self) + + def need_feature_generation(self): + """Indicates that the current feature has C++ code to generate.""" + if self.feature_cmd_params: + return True + return False + + def generate_feature(self): + """Performs C++ code generation for the feature.""" + first = True + for cmd in self.get_filtered_cmd_names(): + cmddef = '' if first else '\n' + cmddef += ' size_t Decode_{}(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size);'.format( + cmd + ) + write(cmddef, file=self.outFile) + first = False + diff --git a/framework/generated/vulkan_generators/vulkan_preload_replayer_body_generator.py b/framework/generated/vulkan_generators/vulkan_preload_replayer_body_generator.py new file mode 100644 index 0000000000..24e9bcedc5 --- /dev/null +++ b/framework/generated/vulkan_generators/vulkan_preload_replayer_body_generator.py @@ -0,0 +1,297 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2018-2020 Valve Corporation +# Copyright (c) 2018-2020 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. + +import sys +from base_generator import BaseGenerator, BaseGeneratorOptions, ValueInfo, write +from base_decoder_body_generator import BaseDecoderBodyGenerator + + +class VulkanPreloadReplayerBodyGeneratorOptions(BaseGeneratorOptions): + """Options for generating a C++ class for Vulkan API parameter decoding.""" + + def __init__( + self, + blacklists=None, # Path to JSON file listing apicalls and structs to ignore. + platform_types=None, # Path to JSON file listing platform (WIN32, X11, etc.) defined types. + filename=None, + directory='.', + prefix_text='', + protect_file=False, + protect_feature=True, + extraVulkanHeaders=[] + ): + BaseGeneratorOptions.__init__( + self, + blacklists, + platform_types, + filename, + directory, + prefix_text, + protect_file, + protect_feature, + extraVulkanHeaders=extraVulkanHeaders + ) + + +class VulkanPreloadReplayerBodyGenerator(BaseDecoderBodyGenerator, BaseGenerator): + """VulkanPreloadReplayerBodyGenerator - subclass of BaseGenerator. + Generates C++ member functions for the VulkanPreloadDecoder class responsible for decoding + Vulkan API call parameter data. + Generate a C++ class for Vulkan API parameter decoding. + """ + + def __init__( + self, err_file=sys.stderr, warn_file=sys.stderr, diag_file=sys.stdout + ): + BaseGenerator.__init__( + self, + process_cmds=True, + process_structs=False, + feature_break=True, + err_file=err_file, + warn_file=warn_file, + diag_file=diag_file + ) + + # Names of all Vulkan commands processed by the generator. + self.cmd_names = [] + + def beginFile(self, gen_opts): + """Method override.""" + BaseGenerator.beginFile(self, gen_opts) + + write('#include "decode/handle_pointer_decoder.h"', file=self.outFile) + write('#include "decode/pointer_decoder.h"', file=self.outFile) + write('#include "decode/string_array_decoder.h"', file=self.outFile) + write('#include "decode/string_decoder.h"', file=self.outFile) + write('#include "decode/struct_pointer_decoder.h"', file=self.outFile) + write('#include "decode/value_decoder.h"', file=self.outFile) + write('#include "decode/vulkan_pnext_node.h"', file=self.outFile) + write('#include "generated/generated_vulkan_preload_replayer.h"', file=self.outFile) + write( + '#include "generated/generated_vulkan_decoder.h"', + file=self.outFile + ) + write( + '#include "generated/generated_vulkan_struct_decoders_forward.h"', + file=self.outFile + ) + write( + '#include "generated/generated_vulkan_preload_decoder.h"', + file=self.outFile + ) + write( + '#include "generated/generated_vulkan_preload_replayer.h"', + file=self.outFile + ) + write('#include "util/defines.h"', file=self.outFile) + self.newline() + self.includeVulkanHeaders(gen_opts) + self.newline() + write('#include ', file=self.outFile) + self.newline() + write('GFXRECON_BEGIN_NAMESPACE(gfxrecon)', file=self.outFile) + write('GFXRECON_BEGIN_NAMESPACE(decode)', file=self.outFile) + + def endFile(self): + self.newline() + # Generate the VulkanDecoder::ReplayFunctionCall method for all of the commands processed by the generator. + self.generate_decode_cases() + write('GFXRECON_END_NAMESPACE(decode)', file=self.outFile) + write('GFXRECON_END_NAMESPACE(gfxrecon)', file=self.outFile) + + # Finish processing in superclass + BaseGenerator.endFile(self) + + def need_feature_generation(self): + """Indicates that the current feature has C++ code to generate.""" + if self.feature_cmd_params: + return True + return False + + def generate_feature(self): + """Performs C++ code generation for the feature.""" + platform_type = self.get_api_prefix() + + first = True + for cmd in self.get_filtered_cmd_names(): + self.cmd_names.append(cmd) + + info = self.feature_cmd_params[cmd] + return_type = info[0] + values = info[2] + + cmddef = '' if first else '\n' + cmddef += 'void {}PreloadReplayer::Replay_{}(Packet_{}* packet)\n'.format( + platform_type, cmd, cmd + ) + cmddef += '{\n' + cmddef += self.make_cmd_body(return_type, cmd, values) + cmddef += '\n' + cmddef += ' return;\n' + cmddef += '}' + + write(cmddef, file=self.outFile) + first = False + + def make_cmd_body(self, return_type, name, values): + """Generate C++ code for the decoder method body.""" + body = '' + arg_names = [] + + # Declarations for decoded types. + for value in values: + decode_type = self.make_decoded_param_type(value) + + if decode_type == 'Decoded_{}'.format(value.base_type): + body += ' {} value_{};\n'.format( + value.base_type, value.name + ) + body += ' {0}.decoded_value = &value_{0};\n'.format( + value.name + ) + if 'Decoder' in decode_type: + arg_names.append('&(packet->' + value.name + ')') + else: + arg_names.append('packet->' + value.name) + + # Make the argument list for the API call + arglist = ', '.join([arg_name for arg_name in arg_names]) + if return_type and return_type != 'void': + arglist = ', '.join(['packet->return_value', arglist]) + + if arglist[-2:] == ', ': + arglist = arglist[:-2] + arglist = 'packet->call_info, ' + arglist + + body += ' vulkan_replay_consumer_->Process_{}({});\n'.format(name, arglist) + + return body + + def make_decode_invocation(self, value): + """Generate parameter decode function/method invocation.""" + buffer_args = '(parameter_buffer + bytes_read), (buffer_size - bytes_read)' + body = '' + + is_struct = False + is_class = False + is_string = False + is_funcp = False + is_handle = False + + type_name = self.make_invocation_type_name(value.base_type) + + if self.is_struct(type_name): + is_struct = True + elif self.is_class(value): + is_class = True + elif type_name in ['String', 'WString']: + is_string = True + elif type_name == 'FunctionPtr': + is_funcp = True + elif self.is_handle(value.base_type): + is_handle = True + + # is_pointer will be False for static arrays. + if value.is_pointer or value.is_array: + if not is_class and type_name in self.EXTERNAL_OBJECT_TYPES and not value.is_array: + if value.pointer_count > 1: + # Pointer to a pointer to an unknown object type (void**), encoded as a pointer to a 64-bit integer ID. + body += ' bytes_read += {}.DecodeVoidPtr({});\n'.format( + value.name, buffer_args + ) + else: + # Pointer to an unknown object type, encoded as a 64-bit integer ID. + body += ' bytes_read += ValueDecoder::DecodeAddress({}, &{});\n'.format( + buffer_args, value.name + ) + else: + if is_struct or is_string or is_handle or ( + is_class and value.pointer_count > 1 + ): + body += ' bytes_read += {}.Decode({});\n'.format( + value.name, buffer_args + ) + elif is_class and value.pointer_count == 1: + body += ' bytes_read += ValueDecoder::DecodeHandleIdValue({}, &{});\n'.format( + buffer_args, value.name + ) + elif self.has_basetype(value.base_type): + base_type = self.get_basetype(value.base_type) + body += ' bytes_read += {}.Decode{}({});\n'.format( + value.name, self.encode_types[base_type], buffer_args + ) + else: + body += ' bytes_read += {}.Decode{}({});\n'.format( + value.name, type_name, buffer_args + ) + else: + if is_struct: + body += ' bytes_read += DecodeStruct({}, &{});\n'.format( + buffer_args, value.name + ) + elif is_funcp: + body += ' bytes_read += ValueDecoder::DecodeAddress({}, &{});\n'.format( + buffer_args, value.name + ) + elif is_handle: + body += ' bytes_read += ValueDecoder::DecodeHandleIdValue({}, &{});\n'.format( + buffer_args, value.name + ) + elif self.has_basetype(type_name) : + base_type = self.get_basetype(type_name) + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &{});\n'.format( + self.encode_types[base_type], buffer_args, value.name + ) + else: + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &{});\n'.format( + type_name, buffer_args, value.name + ) + + return body + + def generate_decode_cases(self): + prefix = self.get_api_prefix() + """Generate the (Platform)Replayer::ReplayFunctionCall method.""" + + body = f'void {prefix}PreloadReplayer::ReplayFunctionCall(format::PacketCallId& packet_call_id, void* packet)\n' + body += '{\n' + body += ' switch(packet_call_id)\n' + body += ' {\n' + body += ' default:\n' + body += f' {prefix}PreloadReplayerBase::ReplayFunctionCall(packet_call_id, packet);\n' + body += ' break;\n' + write(body, file=self.outFile) + + # print(self.feature_cmd_params) + for cmd in self.cmd_names: + cmddef = ' case format::PacketCallId::PacketCall_{}:\n'.format(cmd) + cmddef += ' Replay_{}(reinterpret_cast(packet));\n'.format( + cmd, cmd + ) + cmddef += ' break;' + write(cmddef, file=self.outFile) + + write(' }', file=self.outFile) + write('}\n', file=self.outFile) + diff --git a/framework/generated/vulkan_generators/vulkan_preload_replayer_header_generator.py b/framework/generated/vulkan_generators/vulkan_preload_replayer_header_generator.py new file mode 100644 index 0000000000..ec57f03fcd --- /dev/null +++ b/framework/generated/vulkan_generators/vulkan_preload_replayer_header_generator.py @@ -0,0 +1,131 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2018 Valve Corporation +# Copyright (c) 2018 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. + +import sys +from base_generator import BaseGenerator, BaseGeneratorOptions, write + + +class VulkanPreloadReplayerHeaderGeneratorOptions(BaseGeneratorOptions): + """Options for generating a C++ class declaration for Vulkan API parameter decoding.""" + + def __init__( + self, + blacklists=None, # Path to JSON file listing apicalls and structs to ignore. + platform_types=None, # Path to JSON file listing platform (WIN32, X11, etc.) defined types. + filename=None, + directory='.', + prefix_text='', + protect_file=False, + protect_feature=True, + extraVulkanHeaders=[] + ): + BaseGeneratorOptions.__init__( + self, + blacklists, + platform_types, + filename, + directory, + prefix_text, + protect_file, + protect_feature, + extraVulkanHeaders=extraVulkanHeaders + ) + + +class VulkanPreloadReplayerHeaderGenerator(BaseGenerator): + """VulkanPreloadReplayerHeaderGenerator - subclass of BaseGenerator. + Generates C++ member declarations for the VulkanPreloadReplayer class responsible for decoding + Vulkan API call parameter data. + Generate a C++ class declaration for Vulkan API parameter decoding. + """ + + def __init__( + self, err_file=sys.stderr, warn_file=sys.stderr, diag_file=sys.stdout + ): + BaseGenerator.__init__( + self, + process_cmds=True, + process_structs=False, + feature_break=True, + err_file=err_file, + warn_file=warn_file, + diag_file=diag_file + ) + + def beginFile(self, gen_opts): + """Method override.""" + BaseGenerator.beginFile(self, gen_opts) + + write('#include "decode/vulkan_decoder_base.h"', file=self.outFile) + write('#include "decode/vulkan_preload_replayer_base.h"', file=self.outFile) + # write( + # '#include "generated/generated_vulkan_struct_packet.h"', + # file=self.outFile + # ) + write('#include "util/defines.h"', file=self.outFile) + self.newline() + self.includeVulkanHeaders(gen_opts) + self.newline() + write('GFXRECON_BEGIN_NAMESPACE(gfxrecon)', file=self.outFile) + write('GFXRECON_BEGIN_NAMESPACE(decode)', file=self.outFile) + self.newline() + write( + 'class VulkanPreloadReplayer : public VulkanPreloadReplayerBase', + file=self.outFile + ) + write('{', file=self.outFile) + write(' public:', file=self.outFile) + write(' VulkanPreloadReplayer() { }\n', file=self.outFile) + write(' virtual ~VulkanPreloadReplayer() { }\n', file=self.outFile) + write( + ' virtual void ReplayFunctionCall(format::PacketCallId& packet_call_id, void* packet);\n', + file=self.outFile + ) + write(' private:', end='', file=self.outFile) + + def endFile(self): + """Method override.""" + write('};', file=self.outFile) + self.newline() + write('GFXRECON_END_NAMESPACE(decode)', file=self.outFile) + write('GFXRECON_END_NAMESPACE(gfxrecon)', file=self.outFile) + + # Finish processing in superclass + BaseGenerator.endFile(self) + + def need_feature_generation(self): + """Indicates that the current feature has C++ code to generate.""" + if self.feature_cmd_params: + return True + return False + + def generate_feature(self): + """Performs C++ code generation for the feature.""" + first = True + for cmd in self.get_filtered_cmd_names(): + cmddef = '' if first else '\n' + cmddef += ' void Replay_{}(Packet_{}* packet);'.format( + cmd,cmd + ) + write(cmddef, file=self.outFile) + first = False diff --git a/framework/generated/vulkan_generators/vulkan_preload_struct_decoders_body_generator.py b/framework/generated/vulkan_generators/vulkan_preload_struct_decoders_body_generator.py new file mode 100644 index 0000000000..33e7cd81bc --- /dev/null +++ b/framework/generated/vulkan_generators/vulkan_preload_struct_decoders_body_generator.py @@ -0,0 +1,322 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2018-2020 Valve Corporation +# Copyright (c) 2018-2020 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notiPacketFVulkanStructDecce shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. + +import sys +from base_generator import BaseGenerator, BaseGeneratorOptions, write +from base_struct_decoders_body_generator import BaseStructDecodersBodyGenerator + + +class VulkanPreloadStructDecodersBodyGeneratorOptions(BaseGeneratorOptions): + """Options for generating C++ functions for Vulkan struct decoding.""" + + def __init__( + self, + blacklists=None, # Path to JSON file listing apicalls and structs to ignore. + platform_types=None, # Path to JSON file listing platform (WIN32, X11, etc.) defined types. + filename=None, + directory='.', + prefix_text='', + protect_file=False, + protect_feature=True, + extraVulkanHeaders=[] + ): + BaseGeneratorOptions.__init__( + self, + blacklists, + platform_types, + filename, + directory, + prefix_text, + protect_file, + protect_feature, + extraVulkanHeaders=extraVulkanHeaders + ) + + +class VulkanPreloadStructDecodersBodyGenerator( + BaseStructDecodersBodyGenerator, BaseGenerator +): + """VulkanPreloadStructDecodersBodyGenerator - subclass of BaseGenerator. + Generates C++ functions for decoding Vulkan API structures. + Generate C++ functions for Vulkan struct decoding.""" + + def __init__( + self, err_file=sys.stderr, warn_file=sys.stderr, diag_file=sys.stdout + ): + BaseGenerator.__init__( + self, + process_cmds=False, + process_structs=True, + feature_break=True, + err_file=err_file, + warn_file=warn_file, + diag_file=diag_file + ) + + def beginFile(self, gen_opts): + """Method override.""" + BaseGenerator.beginFile(self, gen_opts) + + write( + '#include "generated/generated_vulkan_preload_struct_decoders.h"', + file=self.outFile + ) + self.newline() + write( + '#include "decode/custom_vulkan_struct_decoders.h"', + file=self.outFile + ) + write('#include "decode/decode_allocator.h"', file=self.outFile) + self.newline() + write('#include ', file=self.outFile) + self.newline() + write('GFXRECON_BEGIN_NAMESPACE(gfxrecon)', file=self.outFile) + write('GFXRECON_BEGIN_NAMESPACE(decode)', file=self.outFile) + self.newline() + write( + 'size_t PreloadDecodePNextStruct(const uint8_t* buffer, size_t buffer_size, PNextNode** pNext);', + file=self.outFile + ) + + def endFile(self): + """Method override.""" + self.newline() + write('GFXRECON_END_NAMESPACE(decode)', file=self.outFile) + write('GFXRECON_END_NAMESPACE(gfxrecon)', file=self.outFile) + + # Finish processing in superclass + BaseGenerator.endFile(self) + + def need_feature_generation(self): + """Indicates that the current feature has C++ code to generate.""" + if self.feature_struct_members: + return True + return False + + def generate_feature(self): + """Performs C++ code generation for the feature.""" + first = True + for struct in self.get_filtered_struct_names(): + body = '' if first else '\n' + body += 'size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_{}* wrapper)\n'.format( + struct + ) + body += '{\n' + body += ' assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr));\n' + body += '\n' + body += ' size_t bytes_read = 0;\n' + body += ' {}* value = wrapper->decoded_value;\n'.format(struct) + body += '\n' + body += self.make_decode_struct_body( + struct, self.feature_struct_members[struct] + ) + body += '\n' + body += ' return bytes_read;\n' + body += '}' + + write(body, file=self.outFile) + first = False + + def make_decode_struct_body(self, name, values): + """Generate C++ code for the decoder method body.""" + body = '' + + for value in values: + # pNext fields require special treatment and are not processed by type name + if 'pNext' in value.name and value.base_type == 'void': + body += ' bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->{}));\n'.format( + value.name + ) + body += ' value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr;\n' + else: + body += self.make_decode_invocation( + name, value + ) + + return body + + def make_decode_invocation(self, name, value): + """Generate the struct member decoder function call invocation.""" + buffer_args = '(buffer + bytes_read), (buffer_size - bytes_read)' + + body = '' + + is_struct = False + is_class = False + is_string = False + is_funcp = False + is_handle = False + is_enum = False + + type_name = self.make_invocation_type_name(value.base_type) + + if self.is_struct(type_name): + is_struct = True + elif self.is_class(value): + is_class = True + elif type_name in ['String', 'WString']: + is_string = True + elif type_name == 'FunctionPtr': + is_funcp = True + elif self.is_handle(value.base_type): + is_handle = True + elif type_name == 'Enum': + is_enum = True + + # is_pointer will be False for static arrays. + if value.is_pointer or value.is_array: + if type_name in self.EXTERNAL_OBJECT_TYPES and not value.is_array: + # Pointer to an unknown object type, encoded as a 64-bit integer ID. + body += ' bytes_read += ValueDecoder::DecodeAddress({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + body += ' value->{} = nullptr;\n'.format(value.name) + else: + is_static_array = True if ( + value.is_array and not value.is_dynamic + ) else False + access_op = '.' + + if is_struct: + body += ' wrapper->{} = DecodeAllocator::Allocate<{}>();\n'.format( + value.name, self.make_decoded_param_type(value) + ) + access_op = '->' + + if is_static_array: + array_dimension = '' + # dx12 treats 2d array as 1d array. EX: [8][2] -> [16], so dx12's 2d array needs *. + # But vk keeps 2d array. + if self.is_dx12_class() and value.array_dimension and value.array_dimension > 0: + array_dimension = '*' + # The pointer decoder will write directly to the struct member's memory. + body += ' wrapper->{name}{}SetExternalMemory({}value->{name}, {arraylen});\n'.format( + access_op, + array_dimension, + name=value.name, + arraylen=value.array_capacity + ) + + if is_struct or is_string or is_handle or ( + is_class and value.pointer_count > 1 + ): + body += ' bytes_read += wrapper->{}{}PreloadDecode({});\n'.format( + value.name, access_op, buffer_args + ) + elif is_class and value.pointer_count == 1: + body += ' bytes_read += ValueDecoder::DecodeHandleIdValue({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + elif self.has_basetype(value.base_type): + base_type = self.get_basetype(value.base_type) + body += ' bytes_read += wrapper->{}.PreloadDecode{}({});\n'.format( + value.name, self.encode_types[base_type], buffer_args + ) + else: + body += ' bytes_read += wrapper->{}.PreloadDecode{}({});\n'.format( + value.name, type_name, buffer_args + ) + + if not is_static_array: + if is_handle or is_class: + # Point the real struct's member pointer to the handle pointer decoder's handle memory. + body += ' value->{} = nullptr;\n'.format(value.name) + else: + # Point the real struct's member pointer to the pointer decoder's memory. + convert_const_cast_begin = '' + convert_const_cast_end = '' + + if value.full_type.find('LPCWSTR *') != -1: + convert_const_cast_end = ')' + convert_const_cast_begin = 'const_cast(' + + elif value.full_type.find('LPCSTR *') != -1: + convert_const_cast_end = ')' + convert_const_cast_begin = 'const_cast(' + + body += ' value->{name} = {}wrapper->{name}{}GetPointer(){};\n'.format( + convert_const_cast_begin, + access_op, + convert_const_cast_end, + name=value.name + ) + else: + if is_struct: + body += ' wrapper->{} = DecodeAllocator::Allocate<{}>();\n'.format( + value.name, self.make_decoded_param_type(value) + ) + body += ' wrapper->{name}->decoded_value = &(value->{name});\n'.format( + name=value.name + ) + body += ' bytes_read += PreloadDecodeStruct({}, wrapper->{});\n'.format( + buffer_args, value.name + ) + elif is_funcp: + body += ' bytes_read += ValueDecoder::DecodeAddress({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + body += ' value->{} = nullptr;\n'.format(value.name) + elif is_handle: + body += ' bytes_read += ValueDecoder::DecodeHandleIdValue({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + body += ' value->{} = VK_NULL_HANDLE;\n'.format(value.name) + elif self.is_generic_struct_handle_value(name, value.name): + body += ' bytes_read += ValueDecoder::DecodeUInt64Value({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + body += ' value->{} = 0;\n'.format(value.name) + elif value.bitfield_width: + # Bit fields need to be read into a tempoaray and then assigned to the struct member. + temp_param_name = 'temp_{}'.format(value.name) + body += ' {} {};\n'.format(value.base_type, temp_param_name) + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &{});\n'.format( + type_name, buffer_args, temp_param_name + ) + body += ' value->{} = {};\n'.format( + value.name, temp_param_name + ) + elif is_enum: + body += ' bytes_read += ValueDecoder::DecodeEnumValue({}, &(value->{}));\n'.format( + buffer_args, value.name + ) + elif self.has_basetype(type_name): + base_type = self.get_basetype(type_name) + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &(value->{}));\n'.format( + self.encode_types[base_type], buffer_args, value.name + ) + elif 'Flags' in type_name: + if 'Flags64' in type_name: + body += ' bytes_read += ValueDecoder::DecodeFlags64Value({}, &(value->{}));\n'.format( + buffer_args, value.name + ) + else: + body += ' bytes_read += ValueDecoder::DecodeFlagsValue({}, &(value->{}));\n'.format( + buffer_args, value.name + ) + else: + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &(value->{}));\n'.format( + type_name, buffer_args, value.name + ) + + return body diff --git a/framework/generated/vulkan_generators/vulkan_preload_struct_decoders_forward_generator.py b/framework/generated/vulkan_generators/vulkan_preload_struct_decoders_forward_generator.py new file mode 100644 index 0000000000..2f3f25a365 --- /dev/null +++ b/framework/generated/vulkan_generators/vulkan_preload_struct_decoders_forward_generator.py @@ -0,0 +1,114 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2018 Valve Corporation +# Copyright (c) 2018 LunarG, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to +# deal in the Software without restriction, including without limitation the +# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +# sell copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +# IN THE SOFTWARE. + +import sys +from base_generator import BaseGenerator, BaseGeneratorOptions, write + + +class VulkanPreloadStructDecodersForwardGeneratorOptions(BaseGeneratorOptions): + """Options for generating C++ function and forward type declarations for Vulkan struct decoding.""" + + def __init__( + self, + blacklists=None, # Path to JSON file listing apicalls and structs to ignore. + platform_types=None, # Path to JSON file listing platform (WIN32, X11, etc.) defined types. + filename=None, + directory='.', + prefix_text='', + protect_file=False, + protect_feature=True, + extraVulkanHeaders=[] + ): + BaseGeneratorOptions.__init__( + self, + blacklists, + platform_types, + filename, + directory, + prefix_text, + protect_file, + protect_feature, + extraVulkanHeaders=extraVulkanHeaders + ) + + +class VulkanPreloadStructDecodersForwardGenerator(BaseGenerator): + """VulkanPreloadStructDecodersForwardGenerator - subclass of BaseGenerator. + Generates C++ type and function declarations for decoding Vulkan API structures. + Generate C++ function and forward type declarations for Vulkan struct decoding. + """ + + def __init__( + self, err_file=sys.stderr, warn_file=sys.stderr, diag_file=sys.stdout + ): + BaseGenerator.__init__( + self, + process_cmds=False, + process_structs=True, + feature_break=True, + err_file=err_file, + warn_file=warn_file, + diag_file=diag_file + ) + + def beginFile(self, gen_opts): + """Method override.""" + BaseGenerator.beginFile(self, gen_opts) + + write('#include "util/defines.h"', file=self.outFile) + self.newline() + self.includeVulkanHeaders(gen_opts) + self.newline() + write('#include ', file=self.outFile) + self.newline() + write('GFXRECON_BEGIN_NAMESPACE(gfxrecon)', file=self.outFile) + write('GFXRECON_BEGIN_NAMESPACE(decode)', file=self.outFile) + + def endFile(self): + """Method override.""" + self.newline() + write('GFXRECON_END_NAMESPACE(decode)', file=self.outFile) + write('GFXRECON_END_NAMESPACE(gfxrecon)', file=self.outFile) + + # Finish processing in superclass + BaseGenerator.endFile(self) + + def need_feature_generation(self): + """Indicates that the current feature has C++ code to generate.""" + if self.feature_struct_members: + return True + return False + + def generate_feature(self): + """Performs C++ code generation for the feature.""" + for struct in self.get_filtered_struct_names(): + write('struct Decoded_{};'.format(struct), file=self.outFile) + + self.newline() + + for struct in self.get_filtered_struct_names(): + write( + 'size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_{}* wrapper);' + .format(struct), + file=self.outFile + ) diff --git a/framework/generated/vulkan_generators/vulkan_struct_decoders_body_generator.py b/framework/generated/vulkan_generators/vulkan_struct_decoders_body_generator.py index a6bd7df053..bf7e8491bb 100644 --- a/framework/generated/vulkan_generators/vulkan_struct_decoders_body_generator.py +++ b/framework/generated/vulkan_generators/vulkan_struct_decoders_body_generator.py @@ -97,6 +97,11 @@ def beginFile(self, gen_opts): 'size_t DecodePNextStruct(const uint8_t* buffer, size_t buffer_size, PNextNode** pNext);', file=self.outFile ) + self.newline() + write( + 'size_t PreloadDecodePNextStruct(const uint8_t* buffer, size_t buffer_size, PNextNode** pNext);', + file=self.outFile + ) def endFile(self): """Method override.""" @@ -112,3 +117,212 @@ def need_feature_generation(self): if self.feature_struct_members: return True return False + + def generate_feature(self): + """Performs C++ code generation for the feature.""" + BaseStructDecodersBodyGenerator.generate_feature(self) + first = True + for struct in self.get_filtered_struct_names(): + body = '' if first else '\n' + body += 'size_t PreloadDecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_{}* wrapper)\n'.format( + struct + ) + body += '{\n' + body += ' assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr));\n' + body += '\n' + body += ' size_t bytes_read = 0;\n' + body += ' {}* value = wrapper->decoded_value;\n'.format(struct) + body += '\n' + body += self.make_preload_decode_struct_body( + struct, self.feature_struct_members[struct] + ) + body += '\n' + body += ' return bytes_read;\n' + body += '}' + + write(body, file=self.outFile) + first = False + + def make_preload_decode_struct_body(self, name, values): + """Generate C++ code for the decoder method body.""" + body = '' + + for value in values: + # pNext fields require special treatment and are not processed by type name + if 'pNext' in value.name and value.base_type == 'void': + body += ' bytes_read += PreloadDecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->{}));\n'.format( + value.name + ) + body += ' value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr;\n' + else: + body += self.make_decode_invocation( + name, value + ) + + return body + + def make_decode_invocation(self, name, value): + """Generate the struct member decoder function call invocation.""" + buffer_args = '(buffer + bytes_read), (buffer_size - bytes_read)' + + body = '' + + is_struct = False + is_class = False + is_string = False + is_funcp = False + is_handle = False + is_enum = False + + type_name = self.make_invocation_type_name(value.base_type) + + if self.is_struct(type_name): + is_struct = True + elif self.is_class(value): + is_class = True + elif type_name in ['String', 'WString']: + is_string = True + elif type_name == 'FunctionPtr': + is_funcp = True + elif self.is_handle(value.base_type): + is_handle = True + elif type_name == 'Enum': + is_enum = True + + # is_pointer will be False for static arrays. + if value.is_pointer or value.is_array: + if type_name in self.EXTERNAL_OBJECT_TYPES and not value.is_array: + # Pointer to an unknown object type, encoded as a 64-bit integer ID. + body += ' bytes_read += ValueDecoder::DecodeAddress({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + body += ' value->{} = nullptr;\n'.format(value.name) + else: + is_static_array = True if ( + value.is_array and not value.is_dynamic + ) else False + access_op = '.' + + if is_struct: + body += ' wrapper->{} = PreloadDecodeAllocator::Allocate<{}>();\n'.format( + value.name, self.make_decoded_param_type(value) + ) + access_op = '->' + + if is_static_array: + array_dimension = '' + # dx12 treats 2d array as 1d array. EX: [8][2] -> [16], so dx12's 2d array needs *. + # But vk keeps 2d array. + if self.is_dx12_class() and value.array_dimension and value.array_dimension > 0: + array_dimension = '*' + # The pointer decoder will write directly to the struct member's memory. + body += ' wrapper->{name}{}SetExternalMemory({}value->{name}, {arraylen});\n'.format( + access_op, + array_dimension, + name=value.name, + arraylen=value.array_capacity + ) + + if is_struct or is_string or is_handle or ( + is_class and value.pointer_count > 1 + ): + body += ' bytes_read += wrapper->{}{}PreloadDecode({});\n'.format( + value.name, access_op, buffer_args + ) + elif is_class and value.pointer_count == 1: + body += ' bytes_read += ValueDecoder::DecodeHandleIdValue({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + elif self.has_basetype(value.base_type): + base_type = self.get_basetype(value.base_type) + body += ' bytes_read += wrapper->{}.PreloadDecode{}({});\n'.format( + value.name, self.encode_types[base_type], buffer_args + ) + else: + body += ' bytes_read += wrapper->{}.PreloadDecode{}({});\n'.format( + value.name, type_name, buffer_args + ) + + if not is_static_array: + if is_handle or is_class: + # Point the real struct's member pointer to the handle pointer decoder's handle memory. + body += ' value->{} = nullptr;\n'.format(value.name) + else: + # Point the real struct's member pointer to the pointer decoder's memory. + convert_const_cast_begin = '' + convert_const_cast_end = '' + + if value.full_type.find('LPCWSTR *') != -1: + convert_const_cast_end = ')' + convert_const_cast_begin = 'const_cast(' + + elif value.full_type.find('LPCSTR *') != -1: + convert_const_cast_end = ')' + convert_const_cast_begin = 'const_cast(' + + body += ' value->{name} = {}wrapper->{name}{}GetPointer(){};\n'.format( + convert_const_cast_begin, + access_op, + convert_const_cast_end, + name=value.name + ) + else: + if is_struct: + body += ' wrapper->{} = PreloadDecodeAllocator::Allocate<{}>();\n'.format( + value.name, self.make_decoded_param_type(value) + ) + body += ' wrapper->{name}->decoded_value = &(value->{name});\n'.format( + name=value.name + ) + body += ' bytes_read += PreloadDecodeStruct({}, wrapper->{});\n'.format( + buffer_args, value.name + ) + elif is_funcp: + body += ' bytes_read += ValueDecoder::DecodeAddress({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + body += ' value->{} = nullptr;\n'.format(value.name) + elif is_handle: + body += ' bytes_read += ValueDecoder::DecodeHandleIdValue({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + body += ' value->{} = VK_NULL_HANDLE;\n'.format(value.name) + elif self.is_generic_struct_handle_value(name, value.name): + body += ' bytes_read += ValueDecoder::DecodeUInt64Value({}, &(wrapper->{}));\n'.format( + buffer_args, value.name + ) + body += ' value->{} = 0;\n'.format(value.name) + elif value.bitfield_width: + # Bit fields need to be read into a tempoaray and then assigned to the struct member. + temp_param_name = 'temp_{}'.format(value.name) + body += ' {} {};\n'.format(value.base_type, temp_param_name) + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &{});\n'.format( + type_name, buffer_args, temp_param_name + ) + body += ' value->{} = {};\n'.format( + value.name, temp_param_name + ) + elif is_enum: + body += ' bytes_read += ValueDecoder::DecodeEnumValue({}, &(value->{}));\n'.format( + buffer_args, value.name + ) + elif self.has_basetype(type_name): + base_type = self.get_basetype(type_name) + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &(value->{}));\n'.format( + self.encode_types[base_type], buffer_args, value.name + ) + elif 'Flags' in type_name: + if 'Flags64' in type_name: + body += ' bytes_read += ValueDecoder::DecodeFlags64Value({}, &(value->{}));\n'.format( + buffer_args, value.name + ) + else: + body += ' bytes_read += ValueDecoder::DecodeFlagsValue({}, &(value->{}));\n'.format( + buffer_args, value.name + ) + else: + body += ' bytes_read += ValueDecoder::Decode{}Value({}, &(value->{}));\n'.format( + type_name, buffer_args, value.name + ) + + return body diff --git a/framework/generated/vulkan_generators/vulkan_struct_decoders_forward_generator.py b/framework/generated/vulkan_generators/vulkan_struct_decoders_forward_generator.py index 21d7933cf6..886875fcc6 100644 --- a/framework/generated/vulkan_generators/vulkan_struct_decoders_forward_generator.py +++ b/framework/generated/vulkan_generators/vulkan_struct_decoders_forward_generator.py @@ -112,3 +112,10 @@ def generate_feature(self): .format(struct), file=self.outFile ) + + for struct in self.get_filtered_struct_names(): + write( + 'size_t PreloadDecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_{}* wrapper);' + .format(struct), + file=self.outFile + ) \ No newline at end of file diff --git a/framework/generated/vulkan_generators/vulkan_struct_packet_header_generator.py b/framework/generated/vulkan_generators/vulkan_struct_packet_header_generator.py new file mode 100644 index 0000000000..49c1ee8983 --- /dev/null +++ b/framework/generated/vulkan_generators/vulkan_struct_packet_header_generator.py @@ -0,0 +1,713 @@ +#!/usr/bin/python3 -i +# +# Copyright (c) 2020 Samsung +# Copyright (c) 2023 Google +# Copyright (c) 2023 LunarG +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import sys +from base_generator import BaseGenerator, BaseGeneratorOptions, write + +# Copyright text prefixing all headers (list of strings). +CPP_PREFIX_STRING = [ + '/*', + '** Copyright (c) 2020 Samsung', + '** Copyright (c) 2023 Google', + '** Copyright (c) 2023 LunarG, Inc.', + '**', + '** Permission is hereby granted, free of charge, to any person obtaining a', + '** copy of this software and associated documentation files (the "Software"),', + '** to deal in the Software without restriction, including without limitation', + '** the rights to use, copy, modify, merge, publish, distribute, sublicense,', + '** and/or sell copies of the Software, and to permit persons to whom the', + '** Software is furnished to do so, subject to the following conditions:', + '**', + '** The above copyright notice and this permission notice shall be included in', + '** all copies or substantial portions of the Software.', '**', + '** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR', + '** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,', + '** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE', + '** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER', + '** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING', + '** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER', + '** DEALINGS IN THE SOFTWARE.', + '*/', + '', + '/*', + '** This file is generated from the Khronos Vulkan XML API Registry.', + '**', + '*/', + '' +] + +# TODO: Copied from base_generator.py. +def makeREstring(argList, defaultValue = None): + if (len(argList) > 0) or (defaultValue is None): + return '^(' + '|'.join(argList) + ')$' + else: + return defaultValue + +def getExtApiStructs(featureDictionary): + extApiStructs = [] + for extension in CPP_REQUIRED_EXTENSIONS: + extDict = featureDictionary[extension] + extStructs = list(extDict['struct'].values()) + extApiStructs.extend([item for subList in extStructs for item in subList if item is not None]) + extApiStructs = [item.split(',') for item in extApiStructs] + return [item for subList in extApiStructs for item in subList] + +CPP_REQUIRED_EXTENSIONS = [ + 'VK_EXT_inline_uniform_block', + 'VK_EXT_memory_budget', + 'VK_EXT_separate_stencil_usage', + 'VK_KHR_android_surface', + 'VK_KHR_create_renderpass2', + 'VK_KHR_descriptor_update_template', + 'VK_KHR_draw_indirect_count', + 'VK_KHR_get_memory_requirements2', + 'VK_KHR_get_physical_device_properties2', + 'VK_KHR_image_format_list', + 'VK_KHR_maintenance1', + 'VK_KHR_maintenance2', + 'VK_KHR_multiview', + 'VK_KHR_surface', + 'VK_KHR_swapchain', + 'VK_KHR_swapchain_mutable_format', + 'VK_KHR_wayland_surface', + 'VK_KHR_xcb_surface', +] + +# Extensions can be enabled by specifying them in this list +CPP_OPTIONAL_EXTENSIONS = [] + +CPP_CONSUMER_ADD_EXTENSION_PAT = makeREstring(CPP_REQUIRED_EXTENSIONS + CPP_OPTIONAL_EXTENSIONS) +CPP_CONSUMER_ADD_OPTIONAL_EXTENSION_PAT = makeREstring(CPP_OPTIONAL_EXTENSIONS) + +CPP_CONSUMER_REMOVE_EXTENSION_PAT = None # makeREstring(['.*']) +CPP_CONSUMER_VULKAN_VERSION = ['VK_VERSION_1_0'] + +CPP_CONSUMER_VULKAN_VERSION_PAT = makeREstring(CPP_CONSUMER_VULKAN_VERSION) + +# These functions have the majority of functionality that is manually generated +CPP_APICALL_GENERATE = [ + # Core functionality - Alphabetical + 'vkAllocateMemory', + 'vkCreateBuffer', + 'vkCreateComputePipelines', + 'vkCreateDescriptorUpdateTemplate', + 'vkCreateDevice', + 'vkCreateGraphicsPipelines', + 'vkCreateInstance', + 'vkCreatePipelineCache', + 'vkCreateShaderModule', + 'vkDestroyDevice', + 'vkEnumeratePhysicalDevices', + 'vkGetBufferMemoryRequirements', + 'vkGetBufferMemoryRequirements2', + 'vkGetDeviceQueue', + 'vkGetFenceStatus', + 'vkGetImageMemoryRequirements', + 'vkGetImageMemoryRequirements2', + 'vkGetImageSparseMemoryRequirements', + 'vkGetPhysicalDeviceQueueFamilyProperties', + 'vkGetPhysicalDeviceSurfaceFormatsKHR', + 'vkGetPhysicalDeviceSurfacePresentModesKHR', + 'vkGetQueryPoolResults', + 'vkMapMemory', + 'vkQueueBindSparse', + 'vkQueueSubmit', + 'vkQueueSubmit2', + 'vkUnmapMemory', + 'vkWaitForFences', + + # KHR functionality - Alphabetical + 'vkAcquireNextImageKHR', + 'vkAcquireNextImage2KHR', + 'vkCreateAndroidSurfaceKHR', + 'vkCreateDescriptorUpdateTemplateKHR', + 'vkCreateSwapchainKHR', + 'vkDestroySwapchainKHR', + 'vkCreateWaylandSurfaceKHR', + 'vkCreateWin32SurfaceKHR', + 'vkCreateXcbSurfaceKHR', + 'vkCreateXlibSurfaceKHR', + 'vkGetBufferMemoryRequirements2KHR', + 'vkGetImageMemoryRequirements2KHR', + 'vkGetSemaphoreFdKHR', + 'vkGetSemaphoreWin32HandleKHR', + 'vkGetSwapchainImagesKHR', + 'vkImportSemaphoreFdKHR', + 'vkImportSemaphoreWin32HandleKHR', + 'vkQueuePresentKHR', + 'vkQueueSubmit2KHR', + + # EXT functionality - Alphabetical + 'vkCreateMetalSurfaceEXT', + 'vkDebugMarkerSetObjectNameEXT', + 'vkDebugMarkerSetObjectTagEXT', + 'vkSetDebugUtilsObjectNameEXT', + 'vkSetDebugUtilsObjectTagEXT', + + # Other extension functionality - Alphabetical + 'vkGetAndroidHardwareBufferPropertiesANDROID', + 'vkGetMemoryAndroidHardwareBufferANDROID', +] + +CPP_APICALL_INTERCEPT_LIST = [ + 'vkBindBufferMemory', + 'vkBindBufferMemory2', + 'vkBindImageMemory', + 'vkBindImageMemory2', + 'vkCmdBeginRenderPass', + 'vkCreateFramebuffer', + 'vkDestroySemaphore', + + 'vkBindImageMemory2KHR', + 'vkBindBufferMemory2KHR', +] + +# Disabled wrapping function call into the 'VK_CALL_CHECK' macro call +CPP_APICALL_DO_NOT_CHECK = ['vkGetPhysicalDeviceImageFormatProperties'] + +def makeSnakeCaseName(camelCaseString): + new_string = ''.join(['_' + char.lower() if char.isupper() else char for char in camelCaseString]).lstrip('_') + if new_string.startswith('p_'): + new_string = new_string.replace('p_', 'p', 1) + return new_string.replace('_p_', '_p') + +def makeGenCall(method, args, arguments=None, indent=4, **kwargs): + """ + Output a method call into the CPP generator. + + :param method: the name of the method to invoke in the CPP generator. + :param args: list of arguments used for the method call. + :param arguments: dictionary containing the key-values used for the string formatting. + :param indent: indentation size. + + :returns: string representation of the method call which can be inserted into the CPP generator. + """ + return makeGenVarCall(None, None, method, args, arguments=arguments, indent=indent, **kwargs) + + +def makeGenVarCall(typeToUse, genName, method, methodArgs, arguments=None, indent=4, **kwargs): + """ + Output a variable initialization with a method call into the CPP generator. + + :param typeToUse type (same type as the return value of the given method). Can be None so no type name is added. + :param genName: the name of the std::string variable used in the CPP generator. Can be None so no assignment is generated. + :param method: a non void method name. + :param methodArgs: list of target method arguments. + :param arguments: dictionary containing the key-values used for the string formatting. + :param indent: indentation size. + + :returns: method call assigning the value to the 'genName' + """ + if not arguments: + arguments = {} + + assignment = '' + if genName: + if typeToUse: + assignment = '{} {} = '.format(typeToUse, genName).format(**arguments, **kwargs) + else: + assignment = '{} = '.format(genName).format(**arguments, **kwargs) + + arg_indent = ',\n' + ' ' * (indent + len(method) + 1 + len(assignment)) + padded_args = arg_indent.join(methodArgs) + + return (' ' * indent) + ('%s%s(%s);\n' % (assignment, method, padded_args)).format(**arguments, **kwargs) + + +def makeGenVar(genName, cppName, handleObjectType=None, arguments=None, indent=4, addType=True, useThis=True): + """ + Output a usable variable name into the CPP generator. + + :param genName: the name of the std::string variable used in the CPP generator. + :param cppName: the name of the variable which will be used in the resulting CPP file. If None is passed a "NULL" value will be inserted. + :param arguments: dictionary containing the key-values used for the string formatting. + :param indent: indentation size. + :param addType: if True the 'std::string' type will be added into the output string, otherwise it is a simple assignment. + :param useThis: use 'this' pointer if True, otherwise access attributes with the object of class. + + :returns: string representation of the std::string variable which can be inserted into the CPP generator. + """ + typeToUse = '' + object = 'consumer.' + + if not arguments: + arguments = {} + if addType: + typeToUse = 'std::string ' # note the space! + if cppName is None: + return '{}{}{} = "NULL";\n'.format(' ' * indent, typeToUse, genName).format(**arguments) + if useThis: + object = 'this->' + + if handleObjectType is None or '_VIEW' in handleObjectType: + return '{}{}{} = "{}_" + std::to_string({}GetNextId());\n'.format(' ' * indent, typeToUse, genName, cppName, object).format(**arguments) + else: + return '{}{}{} = "{}_" + std::to_string({}GetNextId({}));\n'.format(' ' * indent, typeToUse, genName, cppName, object, handleObjectType).format(**arguments) + + +def makeGenCastVar(cast_type, type_name, target_var_name, source_var_name, use_auto=False, indent=4): + """ + Create a variable cast in the CPP generator. + + :param cast_type: type of the cast to perform + :param type_name: name of the type to cast to + :param target_var_name: name of the variable to cast to + :param source_var_name: name of the variable to cast from + :param use_auto: bool whether to use the auto keyword instead + :param indent: indentation size + :return: + """ + if use_auto: + return ' ' * indent + 'auto %s = %s<%s>(%s);\n' % (target_var_name, cast_type, type_name, source_var_name) + return ' ' * indent + '%s %s = %s<%s>(%s);\n' % ( + type_name, target_var_name, cast_type, type_name, source_var_name) + + +def makeGen(statement, arguments=None, indent=4, **kwargs): + """ + Output a single line into the CPP generator. + + :param genName: statement to format and write out. + :param arguments: dictionary containing the key-values used for the string formatting. + :param indent: indentation size. + + :returns: string representation of the statment which can be inserted into the CPP generator. + """ + if not arguments: + arguments = {} + return (' ' * indent) + statement.format(**arguments, **kwargs) + '\n' + + +def makeCppOutputStream(streamName, indent=4): + """ + Create a function call to write out contents of a stream into the resulting CPP file. + + :param streamName: the name of the std::stringstream to write its contents into the final CPP. + :param indent: indentation size. + + :returns: + """ + return (' ' * indent) + 'fprintf(file, "%s", {streamName}.str().c_str());\n'.format(streamName=streamName) + + +def makeCppArray(type, name, values, arguments=None, indent=4): + """ + Create an Array definition in the resulting CPP file. + + :param type: type of the array. + :param name: name of the array. + :param values: the array contents for the initializer. + :param arguments: dictionary containing the key-values used for the string formatting. + :param indent: indentation size. + + :returns: + """ + if not arguments: + arguments = {} + return (' ' * indent) + ( + 'fprintf(file, "\\t\\t{} %s[] = {{{{ %s }}}};\\n", {}.c_str(), {}.c_str());\n'.format(type, name, values).format(**arguments)) + + +def makeGenLoop(loopIdx, max_count, contents, arguments=None, indent=4): + """ + Create a loop statement in the CPP generator. + + :param loopIdx: loop control variable. + :param max_count: Maximum count of the loop + :param contents: list of code lines inside loop body. + :param arguments: dictionary containing the key-values used for the string formatting. + :param indent: indentation size. + + :return: + """ + if not arguments: + arguments = {} + + lines = [(' ' * indent) + ('for (uint32_t %s = 0; %s < %s; %s++) {{\n' % (loopIdx, loopIdx, max_count, loopIdx)).format(**arguments)] \ + + contents + [(' ' * indent) + '}\n'] + + return ''.join(lines) + + +# TODO: replace this with makeGenConditions? +def makeGenCond(condition, contents_if, contents_else=None, arguments=None, indent=4): + """ + Create an if/else statement in the CPP generator. + + + :param condition: condition of if/else statement. + :param contents_if: list of code lines inside if body. + :param contents_else: list of code lines inside else body. + :param arguments: dictionary containing the key-values used for the string formatting. + :param indent: indentation size. + + :return: + """ + else_cont = [(' ' * indent) + '} else {\n'] + contents_else + [(' ' * indent) + '}\n'] if contents_else else [(' ' * indent) + '}\n'] + lines = [(' ' * indent) + ('if (%s) {\n' % (condition).format(**arguments))] + contents_if + else_cont + + return ''.join(lines) + + +def makeGenConditions(cases, arguments=None, indent=4): + """ + + :param cases: list of tuples. Each tuple has the (condition, body) format. + + :param arguments: dictionary containing the key-values used for the string formatting. + :param indent: indentation size. + :return: formatted cpp code + """ + + indent_str = ' ' * indent + + lines = [] + for idx, case in enumerate(cases): + # case[0] -> condition + # case[1] -> body (list) + if case[0]: + if idx == 0: + start = indent_str + 'if' + else: + start = ' else if' + + condition = '%s (%s)' % (start, case[0].format(**arguments)) + else: + condition = ' else' + + lines.append(condition) + lines.append(' {\n') + lines.extend(case[1]) + lines.append(indent_str + '}') + + assert len(lines) >= 4, "a single entry should be in the condition" + lines[-1] += '\n' + + return ''.join(lines) + + +def makeGenSwitch(condition, cases, case_contents, default_content, indent=4): + """ + Create a switch statement in the CPP generator. + + :param condition: condition of the switch statement + :param cases: list of the enum labels + :param case_contents: list of list of strings containing the body of each case by line + :param default_content: list of list of strings containing the body of the default case + :param indent: indentation size + :return: + """ + switch = [] + indentation = ' ' * indent + switch.append(2 * indentation + 'switch (%s) {\n' % condition) + + for case, case_content in zip(cases, case_contents): + switch.append(3 * indentation + 'case %s: {\n' % case) + for line in case_content: + switch.append(4 * indentation + line) + switch.append(3 * indentation + '}\n') + + switch.append(3 * indentation + 'default: {\n') + for line in default_content: + switch.append(4 * indentation + line) + switch.append(3 * indentation + '}\n') + switch.append(2 * indentation + '}\n') + + return ''.join(switch) + +def makeObjectType(handle_value): + return_string='VK_OBJECT_TYPE_' + value='' + + # Save the extension and get rid of it so we don't parse it out + extension = '' + if handle_value.endswith('KHR'): + extension = '_KHR' + value = handle_value[2:-3] + elif handle_value.endswith('EXT'): + extension = '_EXT' + value = handle_value[2:-3] + elif handle_value.endswith('AMD'): + extension = '_AMD' + value = handle_value[2:-3] + elif handle_value.endswith('NVX'): + extension = '_NVX' + value = handle_value[2:-3] + elif handle_value.endswith('NV'): + extension = '_NV' + value = handle_value[2:-2] + elif handle_value.endswith('INTEL'): + extension = '_INTEL' + value = handle_value[2:-5] + elif handle_value.endswith('FUCHSIA'): + extension = '_FUCHSIA' + value = handle_value[2:-7] + else: + value = handle_value[2:] + + for index, cur_char in enumerate(value): + if index > 0 and cur_char.isupper(): + return_string += '_' + return_string += cur_char + + if len(extension) > 0: + return_string += extension + + return return_string.upper() + +def makeOutStructSet(value, arguments=None, isFirstArg=False, isLastArg=False, indent=4): + """ + Create a structure element setting for the vulkan application. + + :param value: contents of the structure member for the initializer. + :param arguments: dictionary containing the key-values used for the string formatting. + :param isLastArg: boolean value if the line should be ended + :param indent: indentation size. + + :return: + """ + if not arguments: + arguments = {} + lineEnding = '' if isLastArg else ' << std::endl' + tabs = '\\t' if isFirstArg else '\\t\\t\\t' + return ((' ' * indent) + 'struct_body << "%s" << %s << ","%s;\n'.format(**arguments) % (tabs, value, lineEnding)).format(**arguments) + + +def printOutStream(values, arguments=None, indent=4): + """ + Output a single line into the CPP consumer. + + + :param values: list of contents to print the out stream. + :param arguments: dictionary containing the key-values used for the string formatting. + :param indent: indentation size. + + :return: + """ + if not arguments: + arguments = {} + return (' ' * indent) + 'out << "\\t\\t" << %s << std::endl;\n' % ' << '.join(values).format(**arguments) + +def replacePointerInLength(inString): + if inString == '': + return '' + if inString[:2] == '->': + new_string = '->GetPointer()->' + next_index = 2 + else: + new_string = inString[0] + next_index = 1 + return new_string + replacePointerInLength(inString[next_index:]) + +def makeParamList(cmdInfo, additionalParams): + paramList = [param.name for param in cmdInfo[2]] + if cmdInfo[0] != 'void': + paramList.insert(0, 'returnValue') + paramList.extend(additionalParams) + return ', '.join(paramList) + + +class VulkanStructPacketsHeaderGeneratorOptions(BaseGeneratorOptions): + """Options for generating a C++ class for Vulkan capture file to CPP source generation""" + + def __init__( + self, + blacklists=None, # Path to JSON file listing apicalls and structs to ignore. + platform_types=None, # Path to JSON file listing platform (WIN32, X11, etc.) defined types. + filename=None, + directory='.', + prefix_text=CPP_PREFIX_STRING, + protect_file=False, + protect_feature=True, + extraVulkanHeaders=[] + ): + BaseGeneratorOptions.__init__( + self, + blacklists, + platform_types, + filename, + directory, + CPP_PREFIX_STRING, + protect_file, + protect_feature, + extraVulkanHeaders=extraVulkanHeaders + ) + + +class VulkanStructPacketsHeaderGenerator(BaseGenerator): + """VulkanStructPacketsHeaderGenerator - subclass of BaseGenerator. + Generates C++ member definitions for the VulkanCppConsumer class responsible for + generating a textfile containing decoded Vulkan API call parameter data. + """ + + def __init__( + self, err_file=sys.stderr, warn_file=sys.stderr, diag_file=sys.stdout + ): + BaseGenerator.__init__( + self, + process_cmds=True, + process_structs=True, + feature_break=False, + err_file=err_file, + warn_file=warn_file, + diag_file=diag_file + ) + + # The generation of these functions are suspended for a while. + self.skippedApiFuncs = [ + 'vkGetPipelineCacheData', + 'vkGetPhysicalDeviceXcbPresentationSupportKHR', + ] + + # # TODO: Don't currently support Nvidia raytracing entrypoints + # self.APICALL_BLACKLIST = [ + # 'vkCmdBuildAccelerationStructureNV', + # 'vkCmdTraceRaysNV', + # 'vkCreateAccelerationStructureNV' + # ] + + self.stype_values = dict() + self.structs_with_handle_ptrs = [] + self.structs_with_handles = dict() + + def writeout(self, *args, **kwargs): + write(*args, **kwargs, file=self.outFile) + + def genStruct(self, typeinfo, typename, alias): + """ + Process struct information + + Note: Using method from replay consumer generator + """ + BaseGenerator.genStruct(self, typeinfo, typename, alias) + + if not alias: + self.check_struct_member_handles( + typename, self.structs_with_handles, + self.structs_with_handle_ptrs + ) + + stype = self.make_structure_type_enum(typeinfo, typename) + if stype: + self.stype_values[typename] = stype + + def beginFile(self, gen_opts): + """Method override.""" + BaseGenerator.beginFile(self, gen_opts) + + self.writeout('#include "generated/generated_vulkan_cpp_consumer.h"') + self.newline() + self.writeout('#include "decode/vulkan_cpp_consumer_base.h"') + self.writeout('#include "decode/vulkan_cpp_structs.h"') + self.writeout('#include "generated/generated_vulkan_cpp_structs.h"') + self.writeout('#include "generated/generated_vulkan_enum_to_string.h"') + self.writeout('#include "generated/generated_vulkan_cpp_consumer_extension.h"') + self.writeout('#include "decode/handle_pointer_decoder.h"') + self.writeout('#include "decode/pointer_decoder.h"') + self.writeout('#include "decode/string_decoder.h"') + self.writeout('#include "decode/struct_pointer_decoder.h"') + self.writeout('#include "decode/custom_vulkan_struct_handle_mappers.h"') + self.writeout('#include "generated/generated_vulkan_struct_decoders.h"') + self.writeout('#include "util/defines.h"') + self.writeout('#include "format/packet_call_id.h"') + self.includeVulkanHeaders(gen_opts) + self.newline() + self.writeout('#include ') + self.writeout('#include ') + self.newline() + self.writeout('GFXRECON_BEGIN_NAMESPACE(gfxrecon)') + self.writeout('GFXRECON_BEGIN_NAMESPACE(decode)') + self.newline() + + def endFile(self): + """Method override.""" + self.newline() + self.writeout('GFXRECON_END_NAMESPACE(decode)') + self.writeout('GFXRECON_END_NAMESPACE(gfxrecon)') + + # Finish processing in superclass + BaseGenerator.endFile(self) + + # + # Indicates that the current feature has C++ code to generate. + def need_feature_generation(self): + if self.feature_cmd_params or self.struct_names: + return True + return False + + # + # Performs C++ code generation for the feature. + def generate_feature(self): + """Performs C++ code generation for the feature.""" + platform_type = 'Vulkan' + + first = True + cmdnames = self.get_filtered_cmd_names() + cmdnames.sort() + + for cmd in cmdnames: + info = self.feature_cmd_params[cmd] + return_type = info[0] + values = info[2] + + cmddef = '' if first else '\n' + cmddef += self.make_packet( + return_type, + cmd, + values + ) + '\n' + + write(cmddef, file=self.outFile) + first = False + + def make_packet(self, return_type, name, values): + """make_packet - return Packet struct. + Generate packet for Vulkan only. + """ + struct_members = [] + struct_member = self.make_aligned_param_decl( + 'format::PacketCallId', 'packet_id', self.INDENT_SIZE, + self.genOpts.align_func_param + ) + struct_members.append(struct_member) + + struct_member = self.make_aligned_param_decl( + 'ApiCallInfo', 'call_info', self.INDENT_SIZE, + self.genOpts.align_func_param + ) + struct_members.append(struct_member) + + if return_type and return_type != 'void': + struct_member = self.make_aligned_param_decl( + return_type, 'return_value', self.INDENT_SIZE, + self.genOpts.align_func_param + ) + struct_members.append(struct_member) + + for value in values: + param_type = self.make_decoded_param_type(value) + if 'Decoder' in param_type: + param_type = '{}'.format(param_type) + struct_member = self.make_aligned_param_decl( + param_type, value.name, self.INDENT_SIZE, + self.genOpts.align_func_param + ) + struct_members.append(struct_member) + + if struct_members: + return 'struct Packet_{}\n{{\n{};\n}};'.format(name, ';\n'.join(struct_members)) \ No newline at end of file diff --git a/tools/replay/android_main.cpp b/tools/replay/android_main.cpp index e692515d53..702a6c9c0c 100644 --- a/tools/replay/android_main.cpp +++ b/tools/replay/android_main.cpp @@ -26,7 +26,7 @@ #include "application/android_context.h" #include "application/android_window.h" #include "decode/file_processor.h" -#include "decode/preload_file_processor.h" +#include "decode/vulkan_preload_file_processor.h" #include "decode/vulkan_replay_options.h" #include "decode/vulkan_tracked_object_info_table.h" #include "format/format.h" @@ -104,7 +104,7 @@ void android_main(struct android_app* app) { std::unique_ptr file_processor = arg_parser.IsOptionSet(kPreloadMeasurementRangeOption) - ? std::make_unique() + ? std::make_unique() : std::make_unique(); if (!file_processor->Initialize(filename)) @@ -156,6 +156,15 @@ void android_main(struct android_app* app) file_processor->AddDecoder(&decoder); application->SetPauseFrame(GetPauseFrame(arg_parser)); + gfxrecon::decode::VulkanPreloadDecoder vulkan_preload_decoder; + if (arg_parser.IsOptionSet(kPreloadMeasurementRangeOption)) + { + dynamic_cast(file_processor.get()) + ->SetPreloadDecoder(&vulkan_preload_decoder); + dynamic_cast(file_processor.get()) + ->SetConsumer(&replay_consumer); + } + // Warn if the capture layer is active. CheckActiveLayers(kLayerProperty); @@ -168,6 +177,7 @@ void android_main(struct android_app* app) fps_info.BeginFile(); + application->SetAPIDetected(false, true); application->Run(); // Add one so that it matches the trim range frame number semantic diff --git a/tools/replay/desktop_main.cpp b/tools/replay/desktop_main.cpp index 958382026c..18ad89efb4 100644 --- a/tools/replay/desktop_main.cpp +++ b/tools/replay/desktop_main.cpp @@ -27,6 +27,8 @@ #include "application/application.h" #include "decode/file_processor.h" #include "decode/preload_file_processor.h" +#include "decode/vulkan_preload_file_processor.h" +#include "decode/decode_api_detection.h" #include "decode/vulkan_replay_options.h" #include "decode/vulkan_tracked_object_info_table.h" #include "generated/generated_vulkan_decoder.h" @@ -152,9 +154,24 @@ int main(int argc, const char** argv) std::unique_ptr file_processor; + bool preload_detected_d3d12 = false; + bool preload_detected_vulkan = false; + gfxrecon::decode::DetectAPIs(filename, preload_detected_d3d12, preload_detected_vulkan); + if (arg_parser.IsOptionSet(kPreloadMeasurementRangeOption)) { - file_processor = std::make_unique(); + if (preload_detected_d3d12) + { + file_processor = std::make_unique(); + } + else if (preload_detected_vulkan) + { + file_processor = std::make_unique(); + } + else + { + GFXRECON_WRITE_CONSOLE("Replay has encountered a fatal error and cannot continue: No API detected."); + } } else { @@ -228,6 +245,16 @@ int main(int argc, const char** argv) vulkan_decoder.AddConsumer(&vulkan_replay_consumer); file_processor->AddDecoder(&vulkan_decoder); } + + gfxrecon::decode::VulkanPreloadDecoder vulkan_preload_decoder; + if (arg_parser.IsOptionSet(kPreloadMeasurementRangeOption) && !preload_detected_d3d12) + { + dynamic_cast(file_processor.get()) + ->SetPreloadDecoder(&vulkan_preload_decoder); + dynamic_cast(file_processor.get()) + ->SetConsumer(&vulkan_replay_consumer); + } + file_processor->SetPrintBlockInfoFlag(vulkan_replay_options.enable_print_block_info, vulkan_replay_options.block_index_from, vulkan_replay_options.block_index_to); @@ -298,6 +325,7 @@ int main(int argc, const char** argv) application->SetPauseFrame(GetPauseFrame(arg_parser)); application->SetFpsInfo(&fps_info); + application->SetAPIDetected(preload_detected_d3d12, preload_detected_vulkan); application->Run(); // XXX if the final frame ended with a Present, this would be the *next* frame