From 55c1cddf95370f754b8b5e5145384fd55be32d0f Mon Sep 17 00:00:00 2001 From: Locke Lin Date: Fri, 11 Aug 2023 12:42:15 -0600 Subject: [PATCH] Update headers to 1.3.261 Skip extension: VK_AMDX_shader_enqueue Deal with KHR suffix's VkFlags64 for ToString --- external/Vulkan-Headers | 2 +- framework/format/api_call_id.h | 4 + .../generated_decode_pnext_struct.cpp | 16 + .../generated_encode_pnext_struct.cpp | 12 + .../generated/generated_layer_func_table.h | 4 + .../generated_vulkan_api_call_encoders.cpp | 145 ++++++- .../generated_vulkan_api_call_encoders.h | 27 +- .../generated_vulkan_command_buffer_util.cpp | 7 + .../generated_vulkan_command_buffer_util.h | 2 + .../generated/generated_vulkan_consumer.h | 31 +- .../generated/generated_vulkan_decoder.cpp | 102 ++++- .../generated/generated_vulkan_decoder.h | 8 + .../generated_vulkan_dispatch_table.h | 14 +- .../generated_vulkan_enum_to_json.cpp | 394 +++++++++++++++++- .../generated/generated_vulkan_enum_to_json.h | 8 + .../generated_vulkan_enum_to_string.cpp | 140 ++++++- .../generated_vulkan_enum_to_string.h | 4 + .../generated_vulkan_export_json_consumer.cpp | 67 ++- .../generated_vulkan_export_json_consumer.h | 31 +- .../generated_vulkan_feature_util.cpp | 13 + ...ed_vulkan_referenced_resource_consumer.cpp | 15 + ...ated_vulkan_referenced_resource_consumer.h | 8 + .../generated_vulkan_replay_consumer.cpp | 116 +++++- .../generated_vulkan_replay_consumer.h | 31 +- .../generated_vulkan_struct_decoders.cpp | 173 ++++++-- .../generated_vulkan_struct_decoders.h | 97 ++++- ...generated_vulkan_struct_decoders_forward.h | 22 +- .../generated_vulkan_struct_encoders.cpp | 80 +++- .../generated_vulkan_struct_encoders.h | 11 +- ...generated_vulkan_struct_handle_mappers.cpp | 8 + .../generated_vulkan_struct_handle_mappers.h | 2 + ...enerated_vulkan_struct_handle_wrappers.cpp | 20 + .../generated_vulkan_struct_handle_wrappers.h | 2 + .../generated_vulkan_struct_to_json.cpp | 158 +++++-- .../generated_vulkan_struct_to_json.h | 10 +- .../vulkan_generators/base_generator.py | 9 +- layer/trace_layer.cpp | 3 +- 37 files changed, 1658 insertions(+), 138 deletions(-) diff --git a/external/Vulkan-Headers b/external/Vulkan-Headers index cb7b123f2d..450ead13e1 160000 --- a/external/Vulkan-Headers +++ b/external/Vulkan-Headers @@ -1 +1 @@ -Subproject commit cb7b123f2ddc04b86fd106c3a2b2e9872e8215b5 +Subproject commit 450ead13e1064584da027d91192bd7bfb724640f diff --git a/framework/format/api_call_id.h b/framework/format/api_call_id.h index 55e6e56797..ed2a19e194 100644 --- a/framework/format/api_call_id.h +++ b/framework/format/api_call_id.h @@ -695,6 +695,10 @@ enum ApiCallId : uint32_t ApiCall_vkCmdUpdatePipelineIndirectBuffer = MakeApiCallId(ApiFamily_Vulkan, 0x12d5), ApiCall_vkGetPipelineIndirectDeviceAddressNV = MakeApiCallId(ApiFamily_Vulkan, 0x12d6), ApiCall_vkCmdUpdatePipelineIndirectBufferNV = MakeApiCallId(ApiFamily_Vulkan, 0x12d7), + ApiCall_vkCmdBindIndexBuffer2KHR = MakeApiCallId(ApiFamily_Vulkan, 0x12d8), + ApiCall_vkGetRenderingAreaGranularityKHR = MakeApiCallId(ApiFamily_Vulkan, 0x12d9), + ApiCall_vkGetDeviceImageSubresourceLayoutKHR = MakeApiCallId(ApiFamily_Vulkan, 0x12da), + ApiCall_vkGetImageSubresourceLayout2KHR = MakeApiCallId(ApiFamily_Vulkan, 0x12db), ApiCall_VulkanLast, diff --git a/framework/generated/generated_decode_pnext_struct.cpp b/framework/generated/generated_decode_pnext_struct.cpp index 37d28f8d32..1f9cb88d06 100644 --- a/framework/generated/generated_decode_pnext_struct.cpp +++ b/framework/generated/generated_decode_pnext_struct.cpp @@ -774,6 +774,22 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); diff --git a/framework/generated/generated_encode_pnext_struct.cpp b/framework/generated/generated_encode_pnext_struct.cpp index 7c70c849d6..11d47e3b05 100644 --- a/framework/generated/generated_encode_pnext_struct.cpp +++ b/framework/generated/generated_encode_pnext_struct.cpp @@ -602,6 +602,18 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: EncodeStructPtr(encoder, reinterpret_cast(base)); break; diff --git a/framework/generated/generated_layer_func_table.h b/framework/generated/generated_layer_func_table.h index b6bdef2070..c13900ffe9 100644 --- a/framework/generated/generated_layer_func_table.h +++ b/framework/generated/generated_layer_func_table.h @@ -405,6 +405,10 @@ const std::unordered_map func_table = { { "vkGetDeviceBufferMemoryRequirementsKHR", reinterpret_cast(encode::GetDeviceBufferMemoryRequirementsKHR) }, { "vkGetDeviceImageMemoryRequirementsKHR", reinterpret_cast(encode::GetDeviceImageMemoryRequirementsKHR) }, { "vkGetDeviceImageSparseMemoryRequirementsKHR", reinterpret_cast(encode::GetDeviceImageSparseMemoryRequirementsKHR) }, + { "vkCmdBindIndexBuffer2KHR", reinterpret_cast(encode::CmdBindIndexBuffer2KHR) }, + { "vkGetRenderingAreaGranularityKHR", reinterpret_cast(encode::GetRenderingAreaGranularityKHR) }, + { "vkGetDeviceImageSubresourceLayoutKHR", reinterpret_cast(encode::GetDeviceImageSubresourceLayoutKHR) }, + { "vkGetImageSubresourceLayout2KHR", reinterpret_cast(encode::GetImageSubresourceLayout2KHR) }, { "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", reinterpret_cast(encode::GetPhysicalDeviceCooperativeMatrixPropertiesKHR) }, { "vkCreateDebugReportCallbackEXT", reinterpret_cast(encode::CreateDebugReportCallbackEXT) }, { "vkDestroyDebugReportCallbackEXT", reinterpret_cast(encode::DestroyDebugReportCallbackEXT) }, diff --git a/framework/generated/generated_vulkan_api_call_encoders.cpp b/framework/generated/generated_vulkan_api_call_encoders.cpp index 979e17688c..e787ce4daf 100644 --- a/framework/generated/generated_vulkan_api_call_encoders.cpp +++ b/framework/generated/generated_vulkan_api_call_encoders.cpp @@ -13349,6 +13349,147 @@ VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR( CustomEncoderPostCall::Dispatch(VulkanCaptureManager::Get(), device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } +VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) +{ + auto force_command_serialization = VulkanCaptureManager::Get()->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(VulkanCaptureManager::Get(), commandBuffer, buffer, offset, size, indexType); + + auto encoder = VulkanCaptureManager::Get()->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdBindIndexBuffer2KHR); + if (encoder) + { + encoder->EncodeHandleValue(commandBuffer); + encoder->EncodeHandleValue(buffer); + encoder->EncodeVkDeviceSizeValue(offset); + encoder->EncodeVkDeviceSizeValue(size); + encoder->EncodeEnumValue(indexType); + VulkanCaptureManager::Get()->EndCommandApiCallCapture(commandBuffer, TrackCmdBindIndexBuffer2KHRHandles, buffer); + } + + GetDeviceTable(commandBuffer)->CmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType); + + CustomEncoderPostCall::Dispatch(VulkanCaptureManager::Get(), commandBuffer, buffer, offset, size, indexType); +} + +VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR( + VkDevice device, + const VkRenderingAreaInfoKHR* pRenderingAreaInfo, + VkExtent2D* pGranularity) +{ + auto force_command_serialization = VulkanCaptureManager::Get()->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(VulkanCaptureManager::Get(), device, pRenderingAreaInfo, pGranularity); + + GetDeviceTable(device)->GetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity); + + auto encoder = VulkanCaptureManager::Get()->BeginApiCallCapture(format::ApiCallId::ApiCall_vkGetRenderingAreaGranularityKHR); + if (encoder) + { + encoder->EncodeHandleValue(device); + EncodeStructPtr(encoder, pRenderingAreaInfo); + EncodeStructPtr(encoder, pGranularity); + VulkanCaptureManager::Get()->EndApiCallCapture(); + } + + CustomEncoderPostCall::Dispatch(VulkanCaptureManager::Get(), device, pRenderingAreaInfo, pGranularity); +} + +VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR( + VkDevice device, + const VkDeviceImageSubresourceInfoKHR* pInfo, + VkSubresourceLayout2KHR* pLayout) +{ + auto force_command_serialization = VulkanCaptureManager::Get()->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(VulkanCaptureManager::Get(), device, pInfo, pLayout); + + auto handle_unwrap_memory = VulkanCaptureManager::Get()->GetHandleUnwrapMemory(); + const VkDeviceImageSubresourceInfoKHR* pInfo_unwrapped = UnwrapStructPtrHandles(pInfo, handle_unwrap_memory); + + GetDeviceTable(device)->GetDeviceImageSubresourceLayoutKHR(device, pInfo_unwrapped, pLayout); + + auto encoder = VulkanCaptureManager::Get()->BeginApiCallCapture(format::ApiCallId::ApiCall_vkGetDeviceImageSubresourceLayoutKHR); + if (encoder) + { + encoder->EncodeHandleValue(device); + EncodeStructPtr(encoder, pInfo); + EncodeStructPtr(encoder, pLayout); + VulkanCaptureManager::Get()->EndApiCallCapture(); + } + + CustomEncoderPostCall::Dispatch(VulkanCaptureManager::Get(), device, pInfo, pLayout); +} + +VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR( + VkDevice device, + VkImage image, + const VkImageSubresource2KHR* pSubresource, + VkSubresourceLayout2KHR* pLayout) +{ + auto force_command_serialization = VulkanCaptureManager::Get()->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(VulkanCaptureManager::Get(), device, image, pSubresource, pLayout); + + GetDeviceTable(device)->GetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout); + + auto encoder = VulkanCaptureManager::Get()->BeginApiCallCapture(format::ApiCallId::ApiCall_vkGetImageSubresourceLayout2KHR); + if (encoder) + { + encoder->EncodeHandleValue(device); + encoder->EncodeHandleValue(image); + EncodeStructPtr(encoder, pSubresource); + EncodeStructPtr(encoder, pLayout); + VulkanCaptureManager::Get()->EndApiCallCapture(); + } + + CustomEncoderPostCall::Dispatch(VulkanCaptureManager::Get(), device, image, pSubresource, pLayout); +} + VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, @@ -18281,8 +18422,8 @@ VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT( VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( VkDevice device, VkImage image, - const VkImageSubresource2EXT* pSubresource, - VkSubresourceLayout2EXT* pLayout) + const VkImageSubresource2KHR* pSubresource, + VkSubresourceLayout2KHR* pLayout) { auto force_command_serialization = VulkanCaptureManager::Get()->GetForceCommandSerialization(); std::shared_lock shared_api_call_lock; diff --git a/framework/generated/generated_vulkan_api_call_encoders.h b/framework/generated/generated_vulkan_api_call_encoders.h index 23a8118d0b..95ca1eb253 100644 --- a/framework/generated/generated_vulkan_api_call_encoders.h +++ b/framework/generated/generated_vulkan_api_call_encoders.h @@ -1917,6 +1917,29 @@ VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR( uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR( + VkDevice device, + const VkRenderingAreaInfoKHR* pRenderingAreaInfo, + VkExtent2D* pGranularity); + +VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR( + VkDevice device, + const VkDeviceImageSubresourceInfoKHR* pInfo, + VkSubresourceLayout2KHR* pLayout); + +VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR( + VkDevice device, + VkImage image, + const VkImageSubresource2KHR* pSubresource, + VkSubresourceLayout2KHR* pLayout); + VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, @@ -2625,8 +2648,8 @@ VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT( VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( VkDevice device, VkImage image, - const VkImageSubresource2EXT* pSubresource, - VkSubresourceLayout2EXT* pLayout); + const VkImageSubresource2KHR* pSubresource, + VkSubresourceLayout2KHR* pLayout); VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT( VkDevice device, diff --git a/framework/generated/generated_vulkan_command_buffer_util.cpp b/framework/generated/generated_vulkan_command_buffer_util.cpp index 9d42ae0886..2141730a1a 100644 --- a/framework/generated/generated_vulkan_command_buffer_util.cpp +++ b/framework/generated/generated_vulkan_command_buffer_util.cpp @@ -974,6 +974,13 @@ void TrackCmdResolveImage2KHRHandles(CommandBufferWrapper* wrapper, const VkReso } } +void TrackCmdBindIndexBuffer2KHRHandles(CommandBufferWrapper* wrapper, VkBuffer buffer) +{ + assert(wrapper != nullptr); + + if(buffer != VK_NULL_HANDLE) wrapper->command_handles[CommandHandleType::BufferHandle].insert(GetWrappedId(buffer)); +} + void TrackCmdBindTransformFeedbackBuffersEXTHandles(CommandBufferWrapper* wrapper, uint32_t bindingCount, const VkBuffer* pBuffers) { assert(wrapper != nullptr); diff --git a/framework/generated/generated_vulkan_command_buffer_util.h b/framework/generated/generated_vulkan_command_buffer_util.h index 52b2a4489a..38c7b172b1 100644 --- a/framework/generated/generated_vulkan_command_buffer_util.h +++ b/framework/generated/generated_vulkan_command_buffer_util.h @@ -176,6 +176,8 @@ void TrackCmdBlitImage2KHRHandles(CommandBufferWrapper* wrapper, const VkBlitIma void TrackCmdResolveImage2KHRHandles(CommandBufferWrapper* wrapper, const VkResolveImageInfo2* pResolveImageInfo); +void TrackCmdBindIndexBuffer2KHRHandles(CommandBufferWrapper* wrapper, VkBuffer buffer); + void TrackCmdBindTransformFeedbackBuffersEXTHandles(CommandBufferWrapper* wrapper, uint32_t bindingCount, const VkBuffer* pBuffers); void TrackCmdBeginTransformFeedbackEXTHandles(CommandBufferWrapper* wrapper, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers); diff --git a/framework/generated/generated_vulkan_consumer.h b/framework/generated/generated_vulkan_consumer.h index 1ffb2c828d..0959c9c8fc 100644 --- a/framework/generated/generated_vulkan_consumer.h +++ b/framework/generated/generated_vulkan_consumer.h @@ -2439,6 +2439,33 @@ class VulkanConsumer : public VulkanConsumerBase PointerDecoder* pSparseMemoryRequirementCount, StructPointerDecoder* pSparseMemoryRequirements) {} + virtual void Process_vkCmdBindIndexBuffer2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + format::HandleId buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) {} + + virtual void Process_vkGetRenderingAreaGranularityKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pRenderingAreaInfo, + StructPointerDecoder* pGranularity) {} + + virtual void Process_vkGetDeviceImageSubresourceLayoutKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pLayout) {} + + virtual void Process_vkGetImageSubresourceLayout2KHR( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId image, + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) {} + virtual void Process_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( const ApiCallInfo& call_info, VkResult returnValue, @@ -3350,8 +3377,8 @@ class VulkanConsumer : public VulkanConsumerBase const ApiCallInfo& call_info, format::HandleId device, format::HandleId image, - StructPointerDecoder* pSubresource, - StructPointerDecoder* pLayout) {} + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) {} virtual void Process_vkReleaseSwapchainImagesEXT( const ApiCallInfo& call_info, diff --git a/framework/generated/generated_vulkan_decoder.cpp b/framework/generated/generated_vulkan_decoder.cpp index e761ebf060..beb8f5e81b 100644 --- a/framework/generated/generated_vulkan_decoder.cpp +++ b/framework/generated/generated_vulkan_decoder.cpp @@ -7591,6 +7591,92 @@ size_t VulkanDecoder::Decode_vkGetDeviceImageSparseMemoryRequirementsKHR(const A return bytes_read; } +size_t VulkanDecoder::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::DecodeVkDeviceSizeValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &offset); + bytes_read += ValueDecoder::DecodeVkDeviceSizeValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &size); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indexType); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdBindIndexBuffer2KHR(call_info, commandBuffer, buffer, offset, size, indexType); + } + + return bytes_read; +} + +size_t VulkanDecoder::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.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pGranularity.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkGetRenderingAreaGranularityKHR(call_info, device, &pRenderingAreaInfo, &pGranularity); + } + + return bytes_read; +} + +size_t VulkanDecoder::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.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pLayout.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkGetDeviceImageSubresourceLayoutKHR(call_info, device, &pInfo, &pLayout); + } + + return bytes_read; +} + +size_t VulkanDecoder::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.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pLayout.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkGetImageSubresourceLayout2KHR(call_info, device, image, &pSubresource, &pLayout); + } + + return bytes_read; +} + size_t VulkanDecoder::Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) { size_t bytes_read = 0; @@ -10443,8 +10529,8 @@ size_t VulkanDecoder::Decode_vkGetImageSubresourceLayout2EXT(const ApiCallInfo& format::HandleId device; format::HandleId image; - StructPointerDecoder pSubresource; - StructPointerDecoder pLayout; + 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); @@ -14176,6 +14262,18 @@ void VulkanDecoder::DecodeFunctionCall(format::ApiCallId call_id, 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; diff --git a/framework/generated/generated_vulkan_decoder.h b/framework/generated/generated_vulkan_decoder.h index 82bf406381..15737df595 100644 --- a/framework/generated/generated_vulkan_decoder.h +++ b/framework/generated/generated_vulkan_decoder.h @@ -751,6 +751,14 @@ class VulkanDecoder : public VulkanDecoderBase 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_vkCreateDebugReportCallbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); diff --git a/framework/generated/generated_vulkan_dispatch_table.h b/framework/generated/generated_vulkan_dispatch_table.h index 29dc25d894..fa373fa4a1 100644 --- a/framework/generated/generated_vulkan_dispatch_table.h +++ b/framework/generated/generated_vulkan_dispatch_table.h @@ -455,6 +455,10 @@ static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR(VkCommandBuffer, VkDe static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR(VkDevice, const VkDeviceBufferMemoryRequirements*, VkMemoryRequirements2*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetDeviceBufferMemoryRequirementsKHR was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR(VkDevice, const VkDeviceImageMemoryRequirements*, VkMemoryRequirements2*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetDeviceImageMemoryRequirementsKHR was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR(VkDevice, const VkDeviceImageMemoryRequirements*, uint32_t*, VkSparseImageMemoryRequirements2*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetDeviceImageSparseMemoryRequirementsKHR was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR(VkCommandBuffer, VkBuffer, VkDeviceSize, VkDeviceSize, VkIndexType) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdBindIndexBuffer2KHR was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL GetRenderingAreaGranularityKHR(VkDevice, const VkRenderingAreaInfoKHR*, VkExtent2D*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetRenderingAreaGranularityKHR was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayoutKHR(VkDevice, const VkDeviceImageSubresourceInfoKHR*, VkSubresourceLayout2KHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetDeviceImageSubresourceLayoutKHR was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2KHR(VkDevice, VkImage, const VkImageSubresource2KHR*, VkSubresourceLayout2KHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetImageSubresourceLayout2KHR was called, resulting in no-op behavior."); } static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice, const VkDebugMarkerObjectTagInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDebugMarkerSetObjectTagEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice, const VkDebugMarkerObjectNameInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDebugMarkerSetObjectNameEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer, const VkDebugMarkerMarkerInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdDebugMarkerBeginEXT was called, resulting in no-op behavior."); } @@ -557,7 +561,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToImageEXT(VkDevice, const VkCop static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToMemoryEXT(VkDevice, const VkCopyImageToMemoryInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCopyImageToMemoryEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL CopyImageToImageEXT(VkDevice, const VkCopyImageToImageInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCopyImageToImageEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL TransitionImageLayoutEXT(VkDevice, uint32_t, const VkHostImageLayoutTransitionInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkTransitionImageLayoutEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT(VkDevice, VkImage, const VkImageSubresource2EXT*, VkSubresourceLayout2EXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetImageSubresourceLayout2EXT was called, resulting in no-op behavior."); } +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT(VkDevice, VkImage, const VkImageSubresource2KHR*, VkSubresourceLayout2KHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetImageSubresourceLayout2EXT was called, resulting in no-op behavior."); } static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT(VkDevice, const VkReleaseSwapchainImagesInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkReleaseSwapchainImagesEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoNV*, VkMemoryRequirements2*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetGeneratedCommandsMemoryRequirementsNV was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(VkCommandBuffer, const VkGeneratedCommandsInfoNV*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdPreprocessGeneratedCommandsNV was called, resulting in no-op behavior."); } @@ -1082,6 +1086,10 @@ struct DeviceTable PFN_vkGetDeviceBufferMemoryRequirementsKHR GetDeviceBufferMemoryRequirementsKHR{ noop::GetDeviceBufferMemoryRequirementsKHR }; PFN_vkGetDeviceImageMemoryRequirementsKHR GetDeviceImageMemoryRequirementsKHR{ noop::GetDeviceImageMemoryRequirementsKHR }; PFN_vkGetDeviceImageSparseMemoryRequirementsKHR GetDeviceImageSparseMemoryRequirementsKHR{ noop::GetDeviceImageSparseMemoryRequirementsKHR }; + PFN_vkCmdBindIndexBuffer2KHR CmdBindIndexBuffer2KHR{ noop::CmdBindIndexBuffer2KHR }; + PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR{ noop::GetRenderingAreaGranularityKHR }; + PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR{ noop::GetDeviceImageSubresourceLayoutKHR }; + PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR{ noop::GetImageSubresourceLayout2KHR }; PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT{ noop::DebugMarkerSetObjectTagEXT }; PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT{ noop::DebugMarkerSetObjectNameEXT }; PFN_vkCmdDebugMarkerBeginEXT CmdDebugMarkerBeginEXT{ noop::CmdDebugMarkerBeginEXT }; @@ -1716,6 +1724,10 @@ static void LoadDeviceTable(PFN_vkGetDeviceProcAddr gpa, VkDevice device, Device LoadFunction(gpa, device, "vkGetDeviceBufferMemoryRequirementsKHR", &table->GetDeviceBufferMemoryRequirementsKHR); LoadFunction(gpa, device, "vkGetDeviceImageMemoryRequirementsKHR", &table->GetDeviceImageMemoryRequirementsKHR); LoadFunction(gpa, device, "vkGetDeviceImageSparseMemoryRequirementsKHR", &table->GetDeviceImageSparseMemoryRequirementsKHR); + LoadFunction(gpa, device, "vkCmdBindIndexBuffer2KHR", &table->CmdBindIndexBuffer2KHR); + LoadFunction(gpa, device, "vkGetRenderingAreaGranularityKHR", &table->GetRenderingAreaGranularityKHR); + LoadFunction(gpa, device, "vkGetDeviceImageSubresourceLayoutKHR", &table->GetDeviceImageSubresourceLayoutKHR); + LoadFunction(gpa, device, "vkGetImageSubresourceLayout2KHR", &table->GetImageSubresourceLayout2KHR); LoadFunction(gpa, device, "vkDebugMarkerSetObjectTagEXT", &table->DebugMarkerSetObjectTagEXT); LoadFunction(gpa, device, "vkDebugMarkerSetObjectNameEXT", &table->DebugMarkerSetObjectNameEXT); LoadFunction(gpa, device, "vkCmdDebugMarkerBeginEXT", &table->CmdDebugMarkerBeginEXT); diff --git a/framework/generated/generated_vulkan_enum_to_json.cpp b/framework/generated/generated_vulkan_enum_to_json.cpp index bb59046671..bb8d26eccc 100644 --- a/framework/generated/generated_vulkan_enum_to_json.cpp +++ b/framework/generated/generated_vulkan_enum_to_json.cpp @@ -1438,6 +1438,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkBufferUsageFlagBits& val case VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT: jdata = "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"; break; + case VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX: + jdata = "VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; + break; case VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: jdata = "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; break; @@ -1474,6 +1477,93 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkBufferUsageFlagBits& val } } +void FieldToJson(VkBufferUsageFlagBits2KHR_t, nlohmann::ordered_json& jdata, const VkBufferUsageFlagBits2KHR& value, const JsonOptions& options) +{ + switch (value) { + case VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX: + jdata = "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; + break; + case VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT: + jdata = "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; + break; + case VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: + jdata = "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; + break; + case VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: + jdata = "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; + break; + case VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: + jdata = "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; + break; + case VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: + jdata = "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"; + break; + case VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: + jdata = "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"; + break; + case VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: + jdata = "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; + break; + case VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: + jdata = "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; + break; + case VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: + jdata = "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; + break; + default: + jdata = to_hex_fixed_width(value); + break; + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const VkBuildAccelerationStructureFlagBitsKHR& value, const JsonOptions& options) { switch (value) { @@ -3931,6 +4021,12 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkFormat& value, const Jso case VK_FORMAT_R16G16_S10_5_NV: jdata = "VK_FORMAT_R16G16_S10_5_NV"; break; + case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: + jdata = "VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR"; + break; + case VK_FORMAT_A8_UNORM_KHR: + jdata = "VK_FORMAT_A8_UNORM_KHR"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -5734,6 +5830,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineBindPoint& value case VK_PIPELINE_BIND_POINT_COMPUTE: jdata = "VK_PIPELINE_BIND_POINT_COMPUTE"; break; + case VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX: + jdata = "VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX"; + break; case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: jdata = "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR"; break; @@ -5889,6 +5988,108 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineCreateFlagBits& } } +void FieldToJson(VkPipelineCreateFlagBits2KHR_t, nlohmann::ordered_json& jdata, const VkPipelineCreateFlagBits2KHR& value, const JsonOptions& options) +{ + switch (value) { + case VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV: + jdata = "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV"; + break; + case VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT"; + break; + case VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT"; + break; + case VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV: + jdata = "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV"; + break; + case VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: + jdata = "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + break; + case VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; + break; + case VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + break; + case VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + break; + case VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT"; + break; + case VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT"; + break; + case VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: + jdata = "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; + break; + case VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"; + break; + default: + jdata = to_hex_fixed_width(value); + break; + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineCreationFeedbackFlagBits& value, const JsonOptions& options) { switch (value) { @@ -8576,6 +8777,21 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: jdata = "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX"; + break; + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX: + jdata = "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX"; + break; + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: + jdata = "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX"; + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: + jdata = "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX"; + break; case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: jdata = "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT"; break; @@ -9371,12 +9587,6 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: jdata = "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT"; break; - case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: - jdata = "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT"; - break; - case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: - jdata = "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT"; - break; case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: jdata = "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT"; break; @@ -9737,6 +9947,30 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR"; + break; + case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR"; + break; + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR"; + break; + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR: + jdata = "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR"; + break; + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR: + jdata = "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR"; + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR"; + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR"; + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR"; break; @@ -11182,6 +11416,8 @@ void FieldToJson(VkBufferUsageFlags_t, nlohmann::ordered_json& jdata, const VkFl return std::string("VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"); case VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT: return std::string("VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"); + case VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX: + return std::string("VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"); case VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: return std::string("VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"); case VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: @@ -11207,6 +11443,74 @@ void FieldToJson(VkBufferUsageFlags_t, nlohmann::ordered_json& jdata, const VkFl }); } +void FieldToJson(VkBufferUsageFlags2KHR_t, nlohmann::ordered_json& jdata, const VkFlags64 flags, const JsonOptions& options) +{ + if (!options.expand_flags) + { + jdata = to_hex_fixed_width(flags); + return; + } + jdata = ExpandFlags(flags, [](VkFlags64 flags) + { + switch (flags) + { + case VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR"); + case VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR"); + case VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"); + case VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"); + case VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR"); + case VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR"); + case VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR"); + case VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR"); + case VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR"); + case VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX: + return std::string("VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"); + case VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT: + return std::string("VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT"); + case VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR"); + case VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: + return std::string("VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"); + case VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: + return std::string("VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"); + case VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR"); + case VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR"); + case VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR"); + case VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR"); + case VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR"); + case VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"); + case VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: + return std::string("VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"); + case VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: + return std::string("VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"); + case VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: + return std::string("VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"); + case VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: + return std::string("VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"); + case VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: + return std::string("VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"); + case VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: + return std::string("VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"); + } + return to_hex_fixed_width(flags); + }); +} + void FieldToJson(VkBufferViewCreateFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { jdata = to_hex_fixed_width(flags); @@ -13050,6 +13354,84 @@ void FieldToJson(VkPipelineCreateFlags_t, nlohmann::ordered_json& jdata, const V }); } +void FieldToJson(VkPipelineCreateFlags2KHR_t, nlohmann::ordered_json& jdata, const VkFlags64 flags, const JsonOptions& options) +{ + if (!options.expand_flags) + { + jdata = to_hex_fixed_width(flags); + return; + } + jdata = ExpandFlags(flags, [](VkFlags64 flags) + { + switch (flags) + { + case VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR"); + case VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR"); + case VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR"); + case VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR"); + case VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR"); + case VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV: + return std::string("VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV"); + case VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR"); + case VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"); + case VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR"); + case VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR"); + case VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT"); + case VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT"); + case VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"); + case VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV: + return std::string("VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV"); + case VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: + return std::string("VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"); + case VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"); + case VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"); + case VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"); + case VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT"); + case VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT"); + case VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: + return std::string("VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"); + case VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"); + } + return to_hex_fixed_width(flags); + }); +} + void FieldToJson(VkPipelineCreationFeedbackFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) diff --git a/framework/generated/generated_vulkan_enum_to_json.h b/framework/generated/generated_vulkan_enum_to_json.h index a06569f42c..37fb9b7a79 100644 --- a/framework/generated/generated_vulkan_enum_to_json.h +++ b/framework/generated/generated_vulkan_enum_to_json.h @@ -53,6 +53,7 @@ struct VkAndroidSurfaceCreateFlagsKHR_t { }; struct VkAttachmentDescriptionFlags_t { }; struct VkBufferCreateFlags_t { }; struct VkBufferUsageFlags_t { }; +struct VkBufferUsageFlags2KHR_t { }; struct VkBufferViewCreateFlags_t { }; struct VkBuildAccelerationStructureFlagsKHR_t { }; struct VkBuildMicromapFlagsEXT_t { }; @@ -138,6 +139,7 @@ struct VkPipelineCoverageModulationStateCreateFlagsNV_t { }; struct VkPipelineCoverageReductionStateCreateFlagsNV_t { }; struct VkPipelineCoverageToColorStateCreateFlagsNV_t { }; struct VkPipelineCreateFlags_t { }; +struct VkPipelineCreateFlags2KHR_t { }; struct VkPipelineCreationFeedbackFlags_t { }; struct VkPipelineDepthStencilStateCreateFlags_t { }; struct VkPipelineDiscardRectangleStateCreateFlagsEXT_t { }; @@ -223,7 +225,9 @@ struct VkWin32SurfaceCreateFlagsKHR_t { }; struct VkXcbSurfaceCreateFlagsKHR_t { }; struct VkXlibSurfaceCreateFlagsKHR_t { }; struct VkAccessFlagBits2_t { }; +struct VkBufferUsageFlagBits2KHR_t { }; struct VkFormatFeatureFlagBits2_t { }; +struct VkPipelineCreateFlagBits2KHR_t { }; struct VkPipelineStageFlagBits2_t { }; @@ -265,6 +269,7 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkBlendOverlapEXT& value, void FieldToJson(nlohmann::ordered_json& jdata, const VkBorderColor& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkBufferCreateFlagBits& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkBufferUsageFlagBits& value, const JsonOptions& options = JsonOptions()); +void FieldToJson(VkBufferUsageFlagBits2KHR_t, nlohmann::ordered_json& jdata, const VkBufferUsageFlagBits2KHR& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkBuildAccelerationStructureFlagBitsKHR& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkBuildAccelerationStructureModeKHR& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkBuildMicromapFlagBitsEXT& value, const JsonOptions& options = JsonOptions()); @@ -392,6 +397,7 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineCacheHeaderVersi void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineColorBlendStateCreateFlagBits& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineCompilerControlFlagBitsAMD& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineCreateFlagBits& value, const JsonOptions& options = JsonOptions()); +void FieldToJson(VkPipelineCreateFlagBits2KHR_t, nlohmann::ordered_json& jdata, const VkPipelineCreateFlagBits2KHR& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineCreationFeedbackFlagBits& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineDepthStencilStateCreateFlagBits& value, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineExecutableStatisticFormatKHR& value, const JsonOptions& options = JsonOptions()); @@ -500,6 +506,7 @@ void FieldToJson(VkAndroidSurfaceCreateFlagsKHR_t, nlohmann::ordered_json& jdata void FieldToJson(VkAttachmentDescriptionFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkBufferCreateFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkBufferUsageFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); +void FieldToJson(VkBufferUsageFlags2KHR_t, nlohmann::ordered_json& jdata, const VkFlags64 flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkBufferViewCreateFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkBuildAccelerationStructureFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkBuildMicromapFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); @@ -585,6 +592,7 @@ void FieldToJson(VkPipelineCoverageModulationStateCreateFlagsNV_t, nlohmann::ord void FieldToJson(VkPipelineCoverageReductionStateCreateFlagsNV_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkPipelineCoverageToColorStateCreateFlagsNV_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkPipelineCreateFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); +void FieldToJson(VkPipelineCreateFlags2KHR_t, nlohmann::ordered_json& jdata, const VkFlags64 flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkPipelineCreationFeedbackFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkPipelineDepthStencilStateCreateFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); void FieldToJson(VkPipelineDiscardRectangleStateCreateFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options = JsonOptions()); diff --git a/framework/generated/generated_vulkan_enum_to_string.cpp b/framework/generated/generated_vulkan_enum_to_string.cpp index 52d0bfad10..025bf3ce8b 100644 --- a/framework/generated/generated_vulkan_enum_to_string.cpp +++ b/framework/generated/generated_vulkan_enum_to_string.cpp @@ -559,6 +559,7 @@ template <> std::string ToString(const VkBufferUsageFlagB case VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; case VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: return "VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; case VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT: return "VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT"; + case VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX: return "VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; case VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: return "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; case VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: return "VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; case VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR: return "VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR"; @@ -1175,6 +1176,8 @@ template <> std::string ToString(const VkFormat& value, ToStringFlags, case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"; case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"; case VK_FORMAT_R16G16_S10_5_NV: return "VK_FORMAT_R16G16_S10_5_NV"; + case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: return "VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR"; + case VK_FORMAT_A8_UNORM_KHR: return "VK_FORMAT_A8_UNORM_KHR"; default: break; } return "Unhandled VkFormat"; @@ -1599,6 +1602,7 @@ template <> std::string ToString(const VkPipelineBindPoint& switch (value) { case VK_PIPELINE_BIND_POINT_GRAPHICS: return "VK_PIPELINE_BIND_POINT_GRAPHICS"; case VK_PIPELINE_BIND_POINT_COMPUTE: return "VK_PIPELINE_BIND_POINT_COMPUTE"; + case VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX: return "VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX"; case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: return "VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR"; case VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI: return "VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI"; default: break; @@ -2534,6 +2538,11 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: return "VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID"; case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID"; case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: return "VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX"; + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX: return "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX"; + case VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX: return "VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX"; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX: return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX"; case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: return "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT"; case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: return "VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT"; case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT"; @@ -2799,8 +2808,6 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT"; case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: return "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT"; - case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: return "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT"; - case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: return "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT"; case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT"; @@ -2921,6 +2928,14 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: return "VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR"; + case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR: return "VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR"; + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: return "VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR"; + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR: return "VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR"; + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR: return "VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR"; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR"; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT"; @@ -4170,6 +4185,127 @@ template <> std::string ToString(VkFlags vkFlags, return BitmaskToString(vkFlags); } +std::string VkBufferUsageFlagBits2KHRToString(const VkBufferUsageFlagBits2KHR value) +{ + switch (value) { + case VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR: return "VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR"; + case VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR: return "VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR"; + case VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: return "VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR"; + case VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: return "VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR"; + case VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR: return "VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR"; + case VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR: return "VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR"; + case VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR: return "VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR"; + case VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR: return "VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR"; + case VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR: return "VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR"; + case VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX: return "VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX"; + case VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT: return "VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT"; + case VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR: return "VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR"; + case VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT"; + case VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: return "VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT"; + case VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR: return "VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR"; + case VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR: return "VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR"; + case VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR: return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR"; + case VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR: return "VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR"; + case VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR: return "VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR"; + case VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR"; + case VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: return "VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR"; + case VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: return "VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT"; + case VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: return "VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT"; + case VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; + case VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; + case VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; + default: break; + } + return "Unhandled VkBufferUsageFlagBits2KHR"; +} + +std::string VkBufferUsageFlags2KHRToString(VkFlags64 vkFlags) +{ + std::string str; + VkFlags64 index = 0U; + while (vkFlags) + { + if (vkFlags & 1U) + { + if (!str.empty()) + { + str += '|'; + } + str.append(VkBufferUsageFlagBits2KHRToString(static_cast(1U) << index)); + } + ++index; + vkFlags >>= 1U; + } + if (str.empty()) + { + str.append(VkBufferUsageFlagBits2KHRToString(0U)); + } + return str; +} + +std::string VkPipelineCreateFlagBits2KHRToString(const VkPipelineCreateFlagBits2KHR value) +{ + switch (value) { + case VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR: return "VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR"; + case VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR: return "VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR"; + case VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR: return "VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR"; + case VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: return "VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR"; + case VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR: return "VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR"; + case VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV: return "VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV"; + case VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR: return "VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR"; + case VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: return "VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR"; + case VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR: return "VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR"; + case VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR: return "VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR"; + case VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT: return "VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT"; + case VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: return "VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT"; + case VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR: return "VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR: return "VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: return "VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: return "VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR"; + case VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV: return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV: return "VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV"; + case VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR"; + case VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: return "VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: return "VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT"; + case VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: return "VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + case VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: return "VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT"; + case VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT: return "VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT"; + case VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT: return "VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT"; + case VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; + case VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT: return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"; + default: break; + } + return "Unhandled VkPipelineCreateFlagBits2KHR"; +} + +std::string VkPipelineCreateFlags2KHRToString(VkFlags64 vkFlags) +{ + std::string str; + VkFlags64 index = 0U; + while (vkFlags) + { + if (vkFlags & 1U) + { + if (!str.empty()) + { + str += '|'; + } + str.append(VkPipelineCreateFlagBits2KHRToString(static_cast(1U) << index)); + } + ++index; + vkFlags >>= 1U; + } + if (str.empty()) + { + str.append(VkPipelineCreateFlagBits2KHRToString(0U)); + } + return str; +} + template <> std::string ToString(const VkComponentTypeKHR& value, ToStringFlags, uint32_t, uint32_t) { switch (value) { diff --git a/framework/generated/generated_vulkan_enum_to_string.h b/framework/generated/generated_vulkan_enum_to_string.h index e0705b5ded..add635b986 100644 --- a/framework/generated/generated_vulkan_enum_to_string.h +++ b/framework/generated/generated_vulkan_enum_to_string.h @@ -290,6 +290,10 @@ template <> std::string ToString(VkFlag template <> std::string ToString(const VkVideoEncodeTuningModeKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkVideoEncodeUsageFlagBitsKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +std::string VkBufferUsageFlagBits2KHRToString(const VkBufferUsageFlagBits2KHR value); +std::string VkBufferUsageFlags2KHRToString(VkFlags64 vkFlags); +std::string VkPipelineCreateFlagBits2KHRToString(const VkPipelineCreateFlagBits2KHR value); +std::string VkPipelineCreateFlags2KHRToString(VkFlags64 vkFlags); template <> std::string ToString(const VkComponentTypeKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkScopeKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkDebugReportFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); diff --git a/framework/generated/generated_vulkan_export_json_consumer.cpp b/framework/generated/generated_vulkan_export_json_consumer.cpp index 7dcc6451d8..f74144ee88 100644 --- a/framework/generated/generated_vulkan_export_json_consumer.cpp +++ b/framework/generated/generated_vulkan_export_json_consumer.cpp @@ -5549,6 +5549,69 @@ void VulkanExportJsonConsumer::Process_vkGetDeviceImageSparseMemoryRequirementsK WriteBlockEnd(); } +void VulkanExportJsonConsumer::Process_vkCmdBindIndexBuffer2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + format::HandleId buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdBindIndexBuffer2KHR"); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options_); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options_); + HandleToJson(args["buffer"], buffer, json_options_); + FieldToJson(args["offset"], offset, json_options_); + FieldToJson(args["size"], size, json_options_); + FieldToJson(args["indexType"], indexType, json_options_); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkGetRenderingAreaGranularityKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pRenderingAreaInfo, + StructPointerDecoder* pGranularity) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkGetRenderingAreaGranularityKHR"); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options_); + FieldToJson(args["pRenderingAreaInfo"], pRenderingAreaInfo, json_options_); + FieldToJson(args["pGranularity"], pGranularity, json_options_); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkGetDeviceImageSubresourceLayoutKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pLayout) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkGetDeviceImageSubresourceLayoutKHR"); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options_); + FieldToJson(args["pInfo"], pInfo, json_options_); + FieldToJson(args["pLayout"], pLayout, json_options_); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkGetImageSubresourceLayout2KHR( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId image, + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkGetImageSubresourceLayout2KHR"); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options_); + HandleToJson(args["image"], image, json_options_); + FieldToJson(args["pSubresource"], pSubresource, json_options_); + FieldToJson(args["pLayout"], pLayout, json_options_); + WriteBlockEnd(); +} + void VulkanExportJsonConsumer::Process_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( const ApiCallInfo& call_info, VkResult returnValue, @@ -7676,8 +7739,8 @@ void VulkanExportJsonConsumer::Process_vkGetImageSubresourceLayout2EXT( const ApiCallInfo& call_info, format::HandleId device, format::HandleId image, - StructPointerDecoder* pSubresource, - StructPointerDecoder* pLayout) + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) { nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkGetImageSubresourceLayout2EXT"); auto& args = jdata[NameArgs()]; diff --git a/framework/generated/generated_vulkan_export_json_consumer.h b/framework/generated/generated_vulkan_export_json_consumer.h index 806bf8fd3d..1376f09733 100644 --- a/framework/generated/generated_vulkan_export_json_consumer.h +++ b/framework/generated/generated_vulkan_export_json_consumer.h @@ -2406,6 +2406,33 @@ class VulkanExportJsonConsumer : public VulkanExportJsonConsumerBase PointerDecoder* pSparseMemoryRequirementCount, StructPointerDecoder* pSparseMemoryRequirements) override; + virtual void Process_vkCmdBindIndexBuffer2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + format::HandleId buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) override; + + virtual void Process_vkGetRenderingAreaGranularityKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pRenderingAreaInfo, + StructPointerDecoder* pGranularity) override; + + virtual void Process_vkGetDeviceImageSubresourceLayoutKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pLayout) override; + + virtual void Process_vkGetImageSubresourceLayout2KHR( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId image, + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) override; + virtual void Process_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( const ApiCallInfo& call_info, VkResult returnValue, @@ -3317,8 +3344,8 @@ class VulkanExportJsonConsumer : public VulkanExportJsonConsumerBase const ApiCallInfo& call_info, format::HandleId device, format::HandleId image, - StructPointerDecoder* pSubresource, - StructPointerDecoder* pLayout) override; + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) override; virtual void Process_vkReleaseSwapchainImagesEXT( const ApiCallInfo& call_info, diff --git a/framework/generated/generated_vulkan_feature_util.cpp b/framework/generated/generated_vulkan_feature_util.cpp index c3d4365f4b..d79e11a80e 100644 --- a/framework/generated/generated_vulkan_feature_util.cpp +++ b/framework/generated/generated_vulkan_feature_util.cpp @@ -1306,6 +1306,19 @@ void RemoveUnsupportedFeatures(VkPhysicalDevice physicalDevice, PFN_vkGetPhysica } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + { + const VkPhysicalDeviceMaintenance5FeaturesKHR* currentNext = reinterpret_cast(next); + VkPhysicalDeviceMaintenance5FeaturesKHR query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->maintenance5 == VK_TRUE) && (query.maintenance5 == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature maintenance5, which is not supported by the replay device, will not be enabled"); + const_cast(currentNext)->maintenance5 = VK_FALSE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: { const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* currentNext = reinterpret_cast(next); diff --git a/framework/generated/generated_vulkan_referenced_resource_consumer.cpp b/framework/generated/generated_vulkan_referenced_resource_consumer.cpp index c2c89935ce..3ba37e2c8f 100644 --- a/framework/generated/generated_vulkan_referenced_resource_consumer.cpp +++ b/framework/generated/generated_vulkan_referenced_resource_consumer.cpp @@ -1410,6 +1410,21 @@ void VulkanReferencedResourceConsumer::Process_vkCmdResolveImage2KHR( } } +void VulkanReferencedResourceConsumer::Process_vkCmdBindIndexBuffer2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + format::HandleId buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) +{ + GFXRECON_UNREFERENCED_PARAMETER(offset); + GFXRECON_UNREFERENCED_PARAMETER(size); + GFXRECON_UNREFERENCED_PARAMETER(indexType); + + GetTable().AddResourceToUser(commandBuffer, buffer); +} + void VulkanReferencedResourceConsumer::Process_vkCmdBindTransformFeedbackBuffersEXT( const ApiCallInfo& call_info, format::HandleId commandBuffer, diff --git a/framework/generated/generated_vulkan_referenced_resource_consumer.h b/framework/generated/generated_vulkan_referenced_resource_consumer.h index b5f5b19335..8c915af274 100644 --- a/framework/generated/generated_vulkan_referenced_resource_consumer.h +++ b/framework/generated/generated_vulkan_referenced_resource_consumer.h @@ -443,6 +443,14 @@ class VulkanReferencedResourceConsumer : public VulkanReferencedResourceConsumer format::HandleId commandBuffer, StructPointerDecoder* pResolveImageInfo) override; + virtual void Process_vkCmdBindIndexBuffer2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + format::HandleId buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) override; + virtual void Process_vkCmdBindTransformFeedbackBuffersEXT( const ApiCallInfo& call_info, format::HandleId commandBuffer, diff --git a/framework/generated/generated_vulkan_replay_consumer.cpp b/framework/generated/generated_vulkan_replay_consumer.cpp index 8bf5ebc46c..911377a204 100644 --- a/framework/generated/generated_vulkan_replay_consumer.cpp +++ b/framework/generated/generated_vulkan_replay_consumer.cpp @@ -5311,6 +5311,64 @@ void VulkanReplayConsumer::Process_vkGetDeviceImageSparseMemoryRequirementsKHR( if (pSparseMemoryRequirements->IsNull()) { SetOutputArrayCount(device, kDeviceArrayGetDeviceImageSparseMemoryRequirementsKHR, *out_pSparseMemoryRequirementCount, &VulkanObjectInfoTable::GetDeviceInfo); } } +void VulkanReplayConsumer::Process_vkCmdBindIndexBuffer2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + format::HandleId buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + VkBuffer in_buffer = MapHandle(buffer, &VulkanObjectInfoTable::GetBufferInfo); + + GetDeviceTable(in_commandBuffer)->CmdBindIndexBuffer2KHR(in_commandBuffer, in_buffer, offset, size, indexType); +} + +void VulkanReplayConsumer::Process_vkGetRenderingAreaGranularityKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pRenderingAreaInfo, + StructPointerDecoder* pGranularity) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + const VkRenderingAreaInfoKHR* in_pRenderingAreaInfo = pRenderingAreaInfo->GetPointer(); + VkExtent2D* out_pGranularity = pGranularity->IsNull() ? nullptr : pGranularity->AllocateOutputData(1); + + GetDeviceTable(in_device)->GetRenderingAreaGranularityKHR(in_device, in_pRenderingAreaInfo, out_pGranularity); +} + +void VulkanReplayConsumer::Process_vkGetDeviceImageSubresourceLayoutKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pLayout) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + const VkDeviceImageSubresourceInfoKHR* in_pInfo = pInfo->GetPointer(); + MapStructHandles(pInfo->GetMetaStructPointer(), GetObjectInfoTable()); + VkSubresourceLayout2KHR* out_pLayout = pLayout->IsNull() ? nullptr : pLayout->AllocateOutputData(1, { VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR, nullptr }); + InitializeOutputStructPNext(pLayout); + + GetDeviceTable(in_device)->GetDeviceImageSubresourceLayoutKHR(in_device, in_pInfo, out_pLayout); +} + +void VulkanReplayConsumer::Process_vkGetImageSubresourceLayout2KHR( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId image, + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + VkImage in_image = MapHandle(image, &VulkanObjectInfoTable::GetImageInfo); + const VkImageSubresource2KHR* in_pSubresource = pSubresource->GetPointer(); + VkSubresourceLayout2KHR* out_pLayout = pLayout->IsNull() ? nullptr : pLayout->AllocateOutputData(1, { VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR, nullptr }); + InitializeOutputStructPNext(pLayout); + + GetDeviceTable(in_device)->GetImageSubresourceLayout2KHR(in_device, in_image, in_pSubresource, out_pLayout); +} + void VulkanReplayConsumer::Process_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( const ApiCallInfo& call_info, VkResult returnValue, @@ -7247,13 +7305,13 @@ void VulkanReplayConsumer::Process_vkGetImageSubresourceLayout2EXT( const ApiCallInfo& call_info, format::HandleId device, format::HandleId image, - StructPointerDecoder* pSubresource, - StructPointerDecoder* pLayout) + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) { VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); VkImage in_image = MapHandle(image, &VulkanObjectInfoTable::GetImageInfo); - const VkImageSubresource2EXT* in_pSubresource = pSubresource->GetPointer(); - VkSubresourceLayout2EXT* out_pLayout = pLayout->IsNull() ? nullptr : pLayout->AllocateOutputData(1, { VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT, nullptr }); + const VkImageSubresource2KHR* in_pSubresource = pSubresource->GetPointer(); + VkSubresourceLayout2KHR* out_pLayout = pLayout->IsNull() ? nullptr : pLayout->AllocateOutputData(1, { VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR, nullptr }); InitializeOutputStructPNext(pLayout); GetDeviceTable(in_device)->GetImageSubresourceLayout2EXT(in_device, in_image, in_pSubresource, out_pLayout); @@ -10779,6 +10837,46 @@ void InitializeOutputStructPNext(StructPointerDecoder *decoder) output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -11814,16 +11912,6 @@ void InitializeOutputStructPNext(StructPointerDecoder *decoder) output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); diff --git a/framework/generated/generated_vulkan_replay_consumer.h b/framework/generated/generated_vulkan_replay_consumer.h index e7934f25b4..09a70a5472 100644 --- a/framework/generated/generated_vulkan_replay_consumer.h +++ b/framework/generated/generated_vulkan_replay_consumer.h @@ -2439,6 +2439,33 @@ class VulkanReplayConsumer : public VulkanReplayConsumerBase PointerDecoder* pSparseMemoryRequirementCount, StructPointerDecoder* pSparseMemoryRequirements) override; + virtual void Process_vkCmdBindIndexBuffer2KHR( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + format::HandleId buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) override; + + virtual void Process_vkGetRenderingAreaGranularityKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pRenderingAreaInfo, + StructPointerDecoder* pGranularity) override; + + virtual void Process_vkGetDeviceImageSubresourceLayoutKHR( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pLayout) override; + + virtual void Process_vkGetImageSubresourceLayout2KHR( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId image, + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) override; + virtual void Process_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( const ApiCallInfo& call_info, VkResult returnValue, @@ -3350,8 +3377,8 @@ class VulkanReplayConsumer : public VulkanReplayConsumerBase const ApiCallInfo& call_info, format::HandleId device, format::HandleId image, - StructPointerDecoder* pSubresource, - StructPointerDecoder* pLayout) override; + StructPointerDecoder* pSubresource, + StructPointerDecoder* pLayout) override; virtual void Process_vkReleaseSwapchainImagesEXT( const ApiCallInfo& call_info, diff --git a/framework/generated/generated_vulkan_struct_decoders.cpp b/framework/generated/generated_vulkan_struct_decoders.cpp index 1376b3d950..9ed2a10ce6 100644 --- a/framework/generated/generated_vulkan_struct_decoders.cpp +++ b/framework/generated/generated_vulkan_struct_decoders.cpp @@ -9895,6 +9895,145 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkTraceRa 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::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maintenance5)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_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::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentMultisampleCoverageAfterSampleCounting)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->earlyFragmentSampleMaskTestBeforeSampleCounting)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthStencilSwizzleOneSupport)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->polygonModePointSize)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictSinglePixelWideLinesUseParallelogram)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->nonStrictWideLinesUseParallelogram)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_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 DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -14061,40 +14200,6 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHostIma return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkSubresourceLayout2EXT* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkSubresourceLayout2EXT* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - 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_VkImageSubresource2EXT* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkImageSubresource2EXT* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - 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_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); diff --git a/framework/generated/generated_vulkan_struct_decoders.h b/framework/generated/generated_vulkan_struct_decoders.h index 2810ec52af..685be3899f 100644 --- a/framework/generated/generated_vulkan_struct_decoders.h +++ b/framework/generated/generated_vulkan_struct_decoders.h @@ -4978,6 +4978,83 @@ typedef Decoded_VkDeviceBufferMemoryRequirements Decoded_VkDeviceBufferMemoryReq typedef Decoded_VkDeviceImageMemoryRequirements Decoded_VkDeviceImageMemoryRequirementsKHR; +struct Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR +{ + using struct_type = VkPhysicalDeviceMaintenance5FeaturesKHR; + + VkPhysicalDeviceMaintenance5FeaturesKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR +{ + using struct_type = VkPhysicalDeviceMaintenance5PropertiesKHR; + + VkPhysicalDeviceMaintenance5PropertiesKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkRenderingAreaInfoKHR +{ + using struct_type = VkRenderingAreaInfoKHR; + + VkRenderingAreaInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + PointerDecoder pColorAttachmentFormats; +}; + +struct Decoded_VkImageSubresource2KHR +{ + using struct_type = VkImageSubresource2KHR; + + VkImageSubresource2KHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + Decoded_VkImageSubresource* imageSubresource{ nullptr }; +}; + +struct Decoded_VkDeviceImageSubresourceInfoKHR +{ + using struct_type = VkDeviceImageSubresourceInfoKHR; + + VkDeviceImageSubresourceInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pCreateInfo{ nullptr }; + StructPointerDecoder* pSubresource{ nullptr }; +}; + +struct Decoded_VkSubresourceLayout2KHR +{ + using struct_type = VkSubresourceLayout2KHR; + + VkSubresourceLayout2KHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + Decoded_VkSubresourceLayout* subresourceLayout{ nullptr }; +}; + +struct Decoded_VkPipelineCreateFlags2CreateInfoKHR +{ + using struct_type = VkPipelineCreateFlags2CreateInfoKHR; + + VkPipelineCreateFlags2CreateInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkBufferUsageFlags2CreateInfoKHR +{ + using struct_type = VkBufferUsageFlags2CreateInfoKHR; + + VkBufferUsageFlags2CreateInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + struct Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { using struct_type = VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; @@ -7255,25 +7332,9 @@ struct Decoded_VkHostImageCopyDevicePerformanceQueryEXT PNextNode* pNext{ nullptr }; }; -struct Decoded_VkSubresourceLayout2EXT -{ - using struct_type = VkSubresourceLayout2EXT; - - VkSubresourceLayout2EXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - Decoded_VkSubresourceLayout* subresourceLayout{ nullptr }; -}; - -struct Decoded_VkImageSubresource2EXT -{ - using struct_type = VkImageSubresource2EXT; - - VkImageSubresource2EXT* decoded_value{ nullptr }; +typedef Decoded_VkSubresourceLayout2KHR Decoded_VkSubresourceLayout2EXT; - PNextNode* pNext{ nullptr }; - Decoded_VkImageSubresource* imageSubresource{ nullptr }; -}; +typedef Decoded_VkImageSubresource2KHR Decoded_VkImageSubresource2EXT; struct Decoded_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT { diff --git a/framework/generated/generated_vulkan_struct_decoders_forward.h b/framework/generated/generated_vulkan_struct_decoders_forward.h index ea62ea5bb3..3ec8ebbc50 100644 --- a/framework/generated/generated_vulkan_struct_decoders_forward.h +++ b/framework/generated/generated_vulkan_struct_decoders_forward.h @@ -1089,6 +1089,24 @@ 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); +struct Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR; +struct Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR; +struct Decoded_VkRenderingAreaInfoKHR; +struct Decoded_VkImageSubresource2KHR; +struct Decoded_VkDeviceImageSubresourceInfoKHR; +struct Decoded_VkSubresourceLayout2KHR; +struct Decoded_VkPipelineCreateFlags2CreateInfoKHR; +struct Decoded_VkBufferUsageFlags2CreateInfoKHR; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderingAreaInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageSubresource2KHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceImageSubresourceInfoKHR* wrapper); +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); + struct Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* wrapper); @@ -1719,8 +1737,6 @@ struct Decoded_VkCopyImageToImageInfoEXT; struct Decoded_VkHostImageLayoutTransitionInfoEXT; struct Decoded_VkSubresourceHostMemcpySizeEXT; struct Decoded_VkHostImageCopyDevicePerformanceQueryEXT; -struct Decoded_VkSubresourceLayout2EXT; -struct Decoded_VkImageSubresource2EXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostImageCopyFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceHostImageCopyPropertiesEXT* wrapper); @@ -1732,8 +1748,6 @@ 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 DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkSubresourceLayout2EXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageSubresource2EXT* wrapper); struct Decoded_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; diff --git a/framework/generated/generated_vulkan_struct_encoders.cpp b/framework/generated/generated_vulkan_struct_encoders.cpp index 454280e7c7..3b1cadb845 100644 --- a/framework/generated/generated_vulkan_struct_encoders.cpp +++ b/framework/generated/generated_vulkan_struct_encoders.cpp @@ -5007,6 +5007,72 @@ void EncodeStruct(ParameterEncoder* encoder, const VkTraceRaysIndirectCommand2KH encoder->EncodeUInt32Value(value.depth); } +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceMaintenance5FeaturesKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.maintenance5); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceMaintenance5PropertiesKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.earlyFragmentMultisampleCoverageAfterSampleCounting); + encoder->EncodeVkBool32Value(value.earlyFragmentSampleMaskTestBeforeSampleCounting); + encoder->EncodeVkBool32Value(value.depthStencilSwizzleOneSupport); + encoder->EncodeVkBool32Value(value.polygonModePointSize); + encoder->EncodeVkBool32Value(value.nonStrictSinglePixelWideLinesUseParallelogram); + encoder->EncodeVkBool32Value(value.nonStrictWideLinesUseParallelogram); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkRenderingAreaInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.viewMask); + encoder->EncodeUInt32Value(value.colorAttachmentCount); + encoder->EncodeEnumArray(value.pColorAttachmentFormats, value.colorAttachmentCount); + encoder->EncodeEnumValue(value.depthAttachmentFormat); + encoder->EncodeEnumValue(value.stencilAttachmentFormat); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkImageSubresource2KHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + EncodeStruct(encoder, value.imageSubresource); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkDeviceImageSubresourceInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + EncodeStructPtr(encoder, value.pCreateInfo); + EncodeStructPtr(encoder, value.pSubresource); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkSubresourceLayout2KHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + EncodeStruct(encoder, value.subresourceLayout); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkPipelineCreateFlags2CreateInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlags64Value(value.flags); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkBufferUsageFlags2CreateInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlags64Value(value.usage); +} + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& value) { encoder->EncodeEnumValue(value.sType); @@ -7080,20 +7146,6 @@ void EncodeStruct(ParameterEncoder* encoder, const VkHostImageCopyDevicePerforma encoder->EncodeVkBool32Value(value.identicalMemoryLayout); } -void EncodeStruct(ParameterEncoder* encoder, const VkSubresourceLayout2EXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - EncodeStruct(encoder, value.subresourceLayout); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkImageSubresource2EXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - EncodeStruct(encoder, value.imageSubresource); -} - void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& value) { encoder->EncodeEnumValue(value.sType); diff --git a/framework/generated/generated_vulkan_struct_encoders.h b/framework/generated/generated_vulkan_struct_encoders.h index 9bfb9c7679..fd736fab8e 100644 --- a/framework/generated/generated_vulkan_struct_encoders.h +++ b/framework/generated/generated_vulkan_struct_encoders.h @@ -571,6 +571,15 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceWorkgroupMemo void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkTraceRaysIndirectCommand2KHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceMaintenance5FeaturesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceMaintenance5PropertiesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkRenderingAreaInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkImageSubresource2KHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkDeviceImageSubresourceInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkSubresourceLayout2KHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPipelineCreateFlags2CreateInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkBufferUsageFlags2CreateInfoKHR& value); + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkCooperativeMatrixPropertiesKHR& value); @@ -891,8 +900,6 @@ void EncodeStruct(ParameterEncoder* encoder, const VkCopyImageToImageInfoEXT& va void EncodeStruct(ParameterEncoder* encoder, const VkHostImageLayoutTransitionInfoEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkSubresourceHostMemcpySizeEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkHostImageCopyDevicePerformanceQueryEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkSubresourceLayout2EXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkImageSubresource2EXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& value); diff --git a/framework/generated/generated_vulkan_struct_handle_mappers.cpp b/framework/generated/generated_vulkan_struct_handle_mappers.cpp index 4ea4ae045b..f668d06e92 100644 --- a/framework/generated/generated_vulkan_struct_handle_mappers.cpp +++ b/framework/generated/generated_vulkan_struct_handle_mappers.cpp @@ -1175,6 +1175,14 @@ void MapStructHandles(Decoded_VkVideoEncodeSessionParametersGetInfoKHR* wrapper, } } +void MapStructHandles(Decoded_VkDeviceImageSubresourceInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if (wrapper != nullptr) + { + MapStructArrayHandles(wrapper->pCreateInfo->GetMetaStructPointer(), 1, object_info_table); + } +} + void MapStructHandles(Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) { if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) diff --git a/framework/generated/generated_vulkan_struct_handle_mappers.h b/framework/generated/generated_vulkan_struct_handle_mappers.h index 0c4718cabb..fe2aa8c2c6 100644 --- a/framework/generated/generated_vulkan_struct_handle_mappers.h +++ b/framework/generated/generated_vulkan_struct_handle_mappers.h @@ -249,6 +249,8 @@ void MapStructHandles(Decoded_VkVideoEncodeInfoKHR* wrapper, const VulkanObjectI void MapStructHandles(Decoded_VkVideoEncodeSessionParametersGetInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table); +void MapStructHandles(Decoded_VkDeviceImageSubresourceInfoKHR* wrapper, const VulkanObjectInfoTable& object_info_table); + void MapStructHandles(Decoded_VkDebugMarkerObjectNameInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); void MapStructHandles(Decoded_VkDebugMarkerObjectTagInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); diff --git a/framework/generated/generated_vulkan_struct_handle_wrappers.cpp b/framework/generated/generated_vulkan_struct_handle_wrappers.cpp index ee73d7c44d..d774837dc6 100644 --- a/framework/generated/generated_vulkan_struct_handle_wrappers.cpp +++ b/framework/generated/generated_vulkan_struct_handle_wrappers.cpp @@ -826,6 +826,14 @@ void UnwrapStructHandles(VkVideoEncodeSessionParametersGetInfoKHR* value, Handle } } +void UnwrapStructHandles(VkDeviceImageSubresourceInfoKHR* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + value->pCreateInfo = UnwrapStructPtrHandles(value->pCreateInfo, unwrap_memory); + } +} + void UnwrapStructHandles(VkDebugMarkerObjectNameInfoEXT* value, HandleUnwrapMemory* unwrap_memory) { if (value != nullptr) @@ -1775,6 +1783,18 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; diff --git a/framework/generated/generated_vulkan_struct_handle_wrappers.h b/framework/generated/generated_vulkan_struct_handle_wrappers.h index f8241b89e4..92edc202e6 100644 --- a/framework/generated/generated_vulkan_struct_handle_wrappers.h +++ b/framework/generated/generated_vulkan_struct_handle_wrappers.h @@ -249,6 +249,8 @@ void UnwrapStructHandles(VkVideoEncodeInfoKHR* value, HandleUnwrapMemory* unwrap void UnwrapStructHandles(VkVideoEncodeSessionParametersGetInfoKHR* value, HandleUnwrapMemory* unwrap_memory); +void UnwrapStructHandles(VkDeviceImageSubresourceInfoKHR* value, HandleUnwrapMemory* unwrap_memory); + void UnwrapStructHandles(VkDebugMarkerObjectNameInfoEXT* value, HandleUnwrapMemory* unwrap_memory); void UnwrapStructHandles(VkDebugMarkerObjectTagInfoEXT* value, HandleUnwrapMemory* unwrap_memory); diff --git a/framework/generated/generated_vulkan_struct_to_json.cpp b/framework/generated/generated_vulkan_struct_to_json.cpp index 056d39ce4c..317200dfcc 100644 --- a/framework/generated/generated_vulkan_struct_to_json.cpp +++ b/framework/generated/generated_vulkan_struct_to_json.cpp @@ -7325,6 +7325,112 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkTraceRaysIndirec } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceMaintenance5FeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR& meta_struct = *data; + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["maintenance5"] = static_cast(decoded_value.maintenance5); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceMaintenance5PropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR& meta_struct = *data; + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["earlyFragmentMultisampleCoverageAfterSampleCounting"] = static_cast(decoded_value.earlyFragmentMultisampleCoverageAfterSampleCounting); + jdata["earlyFragmentSampleMaskTestBeforeSampleCounting"] = static_cast(decoded_value.earlyFragmentSampleMaskTestBeforeSampleCounting); + jdata["depthStencilSwizzleOneSupport"] = static_cast(decoded_value.depthStencilSwizzleOneSupport); + jdata["polygonModePointSize"] = static_cast(decoded_value.polygonModePointSize); + jdata["nonStrictSinglePixelWideLinesUseParallelogram"] = static_cast(decoded_value.nonStrictSinglePixelWideLinesUseParallelogram); + jdata["nonStrictWideLinesUseParallelogram"] = static_cast(decoded_value.nonStrictWideLinesUseParallelogram); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderingAreaInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkRenderingAreaInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkRenderingAreaInfoKHR& meta_struct = *data; + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["viewMask"], decoded_value.viewMask, options); + FieldToJson(jdata["colorAttachmentCount"], decoded_value.colorAttachmentCount, options); + FieldToJson(jdata["pColorAttachmentFormats"], meta_struct.pColorAttachmentFormats, options); + FieldToJson(jdata["depthAttachmentFormat"], decoded_value.depthAttachmentFormat, options); + FieldToJson(jdata["stencilAttachmentFormat"], decoded_value.stencilAttachmentFormat, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageSubresource2KHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkImageSubresource2KHR& decoded_value = *data->decoded_value; + const Decoded_VkImageSubresource2KHR& meta_struct = *data; + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["imageSubresource"], meta_struct.imageSubresource, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDeviceImageSubresourceInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkDeviceImageSubresourceInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkDeviceImageSubresourceInfoKHR& meta_struct = *data; + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["pCreateInfo"], meta_struct.pCreateInfo, options); + FieldToJson(jdata["pSubresource"], meta_struct.pSubresource, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSubresourceLayout2KHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkSubresourceLayout2KHR& decoded_value = *data->decoded_value; + const Decoded_VkSubresourceLayout2KHR& meta_struct = *data; + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["subresourceLayout"], meta_struct.subresourceLayout, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineCreateFlags2CreateInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPipelineCreateFlags2CreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineCreateFlags2CreateInfoKHR& meta_struct = *data; + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkPipelineCreateFlags2KHR_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBufferUsageFlags2CreateInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkBufferUsageFlags2CreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkBufferUsageFlags2CreateInfoKHR& meta_struct = *data; + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkBufferUsageFlags2KHR_t(),jdata["usage"], decoded_value.usage, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -10568,30 +10674,6 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkHostImageCopyDev } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSubresourceLayout2EXT* data, const JsonOptions& options) -{ - if (data && data->decoded_value) - { - const VkSubresourceLayout2EXT& decoded_value = *data->decoded_value; - const Decoded_VkSubresourceLayout2EXT& meta_struct = *data; - FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["subresourceLayout"], meta_struct.subresourceLayout, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); - } -} - -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageSubresource2EXT* data, const JsonOptions& options) -{ - if (data && data->decoded_value) - { - const VkImageSubresource2EXT& decoded_value = *data->decoded_value; - const Decoded_VkImageSubresource2EXT& meta_struct = *data; - FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["imageSubresource"], meta_struct.imageSubresource, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); - } -} - void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -14912,6 +14994,34 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); diff --git a/framework/generated/generated_vulkan_struct_to_json.h b/framework/generated/generated_vulkan_struct_to_json.h index 06c0273897..05b99c15dc 100644 --- a/framework/generated/generated_vulkan_struct_to_json.h +++ b/framework/generated/generated_vulkan_struct_to_json.h @@ -505,6 +505,14 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceSh void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkTraceRaysIndirectCommand2KHR* data, const JsonOptions& options = JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance5FeaturesKHR* data, const JsonOptions& options = JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMaintenance5PropertiesKHR* data, const JsonOptions& options = JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderingAreaInfoKHR* data, const JsonOptions& options = JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageSubresource2KHR* data, const JsonOptions& options = JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDeviceImageSubresourceInfoKHR* data, const JsonOptions& options = JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSubresourceLayout2KHR* data, const JsonOptions& options = JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineCreateFlags2CreateInfoKHR* data, const JsonOptions& options = JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBufferUsageFlags2CreateInfoKHR* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCooperativeMatrixPropertiesKHR* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* data, const JsonOptions& options = JsonOptions()); @@ -739,8 +747,6 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCopyImageToImage void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkHostImageLayoutTransitionInfoEXT* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSubresourceHostMemcpySizeEXT* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkHostImageCopyDevicePerformanceQueryEXT* data, const JsonOptions& options = JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSubresourceLayout2EXT* data, const JsonOptions& options = JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageSubresource2EXT* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSurfacePresentModeEXT* data, const JsonOptions& options = JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSurfacePresentScalingCapabilitiesEXT* data, const JsonOptions& options = JsonOptions()); diff --git a/framework/generated/vulkan_generators/base_generator.py b/framework/generated/vulkan_generators/base_generator.py index 557a023842..66d9e3f0aa 100644 --- a/framework/generated/vulkan_generators/base_generator.py +++ b/framework/generated/vulkan_generators/base_generator.py @@ -76,7 +76,8 @@ def _make_re_string(list, default=None): "VK_EXT_descriptor_buffer", "VK_NV_copy_memory_indirect", "VK_NV_memory_decompression", - "VK_QNX_external_memory_screen_buffer" + "VK_QNX_external_memory_screen_buffer", + "VK_AMDX_shader_enqueue" ] _supported_subsets = [ @@ -111,7 +112,13 @@ def BitsEnumToFlagsTypedef(enum): flags = removesuffix(enum, 'Bits2') if flags != enum: flags = flags + 's2' + return flags # Gods preserve us from Bits 3, 4, 5, etc. + # It might have more extension suffix. + flags = removesuffix(enum, 'Bits2KHR') + if flags != enum: + flags = flags + 's2KHR' + return flags return flags class ValueInfo(): diff --git a/layer/trace_layer.cpp b/layer/trace_layer.cpp index 1092fefe8c..56b60d4f2c 100644 --- a/layer/trace_layer.cpp +++ b/layer/trace_layer.cpp @@ -78,7 +78,8 @@ const char* const kUnsupportedDeviceExtensions[] = { VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME, VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME, VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME, - VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME + VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME, + VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME }; static void remove_extensions(std::vector& extensionProps,