From d02dad74ef236da77a229c54d058d3ee5f7001c6 Mon Sep 17 00:00:00 2001 From: locke-lunarg Date: Tue, 12 Dec 2023 14:05:57 -0700 Subject: [PATCH] Update headers to 1.3.273 Skip: VK_NV_cuda_kernel_launch --- external/Vulkan-Headers | 2 +- framework/decode/vulkan_object_info.h | 1 + framework/format/api_call_id.h | 2 + .../generated_decode_pnext_struct.cpp | 60 ++- .../generated_encode_pnext_struct.cpp | 45 +- .../generated/generated_layer_func_table.h | 2 + .../generated_vulkan_api_call_encoders.cpp | 96 ++++- .../generated_vulkan_api_call_encoders.h | 16 +- .../generated/generated_vulkan_consumer.h | 20 +- .../generated/generated_vulkan_decoder.cpp | 58 ++- .../generated/generated_vulkan_decoder.h | 4 + .../generated_vulkan_dispatch_table.h | 10 +- .../generated_vulkan_enum_to_json.cpp | 162 +++++++- .../generated/generated_vulkan_enum_to_json.h | 7 +- .../generated_vulkan_enum_to_string.cpp | 81 +++- .../generated_vulkan_enum_to_string.h | 5 +- .../generated_vulkan_feature_util.cpp | 89 +++- .../generated_vulkan_json_consumer.cpp | 42 +- .../generated_vulkan_json_consumer.h | 20 +- .../generated_vulkan_replay_consumer.cpp | 133 +++++- .../generated_vulkan_replay_consumer.h | 20 +- .../generated_vulkan_struct_decoders.cpp | 338 ++++++++++++--- .../generated_vulkan_struct_decoders.h | 194 +++++++-- ...generated_vulkan_struct_decoders_forward.h | 56 ++- .../generated_vulkan_struct_encoders.cpp | 156 +++++-- .../generated_vulkan_struct_encoders.h | 28 +- ...generated_vulkan_struct_handle_mappers.cpp | 11 + .../generated_vulkan_struct_handle_mappers.h | 2 + ...enerated_vulkan_struct_handle_wrappers.cpp | 55 ++- .../generated_vulkan_struct_handle_wrappers.h | 2 + .../generated_vulkan_struct_to_json.cpp | 387 +++++++++++++++--- .../generated_vulkan_struct_to_json.h | 21 +- .../vulkan_generators/base_generator.py | 1 + layer/trace_layer.cpp | 25 +- 34 files changed, 1817 insertions(+), 334 deletions(-) diff --git a/external/Vulkan-Headers b/external/Vulkan-Headers index 07ff4233bc..41263fc5aa 160000 --- a/external/Vulkan-Headers +++ b/external/Vulkan-Headers @@ -1 +1 @@ -Subproject commit 07ff4233bc69e573ae0a6b4b48ad16451ac4e37f +Subproject commit 41263fc5aa994b8eafaca946583bfcceca8ca419 diff --git a/framework/decode/vulkan_object_info.h b/framework/decode/vulkan_object_info.h index 60a0a0b13d..614e387114 100644 --- a/framework/decode/vulkan_object_info.h +++ b/framework/decode/vulkan_object_info.h @@ -96,6 +96,7 @@ enum DeviceArrayIndices : uint32_t kDeviceArrayGetDeviceImageSparseMemoryRequirements = 4, kDeviceArrayGetEncodedVideoSessionParametersKHR = 5, kPhysicalDeviceArrayGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 6, + kPhysicalDeviceArrayGetPhysicalDeviceCalibrateableTimeDomainsKHR = 7, // Aliases for extensions functions that were promoted to core. kDeviceArrayGetImageSparseMemoryRequirements2KHR = kDeviceArrayGetImageSparseMemoryRequirements2, diff --git a/framework/format/api_call_id.h b/framework/format/api_call_id.h index 523c57df18..9d2d51be3d 100644 --- a/framework/format/api_call_id.h +++ b/framework/format/api_call_id.h @@ -700,6 +700,8 @@ enum ApiCallId : uint32_t ApiCall_vkGetDeviceImageSubresourceLayoutKHR = MakeApiCallId(ApiFamily_Vulkan, 0x12da), ApiCall_vkGetImageSubresourceLayout2KHR = MakeApiCallId(ApiFamily_Vulkan, 0x12db), ApiCall_vkFrameBoundaryANDROID = MakeApiCallId(ApiFamily_Vulkan, 0x12dc), + ApiCall_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = MakeApiCallId(ApiFamily_Vulkan, 0x12dd), + ApiCall_vkGetCalibratedTimestampsKHR = MakeApiCallId(ApiFamily_Vulkan, 0x12de), ApiCall_VulkanLast, diff --git a/framework/generated/generated_decode_pnext_struct.cpp b/framework/generated/generated_decode_pnext_struct.cpp index c36274a503..df830082b6 100644 --- a/framework/generated/generated_decode_pnext_struct.cpp +++ b/framework/generated/generated_decode_pnext_struct.cpp @@ -802,6 +802,18 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -1042,6 +1054,10 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -1202,14 +1218,6 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: - (*pNext) = DecodeAllocator::Allocate>(); - bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); - break; case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -1762,6 +1770,10 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -1778,6 +1790,18 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -1798,6 +1822,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_RENDER_PASS_STRIPED_FEATURES_ARM: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -1962,6 +2002,10 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: (*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 b0102750bc..b79abd3f0e 100644 --- a/framework/generated/generated_encode_pnext_struct.cpp +++ b/framework/generated/generated_encode_pnext_struct.cpp @@ -623,6 +623,15 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -803,6 +812,9 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -923,12 +935,6 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: EncodeStructPtr(encoder, reinterpret_cast(base)); break; - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: - EncodeStructPtr(encoder, reinterpret_cast(base)); - break; case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -1343,6 +1349,9 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -1355,6 +1364,15 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -1370,6 +1388,18 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -1493,6 +1523,9 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: 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 576bf067f9..16f9bc0c7f 100644 --- a/framework/generated/generated_layer_func_table.h +++ b/framework/generated/generated_layer_func_table.h @@ -410,6 +410,8 @@ const std::unordered_map func_table = { { "vkGetDeviceImageSubresourceLayoutKHR", reinterpret_cast(encode::GetDeviceImageSubresourceLayoutKHR) }, { "vkGetImageSubresourceLayout2KHR", reinterpret_cast(encode::GetImageSubresourceLayout2KHR) }, { "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", reinterpret_cast(encode::GetPhysicalDeviceCooperativeMatrixPropertiesKHR) }, + { "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", reinterpret_cast(encode::GetPhysicalDeviceCalibrateableTimeDomainsKHR) }, + { "vkGetCalibratedTimestampsKHR", reinterpret_cast(encode::GetCalibratedTimestampsKHR) }, { "vkFrameBoundaryANDROID", reinterpret_cast(encode::FrameBoundaryANDROID) }, { "vkCreateDebugReportCallbackEXT", reinterpret_cast(encode::CreateDebugReportCallbackEXT) }, { "vkDestroyDebugReportCallbackEXT", reinterpret_cast(encode::DestroyDebugReportCallbackEXT) }, diff --git a/framework/generated/generated_vulkan_api_call_encoders.cpp b/framework/generated/generated_vulkan_api_call_encoders.cpp index 24dc3b1b83..6489858702 100644 --- a/framework/generated/generated_vulkan_api_call_encoders.cpp +++ b/framework/generated/generated_vulkan_api_call_encoders.cpp @@ -14232,6 +14232,98 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR( return result; } +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + bool omit_output_data = false; + + CustomEncoderPreCall::Dispatch(manager, physicalDevice, pTimeDomainCount, pTimeDomains); + + VkResult result = GetInstanceTable(physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains); + if (result < 0) + { + omit_output_data = true; + } + + auto encoder = manager->BeginApiCallCapture(format::ApiCallId::ApiCall_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR); + if (encoder) + { + encoder->EncodeHandleValue(physicalDevice); + encoder->EncodeUInt32Ptr(pTimeDomainCount, omit_output_data); + encoder->EncodeEnumArray(pTimeDomains, (pTimeDomainCount != nullptr) ? (*pTimeDomainCount) : 0, omit_output_data); + encoder->EncodeEnumValue(result); + manager->EndApiCallCapture(); + } + + CustomEncoderPostCall::Dispatch(manager, result, physicalDevice, pTimeDomainCount, pTimeDomains); + + return result; +} + +VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + bool omit_output_data = false; + + CustomEncoderPreCall::Dispatch(manager, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + + VkResult result = GetDeviceTable(device)->GetCalibratedTimestampsKHR(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + if (result < 0) + { + omit_output_data = true; + } + + auto encoder = manager->BeginApiCallCapture(format::ApiCallId::ApiCall_vkGetCalibratedTimestampsKHR); + if (encoder) + { + encoder->EncodeHandleValue(device); + encoder->EncodeUInt32Value(timestampCount); + EncodeStructArray(encoder, pTimestampInfos, timestampCount); + encoder->EncodeUInt64Array(pTimestamps, timestampCount, omit_output_data); + encoder->EncodeUInt64Ptr(pMaxDeviation, omit_output_data); + encoder->EncodeEnumValue(result); + manager->EndApiCallCapture(); + } + + CustomEncoderPostCall::Dispatch(manager, result, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + + return result; +} + VKAPI_ATTR void VKAPI_CALL FrameBoundaryANDROID( VkDevice device, VkSemaphore semaphore, @@ -17543,7 +17635,7 @@ VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, - VkTimeDomainEXT* pTimeDomains) + VkTimeDomainKHR* pTimeDomains) { VulkanCaptureManager* manager = VulkanCaptureManager::Get(); GFXRECON_ASSERT(manager != nullptr); @@ -17587,7 +17679,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, - const VkCalibratedTimestampInfoEXT* pTimestampInfos, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) { diff --git a/framework/generated/generated_vulkan_api_call_encoders.h b/framework/generated/generated_vulkan_api_call_encoders.h index dfbbc74574..3acbb93c9e 100644 --- a/framework/generated/generated_vulkan_api_call_encoders.h +++ b/framework/generated/generated_vulkan_api_call_encoders.h @@ -1945,6 +1945,18 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR( uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties); +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains); + +VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsKHR( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); + VKAPI_ATTR void VKAPI_CALL FrameBoundaryANDROID( VkDevice device, VkSemaphore semaphore, @@ -2414,12 +2426,12 @@ VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, - VkTimeDomainEXT* pTimeDomains); + VkTimeDomainKHR* pTimeDomains); VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( VkDevice device, uint32_t timestampCount, - const VkCalibratedTimestampInfoEXT* pTimestampInfos, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); diff --git a/framework/generated/generated_vulkan_consumer.h b/framework/generated/generated_vulkan_consumer.h index a702336771..199f4df6c7 100644 --- a/framework/generated/generated_vulkan_consumer.h +++ b/framework/generated/generated_vulkan_consumer.h @@ -2473,6 +2473,22 @@ class VulkanConsumer : public VulkanConsumerBase PointerDecoder* pPropertyCount, StructPointerDecoder* pProperties) {} + virtual void Process_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId physicalDevice, + PointerDecoder* pTimeDomainCount, + PointerDecoder* pTimeDomains) {} + + virtual void Process_vkGetCalibratedTimestampsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + uint32_t timestampCount, + StructPointerDecoder* pTimestampInfos, + PointerDecoder* pTimestamps, + PointerDecoder* pMaxDeviation) {} + virtual void Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, @@ -3072,14 +3088,14 @@ class VulkanConsumer : public VulkanConsumerBase VkResult returnValue, format::HandleId physicalDevice, PointerDecoder* pTimeDomainCount, - PointerDecoder* pTimeDomains) {} + PointerDecoder* pTimeDomains) {} virtual void Process_vkGetCalibratedTimestampsEXT( const ApiCallInfo& call_info, VkResult returnValue, format::HandleId device, uint32_t timestampCount, - StructPointerDecoder* pTimestampInfos, + StructPointerDecoder* pTimestampInfos, PointerDecoder* pTimestamps, PointerDecoder* pMaxDeviation) {} diff --git a/framework/generated/generated_vulkan_decoder.cpp b/framework/generated/generated_vulkan_decoder.cpp index 012ef329c8..37d62eb07f 100644 --- a/framework/generated/generated_vulkan_decoder.cpp +++ b/framework/generated/generated_vulkan_decoder.cpp @@ -7699,6 +7699,54 @@ size_t VulkanDecoder::Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(c return bytes_read; } +size_t VulkanDecoder::Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId physicalDevice; + PointerDecoder pTimeDomainCount; + PointerDecoder pTimeDomains; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); + bytes_read += pTimeDomainCount.DecodeUInt32((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pTimeDomains.DecodeEnum((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(call_info, return_value, physicalDevice, &pTimeDomainCount, &pTimeDomains); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkGetCalibratedTimestampsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + uint32_t timestampCount; + StructPointerDecoder pTimestampInfos; + PointerDecoder pTimestamps; + PointerDecoder pMaxDeviation; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), ×tampCount); + bytes_read += pTimestampInfos.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pTimestamps.DecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMaxDeviation.DecodeUInt64((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &return_value); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkGetCalibratedTimestampsKHR(call_info, return_value, device, timestampCount, &pTimestampInfos, &pTimestamps, &pMaxDeviation); + } + + return bytes_read; +} + size_t VulkanDecoder::Decode_vkFrameBoundaryANDROID(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) { size_t bytes_read = 0; @@ -9541,7 +9589,7 @@ size_t VulkanDecoder::Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(cons format::HandleId physicalDevice; PointerDecoder pTimeDomainCount; - PointerDecoder pTimeDomains; + PointerDecoder pTimeDomains; VkResult return_value; bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &physicalDevice); @@ -9563,7 +9611,7 @@ size_t VulkanDecoder::Decode_vkGetCalibratedTimestampsEXT(const ApiCallInfo& cal format::HandleId device; uint32_t timestampCount; - StructPointerDecoder pTimestampInfos; + StructPointerDecoder pTimestampInfos; PointerDecoder pTimestamps; PointerDecoder pMaxDeviation; VkResult return_value; @@ -14297,6 +14345,12 @@ void VulkanDecoder::DecodeFunctionCall(format::ApiCallId call_id, case format::ApiCallId::ApiCall_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR: Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(call_info, parameter_buffer, buffer_size); break; + case format::ApiCallId::ApiCall_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR: + Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkGetCalibratedTimestampsKHR: + Decode_vkGetCalibratedTimestampsKHR(call_info, parameter_buffer, buffer_size); + break; case format::ApiCallId::ApiCall_vkFrameBoundaryANDROID: Decode_vkFrameBoundaryANDROID(call_info, parameter_buffer, buffer_size); break; diff --git a/framework/generated/generated_vulkan_decoder.h b/framework/generated/generated_vulkan_decoder.h index 5deb49b365..9e5a274090 100644 --- a/framework/generated/generated_vulkan_decoder.h +++ b/framework/generated/generated_vulkan_decoder.h @@ -761,6 +761,10 @@ class VulkanDecoder : public VulkanDecoderBase size_t Decode_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + size_t Decode_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkGetCalibratedTimestampsKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + size_t Decode_vkFrameBoundaryANDROID(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); size_t Decode_vkCreateDebugReportCallbackEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); diff --git a/framework/generated/generated_vulkan_dispatch_table.h b/framework/generated/generated_vulkan_dispatch_table.h index ad2ce37af4..a699cf4e8d 100644 --- a/framework/generated/generated_vulkan_dispatch_table.h +++ b/framework/generated/generated_vulkan_dispatch_table.h @@ -136,6 +136,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(VkPhysical static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice, uint32_t*, VkPhysicalDeviceFragmentShadingRateKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetPhysicalDeviceFragmentShadingRatesKHR was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR*, VkVideoEncodeQualityLevelPropertiesKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice, uint32_t*, VkCooperativeMatrixPropertiesKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR was called, resulting in no-op behavior."); return VK_SUCCESS; } +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice, uint32_t*, VkTimeDomainKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetPhysicalDeviceCalibrateableTimeDomainsKHR was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(VkInstance, const VkDebugReportCallbackCreateInfoEXT*, const VkAllocationCallbacks*, VkDebugReportCallbackEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCreateDebugReportCallbackEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance, VkDebugReportCallbackEXT, const VkAllocationCallbacks*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDestroyDebugReportCallbackEXT was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance, VkDebugReportFlagsEXT, VkDebugReportObjectTypeEXT, uint64_t, size_t, int32_t, const char*, const char*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDebugReportMessageEXT was called, resulting in no-op behavior."); } @@ -154,7 +155,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(VkInstance, c static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(VkInstance, VkDebugUtilsMessengerEXT, const VkAllocationCallbacks*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDestroyDebugUtilsMessengerEXT was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(VkInstance, VkDebugUtilsMessageSeverityFlagBitsEXT, VkDebugUtilsMessageTypeFlagsEXT, const VkDebugUtilsMessengerCallbackDataEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkSubmitDebugUtilsMessageEXT was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice, VkSampleCountFlagBits, VkMultisamplePropertiesEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetPhysicalDeviceMultisamplePropertiesEXT was called, resulting in no-op behavior."); } -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice, uint32_t*, VkTimeDomainEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetPhysicalDeviceCalibrateableTimeDomainsEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice, uint32_t*, VkTimeDomainKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetPhysicalDeviceCalibrateableTimeDomainsEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(VkInstance, const VkImagePipeSurfaceCreateInfoFUCHSIA*, const VkAllocationCallbacks*, VkSurfaceKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCreateImagePipeSurfaceFUCHSIA was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(VkInstance, const VkMetalSurfaceCreateInfoEXT*, const VkAllocationCallbacks*, VkSurfaceKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCreateMetalSurfaceEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice, uint32_t*, VkPhysicalDeviceToolProperties*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetPhysicalDeviceToolPropertiesEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } @@ -459,6 +460,7 @@ static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer2KHR(VkCommandBuffer, VkBuff 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 GetCalibratedTimestampsKHR(VkDevice, uint32_t, const VkCalibratedTimestampInfoKHR*, uint64_t*, uint64_t*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetCalibratedTimestampsKHR was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR void VKAPI_CALL FrameBoundaryANDROID(VkDevice, VkSemaphore, VkImage) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkFrameBoundaryANDROID was called, resulting in no-op behavior."); } static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice, const VkDebugMarkerObjectTagInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDebugMarkerSetObjectTagEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice, const VkDebugMarkerObjectNameInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDebugMarkerSetObjectNameEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } @@ -522,7 +524,7 @@ static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(VkC static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(VkDevice, VkPipeline, uint32_t) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCompileDeferredNV was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT(VkDevice, VkExternalMemoryHandleTypeFlagBits, const void*, VkMemoryHostPointerPropertiesEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetMemoryHostPointerPropertiesEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(VkCommandBuffer, VkPipelineStageFlagBits, VkBuffer, VkDeviceSize, uint32_t) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdWriteBufferMarkerAMD was called, resulting in no-op behavior."); } -static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(VkDevice, uint32_t, const VkCalibratedTimestampInfoEXT*, uint64_t*, uint64_t*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetCalibratedTimestampsEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(VkDevice, uint32_t, const VkCalibratedTimestampInfoKHR*, uint64_t*, uint64_t*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetCalibratedTimestampsEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(VkCommandBuffer, uint32_t, uint32_t) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdDrawMeshTasksNV was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(VkCommandBuffer, VkBuffer, VkDeviceSize, uint32_t, uint32_t) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdDrawMeshTasksIndirectNV was called, resulting in no-op behavior."); } static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(VkCommandBuffer, VkBuffer, VkDeviceSize, VkBuffer, VkDeviceSize, uint32_t, uint32_t) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdDrawMeshTasksIndirectCountNV was called, resulting in no-op behavior."); } @@ -764,6 +766,7 @@ struct InstanceTable PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR GetPhysicalDeviceFragmentShadingRatesKHR{ noop::GetPhysicalDeviceFragmentShadingRatesKHR }; PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR{ noop::GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR }; PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR GetPhysicalDeviceCooperativeMatrixPropertiesKHR{ noop::GetPhysicalDeviceCooperativeMatrixPropertiesKHR }; + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR GetPhysicalDeviceCalibrateableTimeDomainsKHR{ noop::GetPhysicalDeviceCalibrateableTimeDomainsKHR }; PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT{ noop::CreateDebugReportCallbackEXT }; PFN_vkDestroyDebugReportCallbackEXT DestroyDebugReportCallbackEXT{ noop::DestroyDebugReportCallbackEXT }; PFN_vkDebugReportMessageEXT DebugReportMessageEXT{ noop::DebugReportMessageEXT }; @@ -1091,6 +1094,7 @@ struct DeviceTable PFN_vkGetRenderingAreaGranularityKHR GetRenderingAreaGranularityKHR{ noop::GetRenderingAreaGranularityKHR }; PFN_vkGetDeviceImageSubresourceLayoutKHR GetDeviceImageSubresourceLayoutKHR{ noop::GetDeviceImageSubresourceLayoutKHR }; PFN_vkGetImageSubresourceLayout2KHR GetImageSubresourceLayout2KHR{ noop::GetImageSubresourceLayout2KHR }; + PFN_vkGetCalibratedTimestampsKHR GetCalibratedTimestampsKHR{ noop::GetCalibratedTimestampsKHR }; PFN_vkFrameBoundaryANDROID FrameBoundaryANDROID{ noop::FrameBoundaryANDROID }; PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT{ noop::DebugMarkerSetObjectTagEXT }; PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT{ noop::DebugMarkerSetObjectNameEXT }; @@ -1401,6 +1405,7 @@ static void LoadInstanceTable(PFN_vkGetInstanceProcAddr gpa, VkInstance instance LoadFunction(gpa, instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR", &table->GetPhysicalDeviceFragmentShadingRatesKHR); LoadFunction(gpa, instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR", &table->GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR); LoadFunction(gpa, instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", &table->GetPhysicalDeviceCooperativeMatrixPropertiesKHR); + LoadFunction(gpa, instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", &table->GetPhysicalDeviceCalibrateableTimeDomainsKHR); LoadFunction(gpa, instance, "vkCreateDebugReportCallbackEXT", &table->CreateDebugReportCallbackEXT); LoadFunction(gpa, instance, "vkDestroyDebugReportCallbackEXT", &table->DestroyDebugReportCallbackEXT); LoadFunction(gpa, instance, "vkDebugReportMessageEXT", &table->DebugReportMessageEXT); @@ -1730,6 +1735,7 @@ static void LoadDeviceTable(PFN_vkGetDeviceProcAddr gpa, VkDevice device, Device LoadFunction(gpa, device, "vkGetRenderingAreaGranularityKHR", &table->GetRenderingAreaGranularityKHR); LoadFunction(gpa, device, "vkGetDeviceImageSubresourceLayoutKHR", &table->GetDeviceImageSubresourceLayoutKHR); LoadFunction(gpa, device, "vkGetImageSubresourceLayout2KHR", &table->GetImageSubresourceLayout2KHR); + LoadFunction(gpa, device, "vkGetCalibratedTimestampsKHR", &table->GetCalibratedTimestampsKHR); LoadFunction(gpa, device, "vkFrameBoundaryANDROID", &table->FrameBoundaryANDROID); LoadFunction(gpa, device, "vkDebugMarkerSetObjectTagEXT", &table->DebugMarkerSetObjectTagEXT); LoadFunction(gpa, device, "vkDebugMarkerSetObjectNameEXT", &table->DebugMarkerSetObjectNameEXT); diff --git a/framework/generated/generated_vulkan_enum_to_json.cpp b/framework/generated/generated_vulkan_enum_to_json.cpp index 4daee95d28..f8f672affd 100644 --- a/framework/generated/generated_vulkan_enum_to_json.cpp +++ b/framework/generated/generated_vulkan_enum_to_json.cpp @@ -2276,6 +2276,12 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkDebugReportObjectTypeEXT case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT: jdata = "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT"; break; + case VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT: + jdata = "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT"; + break; + case VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT: + jdata = "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT"; + break; case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT: jdata = "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT"; break; @@ -5141,6 +5147,39 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkInternalAllocationType& } } +void FieldToJson(nlohmann::ordered_json& jdata, const VkLayerSettingTypeEXT& value, const JsonOptions& options) +{ + switch (value) { + case VK_LAYER_SETTING_TYPE_BOOL32_EXT: + jdata = "VK_LAYER_SETTING_TYPE_BOOL32_EXT"; + break; + case VK_LAYER_SETTING_TYPE_INT32_EXT: + jdata = "VK_LAYER_SETTING_TYPE_INT32_EXT"; + break; + case VK_LAYER_SETTING_TYPE_INT64_EXT: + jdata = "VK_LAYER_SETTING_TYPE_INT64_EXT"; + break; + case VK_LAYER_SETTING_TYPE_UINT32_EXT: + jdata = "VK_LAYER_SETTING_TYPE_UINT32_EXT"; + break; + case VK_LAYER_SETTING_TYPE_UINT64_EXT: + jdata = "VK_LAYER_SETTING_TYPE_UINT64_EXT"; + break; + case VK_LAYER_SETTING_TYPE_FLOAT32_EXT: + jdata = "VK_LAYER_SETTING_TYPE_FLOAT32_EXT"; + break; + case VK_LAYER_SETTING_TYPE_FLOAT64_EXT: + jdata = "VK_LAYER_SETTING_TYPE_FLOAT64_EXT"; + break; + case VK_LAYER_SETTING_TYPE_STRING_EXT: + jdata = "VK_LAYER_SETTING_TYPE_STRING_EXT"; + break; + default: + jdata = to_hex_fixed_width(value); + break; + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const VkLayeredDriverUnderlyingApiMSFT& value, const JsonOptions& options) { switch (value) { @@ -5486,6 +5525,12 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkObjectType& value, const case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV: jdata = "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV"; break; + case VK_OBJECT_TYPE_CUDA_MODULE_NV: + jdata = "VK_OBJECT_TYPE_CUDA_MODULE_NV"; + break; + case VK_OBJECT_TYPE_CUDA_FUNCTION_NV: + jdata = "VK_OBJECT_TYPE_CUDA_FUNCTION_NV"; + break; case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA: jdata = "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"; break; @@ -5873,6 +5918,18 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkPerformanceValueTypeINTE } } +void FieldToJson(VkPhysicalDeviceSchedulingControlsFlagBitsARM_t, nlohmann::ordered_json& jdata, const VkPhysicalDeviceSchedulingControlsFlagBitsARM& value, const JsonOptions& options) +{ + switch (value) { + case VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM: + jdata = "VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM"; + break; + default: + jdata = to_hex_fixed_width(value); + break; + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const VkPhysicalDeviceType& value, const JsonOptions& options) { switch (value) { @@ -8760,6 +8817,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_HDR_METADATA_EXT: jdata = "VK_STRUCTURE_TYPE_HDR_METADATA_EXT"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG"; + break; case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: jdata = "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"; break; @@ -9081,9 +9141,6 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: jdata = "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"; break; - case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"; - break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"; break; @@ -9120,12 +9177,6 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"; break; - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: - jdata = "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"; - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: - jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"; - break; case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: jdata = "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP"; break; @@ -9525,6 +9576,21 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: jdata = "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"; break; + case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV: + jdata = "VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV"; + break; + case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV: + jdata = "VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV"; + break; + case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV: + jdata = "VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV"; + break; case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: jdata = "VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV"; break; @@ -9894,6 +9960,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI"; + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"; break; @@ -9906,6 +9975,15 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM"; break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + jdata = "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM"; + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT"; break; @@ -9927,6 +10005,21 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM"; + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + jdata = "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM"; + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: + jdata = "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM"; + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + jdata = "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM"; + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM"; break; @@ -10125,6 +10218,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: jdata = "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT"; break; + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT"; + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM"; break; @@ -10209,6 +10305,15 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR"; + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR"; + break; case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX: jdata = "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX"; break; @@ -10227,6 +10332,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT"; break; + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: + jdata = "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR"; + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV"; break; @@ -10494,20 +10602,20 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkTessellationDomainOrigin } } -void FieldToJson(nlohmann::ordered_json& jdata, const VkTimeDomainEXT& value, const JsonOptions& options) +void FieldToJson(nlohmann::ordered_json& jdata, const VkTimeDomainKHR& value, const JsonOptions& options) { switch (value) { - case VK_TIME_DOMAIN_DEVICE_EXT: - jdata = "VK_TIME_DOMAIN_DEVICE_EXT"; + case VK_TIME_DOMAIN_DEVICE_KHR: + jdata = "VK_TIME_DOMAIN_DEVICE_KHR"; break; - case VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT: - jdata = "VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT"; + case VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR: + jdata = "VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR"; break; - case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT: - jdata = "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT"; + case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR: + jdata = "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR"; break; - case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT: - jdata = "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT"; + case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR: + jdata = "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR"; break; default: jdata = to_hex_fixed_width(value); @@ -13435,6 +13543,24 @@ void FieldToJson(VkPerformanceCounterDescriptionFlagsKHR_t, nlohmann::ordered_js }); } +void FieldToJson(VkPhysicalDeviceSchedulingControlsFlagsARM_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_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM: + return std::string("VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM"); + } + return to_hex_fixed_width(flags); + }); +} + void FieldToJson(VkPipelineCacheCreateFlags_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 8cc717d33a..d9334d01a3 100644 --- a/framework/generated/generated_vulkan_enum_to_json.h +++ b/framework/generated/generated_vulkan_enum_to_json.h @@ -133,6 +133,7 @@ struct VkOpticalFlowSessionCreateFlagsNV_t { }; struct VkOpticalFlowUsageFlagsNV_t { }; struct VkPeerMemoryFeatureFlags_t { }; struct VkPerformanceCounterDescriptionFlagsKHR_t { }; +struct VkPhysicalDeviceSchedulingControlsFlagsARM_t { }; struct VkPipelineCacheCreateFlags_t { }; struct VkPipelineColorBlendStateCreateFlags_t { }; struct VkPipelineCompilerControlFlagsAMD_t { }; @@ -228,6 +229,7 @@ struct VkXlibSurfaceCreateFlagsKHR_t { }; struct VkAccessFlagBits2_t { }; struct VkBufferUsageFlagBits2KHR_t { }; struct VkFormatFeatureFlagBits2_t { }; +struct VkPhysicalDeviceSchedulingControlsFlagBitsARM_t { }; struct VkPipelineCreateFlagBits2KHR_t { }; struct VkPipelineStageFlagBits2_t { }; @@ -367,6 +369,7 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsTokenTyp void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectStateFlagBitsNV& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkInstanceCreateFlagBits& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkInternalAllocationType& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkLayerSettingTypeEXT& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkLayeredDriverUnderlyingApiMSFT& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkLineRasterizationModeEXT& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkLogicOp& value, const util::JsonOptions& options = util::JsonOptions()); @@ -394,6 +397,7 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkPerformanceCounterUnitKH void FieldToJson(nlohmann::ordered_json& jdata, const VkPerformanceOverrideTypeINTEL& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPerformanceParameterTypeINTEL& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPerformanceValueTypeINTEL& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkPhysicalDeviceSchedulingControlsFlagBitsARM_t, nlohmann::ordered_json& jdata, const VkPhysicalDeviceSchedulingControlsFlagBitsARM& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPhysicalDeviceType& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineBindPoint& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkPipelineCacheCreateFlagBits& value, const util::JsonOptions& options = util::JsonOptions()); @@ -468,7 +472,7 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkSurfaceTransformFlagBits void FieldToJson(nlohmann::ordered_json& jdata, const VkSwapchainCreateFlagBitsKHR& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkSystemAllocationScope& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkTessellationDomainOrigin& value, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const VkTimeDomainEXT& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkTimeDomainKHR& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkToolPurposeFlagBits& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkValidationCacheHeaderVersionEXT& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkValidationCheckEXT& value, const util::JsonOptions& options = util::JsonOptions()); @@ -590,6 +594,7 @@ void FieldToJson(VkOpticalFlowSessionCreateFlagsNV_t, nlohmann::ordered_json& jd void FieldToJson(VkOpticalFlowUsageFlagsNV_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkPeerMemoryFeatureFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkPerformanceCounterDescriptionFlagsKHR_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkPhysicalDeviceSchedulingControlsFlagsARM_t, nlohmann::ordered_json& jdata, const VkFlags64 flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkPipelineCacheCreateFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkPipelineColorBlendStateCreateFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkPipelineCompilerControlFlagsAMD_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); diff --git a/framework/generated/generated_vulkan_enum_to_string.cpp b/framework/generated/generated_vulkan_enum_to_string.cpp index 69eef71429..3998cf5d48 100644 --- a/framework/generated/generated_vulkan_enum_to_string.cpp +++ b/framework/generated/generated_vulkan_enum_to_string.cpp @@ -1577,6 +1577,8 @@ template <> std::string ToString(const VkObjectType& value, ToStri case VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL: return "VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL"; case VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR: return "VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR"; case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV: return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV"; + case VK_OBJECT_TYPE_CUDA_MODULE_NV: return "VK_OBJECT_TYPE_CUDA_MODULE_NV"; + case VK_OBJECT_TYPE_CUDA_FUNCTION_NV: return "VK_OBJECT_TYPE_CUDA_FUNCTION_NV"; case VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA: return "VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA"; case VK_OBJECT_TYPE_MICROMAP_EXT: return "VK_OBJECT_TYPE_MICROMAP_EXT"; case VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: return "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV"; @@ -2505,6 +2507,7 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT"; case VK_STRUCTURE_TYPE_HDR_METADATA_EXT: return "VK_STRUCTURE_TYPE_HDR_METADATA_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG"; case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: return "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR"; case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: return "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR"; case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: return "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR"; @@ -2612,7 +2615,6 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR"; case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: return "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD"; - case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD"; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR"; case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR"; @@ -2625,8 +2627,6 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR"; case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: return "VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT"; - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT"; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: return "VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV"; @@ -2760,6 +2760,11 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: return "VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV"; case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: return "VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV"; + case VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV: return "VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV"; + case VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV: return "VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV"; + case VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV: return "VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV"; case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: return "VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV"; case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT"; case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT: return "VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT"; @@ -2883,10 +2888,14 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: return "VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT"; case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM"; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT"; case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE"; @@ -2894,6 +2903,11 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM"; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: return "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM"; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: return "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM"; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: return "VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM"; case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: return "VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM"; @@ -2960,6 +2974,7 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT"; case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT"; @@ -2988,12 +3003,16 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: return "VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR"; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR"; case VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX: return "VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX"; case VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX: return "VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX"; case VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX: return "VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX"; case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX: return "VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT"; + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: return "VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV"; default: break; } @@ -4375,6 +4394,18 @@ template <> std::string ToString(const VkScopeKHR& value, ToStringFl return "Unhandled VkScopeKHR"; } +template <> std::string ToString(const VkTimeDomainKHR& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_TIME_DOMAIN_DEVICE_KHR: return "VK_TIME_DOMAIN_DEVICE_KHR"; + case VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR: return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR"; + case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR: return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR"; + case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR: return "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR"; + default: break; + } + return "Unhandled VkTimeDomainKHR"; +} + template <> std::string ToString(const VkDebugReportFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) { switch (value) { @@ -4434,6 +4465,8 @@ template <> std::string ToString(const VkDebugReport case VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT"; case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT"; case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT"; + case VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT"; + case VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT"; case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT: return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT"; default: break; } @@ -5025,18 +5058,6 @@ template <> std::string ToString(VkFlags v return BitmaskToString(vkFlags); } -template <> std::string ToString(const VkTimeDomainEXT& value, ToStringFlags, uint32_t, uint32_t) -{ - switch (value) { - case VK_TIME_DOMAIN_DEVICE_EXT: return "VK_TIME_DOMAIN_DEVICE_EXT"; - case VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT: return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT"; - case VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT: return "VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT"; - case VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT: return "VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT"; - default: break; - } - return "Unhandled VkTimeDomainEXT"; -} - template <> std::string ToString(const VkMemoryOverallocationBehaviorAMD& value, ToStringFlags, uint32_t, uint32_t) { switch (value) { @@ -5608,6 +5629,20 @@ template <> std::string ToString(const VkDisplac return "Unhandled VkDisplacementMicromapFormatNV"; } +template <> std::string ToString(const VkPhysicalDeviceSchedulingControlsFlagBitsARM& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM: return "VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM"; + default: break; + } + return "Unhandled VkPhysicalDeviceSchedulingControlsFlagBitsARM"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + template <> std::string ToString(const VkSubpassMergeStatusEXT& value, ToStringFlags, uint32_t, uint32_t) { switch (value) { @@ -5778,6 +5813,22 @@ template <> std::string ToString(const VkRa return "Unhandled VkRayTracingInvocationReorderModeNV"; } +template <> std::string ToString(const VkLayerSettingTypeEXT& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_LAYER_SETTING_TYPE_BOOL32_EXT: return "VK_LAYER_SETTING_TYPE_BOOL32_EXT"; + case VK_LAYER_SETTING_TYPE_INT32_EXT: return "VK_LAYER_SETTING_TYPE_INT32_EXT"; + case VK_LAYER_SETTING_TYPE_INT64_EXT: return "VK_LAYER_SETTING_TYPE_INT64_EXT"; + case VK_LAYER_SETTING_TYPE_UINT32_EXT: return "VK_LAYER_SETTING_TYPE_UINT32_EXT"; + case VK_LAYER_SETTING_TYPE_UINT64_EXT: return "VK_LAYER_SETTING_TYPE_UINT64_EXT"; + case VK_LAYER_SETTING_TYPE_FLOAT32_EXT: return "VK_LAYER_SETTING_TYPE_FLOAT32_EXT"; + case VK_LAYER_SETTING_TYPE_FLOAT64_EXT: return "VK_LAYER_SETTING_TYPE_FLOAT64_EXT"; + case VK_LAYER_SETTING_TYPE_STRING_EXT: return "VK_LAYER_SETTING_TYPE_STRING_EXT"; + default: break; + } + return "Unhandled VkLayerSettingTypeEXT"; +} + template <> std::string ToString(const VkBlockMatchWindowCompareModeQCOM& 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 4075d3b039..1f95734818 100644 --- a/framework/generated/generated_vulkan_enum_to_string.h +++ b/framework/generated/generated_vulkan_enum_to_string.h @@ -296,6 +296,7 @@ std::string VkPipelineCreateFlagBits2KHRToString(const VkPipelineCreateFlagBits2 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 VkTimeDomainKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkDebugReportFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkDebugReportObjectTypeEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); @@ -356,7 +357,6 @@ template <> std::string ToString(const VkGeometryTypeKHR& val template <> std::string ToString(const VkRayTracingShaderGroupTypeKHR& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkPipelineCompilerControlFlagBitsAMD& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); -template <> std::string ToString(const VkTimeDomainEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkMemoryOverallocationBehaviorAMD& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkPerformanceConfigurationTypeINTEL& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkPerformanceOverrideTypeINTEL& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); @@ -414,6 +414,8 @@ template <> std::string ToString(const VkMicromapTypeEXT& val template <> std::string ToString(const VkOpacityMicromapFormatEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkOpacityMicromapSpecialIndexEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkDisplacementMicromapFormatNV& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkPhysicalDeviceSchedulingControlsFlagBitsARM& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkSubpassMergeStatusEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkDirectDriverLoadingModeLUNARG& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkOpticalFlowExecuteFlagBitsNV& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); @@ -430,6 +432,7 @@ template <> std::string ToString(const VkShaderCodeTypeEXT& template <> std::string ToString(const VkShaderCreateFlagBitsEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkRayTracingInvocationReorderModeNV& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkLayerSettingTypeEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkBlockMatchWindowCompareModeQCOM& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkCubicFilterWeightsQCOM& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkLayeredDriverUnderlyingApiMSFT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); diff --git a/framework/generated/generated_vulkan_feature_util.cpp b/framework/generated/generated_vulkan_feature_util.cpp index 7f8da21572..2281fb8433 100644 --- a/framework/generated/generated_vulkan_feature_util.cpp +++ b/framework/generated/generated_vulkan_feature_util.cpp @@ -1720,6 +1720,28 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + { + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* currentNext = reinterpret_cast(next); + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->vertexAttributeInstanceRateDivisor == VK_TRUE) && (query.vertexAttributeInstanceRateDivisor == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature vertexAttributeInstanceRateDivisor %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->vertexAttributeInstanceRateDivisor = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + if ((currentNext->vertexAttributeInstanceRateZeroDivisor == VK_TRUE) && (query.vertexAttributeInstanceRateZeroDivisor == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature vertexAttributeInstanceRateZeroDivisor %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->vertexAttributeInstanceRateZeroDivisor = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { const VkPhysicalDeviceTransformFeedbackFeaturesEXT* currentNext = reinterpret_cast(next); @@ -1824,6 +1846,21 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + { + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* currentNext = reinterpret_cast(next); + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->relaxedLineRasterization == VK_TRUE) && (query.relaxedLineRasterization == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature relaxedLineRasterization %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->relaxedLineRasterization = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: { const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* currentNext = reinterpret_cast(next); @@ -1891,28 +1928,6 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: - { - const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* currentNext = reinterpret_cast(next); - VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, nullptr }; - physicalDeviceFeatures2.pNext = &query; - GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); - if ((currentNext->vertexAttributeInstanceRateDivisor == VK_TRUE) && (query.vertexAttributeInstanceRateDivisor == VK_FALSE)) - { - GFXRECON_LOG_WARNING("Feature vertexAttributeInstanceRateDivisor %s", warn_message); - found_unsupported = true; - const_cast(currentNext)->vertexAttributeInstanceRateDivisor = - remove_unsupported ? VK_FALSE : VK_TRUE; - } - if ((currentNext->vertexAttributeInstanceRateZeroDivisor == VK_TRUE) && (query.vertexAttributeInstanceRateZeroDivisor == VK_FALSE)) - { - GFXRECON_LOG_WARNING("Feature vertexAttributeInstanceRateZeroDivisor %s", warn_message); - found_unsupported = true; - const_cast(currentNext)->vertexAttributeInstanceRateZeroDivisor = - remove_unsupported ? VK_FALSE : VK_TRUE; - } - break; - } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: { const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* currentNext = reinterpret_cast(next); @@ -3329,6 +3344,21 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + { + const VkPhysicalDeviceSchedulingControlsFeaturesARM* currentNext = reinterpret_cast(next); + VkPhysicalDeviceSchedulingControlsFeaturesARM query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->schedulingControls == VK_TRUE) && (query.schedulingControls == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature schedulingControls %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->schedulingControls = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: { const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* currentNext = reinterpret_cast(next); @@ -3389,6 +3419,21 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + { + const VkPhysicalDeviceRenderPassStripedFeaturesARM* currentNext = reinterpret_cast(next); + VkPhysicalDeviceRenderPassStripedFeaturesARM query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->renderPassStriped == VK_TRUE) && (query.renderPassStriped == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature renderPassStriped %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->renderPassStriped = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: { const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* currentNext = reinterpret_cast(next); diff --git a/framework/generated/generated_vulkan_json_consumer.cpp b/framework/generated/generated_vulkan_json_consumer.cpp index e85d05cf2f..c362a64f29 100644 --- a/framework/generated/generated_vulkan_json_consumer.cpp +++ b/framework/generated/generated_vulkan_json_consumer.cpp @@ -5980,6 +5980,44 @@ void VulkanExportJsonConsumer::Process_vkGetPhysicalDeviceCooperativeMatrixPrope WriteBlockEnd(); } +void VulkanExportJsonConsumer::Process_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId physicalDevice, + PointerDecoder* pTimeDomainCount, + PointerDecoder* pTimeDomains) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameReturn()], returnValue, json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["physicalDevice"], physicalDevice, json_options); + FieldToJson(args["pTimeDomainCount"], pTimeDomainCount, json_options); + FieldToJson(args["pTimeDomains"], pTimeDomains, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkGetCalibratedTimestampsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + uint32_t timestampCount, + StructPointerDecoder* pTimestampInfos, + PointerDecoder* pTimestamps, + PointerDecoder* pMaxDeviation) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkGetCalibratedTimestampsKHR"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameReturn()], returnValue, json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options); + FieldToJson(args["timestampCount"], timestampCount, json_options); + FieldToJson(args["pTimestampInfos"], pTimestampInfos, json_options); + FieldToJson(args["pTimestamps"], pTimestamps, json_options); + FieldToJson(args["pMaxDeviation"], pMaxDeviation, json_options); + WriteBlockEnd(); +} + void VulkanExportJsonConsumer::Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, @@ -7445,7 +7483,7 @@ void VulkanExportJsonConsumer::Process_vkGetPhysicalDeviceCalibrateableTimeDomai VkResult returnValue, format::HandleId physicalDevice, PointerDecoder* pTimeDomainCount, - PointerDecoder* pTimeDomains) + PointerDecoder* pTimeDomains) { nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"); const JsonOptions& json_options = GetJsonOptions(); @@ -7462,7 +7500,7 @@ void VulkanExportJsonConsumer::Process_vkGetCalibratedTimestampsEXT( VkResult returnValue, format::HandleId device, uint32_t timestampCount, - StructPointerDecoder* pTimestampInfos, + StructPointerDecoder* pTimestampInfos, PointerDecoder* pTimestamps, PointerDecoder* pMaxDeviation) { diff --git a/framework/generated/generated_vulkan_json_consumer.h b/framework/generated/generated_vulkan_json_consumer.h index 6c97340289..4ee8225bf8 100644 --- a/framework/generated/generated_vulkan_json_consumer.h +++ b/framework/generated/generated_vulkan_json_consumer.h @@ -2440,6 +2440,22 @@ class VulkanExportJsonConsumer : public VulkanExportJsonConsumerBase PointerDecoder* pPropertyCount, StructPointerDecoder* pProperties) override; + virtual void Process_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId physicalDevice, + PointerDecoder* pTimeDomainCount, + PointerDecoder* pTimeDomains) override; + + virtual void Process_vkGetCalibratedTimestampsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + uint32_t timestampCount, + StructPointerDecoder* pTimestampInfos, + PointerDecoder* pTimestamps, + PointerDecoder* pMaxDeviation) override; + virtual void Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, @@ -3039,14 +3055,14 @@ class VulkanExportJsonConsumer : public VulkanExportJsonConsumerBase VkResult returnValue, format::HandleId physicalDevice, PointerDecoder* pTimeDomainCount, - PointerDecoder* pTimeDomains) override; + PointerDecoder* pTimeDomains) override; virtual void Process_vkGetCalibratedTimestampsEXT( const ApiCallInfo& call_info, VkResult returnValue, format::HandleId device, uint32_t timestampCount, - StructPointerDecoder* pTimestampInfos, + StructPointerDecoder* pTimestampInfos, PointerDecoder* pTimestamps, PointerDecoder* pMaxDeviation) override; diff --git a/framework/generated/generated_vulkan_replay_consumer.cpp b/framework/generated/generated_vulkan_replay_consumer.cpp index 0c291f0934..308516523b 100644 --- a/framework/generated/generated_vulkan_replay_consumer.cpp +++ b/framework/generated/generated_vulkan_replay_consumer.cpp @@ -5440,6 +5440,41 @@ void VulkanReplayConsumer::Process_vkGetPhysicalDeviceCooperativeMatrixPropertie if (pProperties->IsNull()) { SetOutputArrayCount(physicalDevice, kPhysicalDeviceArrayGetPhysicalDeviceCooperativeMatrixPropertiesKHR, *out_pPropertyCount, &VulkanObjectInfoTable::GetPhysicalDeviceInfo); } } +void VulkanReplayConsumer::Process_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId physicalDevice, + PointerDecoder* pTimeDomainCount, + PointerDecoder* pTimeDomains) +{ + VkPhysicalDevice in_physicalDevice = MapHandle(physicalDevice, &VulkanObjectInfoTable::GetPhysicalDeviceInfo); + uint32_t* out_pTimeDomainCount = pTimeDomainCount->IsNull() ? nullptr : pTimeDomainCount->AllocateOutputData(1, GetOutputArrayCount("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", returnValue, physicalDevice, kPhysicalDeviceArrayGetPhysicalDeviceCalibrateableTimeDomainsKHR, pTimeDomainCount, pTimeDomains, &VulkanObjectInfoTable::GetPhysicalDeviceInfo)); + VkTimeDomainKHR* out_pTimeDomains = pTimeDomains->IsNull() ? nullptr : pTimeDomains->AllocateOutputData(*out_pTimeDomainCount); + + VkResult replay_result = GetInstanceTable(in_physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsKHR(in_physicalDevice, out_pTimeDomainCount, out_pTimeDomains); + CheckResult("vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", returnValue, replay_result, call_info); + + if (pTimeDomains->IsNull()) { SetOutputArrayCount(physicalDevice, kPhysicalDeviceArrayGetPhysicalDeviceCalibrateableTimeDomainsKHR, *out_pTimeDomainCount, &VulkanObjectInfoTable::GetPhysicalDeviceInfo); } +} + +void VulkanReplayConsumer::Process_vkGetCalibratedTimestampsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + uint32_t timestampCount, + StructPointerDecoder* pTimestampInfos, + PointerDecoder* pTimestamps, + PointerDecoder* pMaxDeviation) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + const VkCalibratedTimestampInfoKHR* in_pTimestampInfos = pTimestampInfos->GetPointer(); + uint64_t* out_pTimestamps = pTimestamps->IsNull() ? nullptr : pTimestamps->AllocateOutputData(timestampCount); + uint64_t* out_pMaxDeviation = pMaxDeviation->IsNull() ? nullptr : pMaxDeviation->AllocateOutputData(1, static_cast(0)); + + VkResult replay_result = GetDeviceTable(in_device)->GetCalibratedTimestampsKHR(in_device, timestampCount, in_pTimestampInfos, out_pTimestamps, out_pMaxDeviation); + CheckResult("vkGetCalibratedTimestampsKHR", returnValue, replay_result, call_info); +} + void VulkanReplayConsumer::Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, @@ -6726,11 +6761,11 @@ void VulkanReplayConsumer::Process_vkGetPhysicalDeviceCalibrateableTimeDomainsEX VkResult returnValue, format::HandleId physicalDevice, PointerDecoder* pTimeDomainCount, - PointerDecoder* pTimeDomains) + PointerDecoder* pTimeDomains) { VkPhysicalDevice in_physicalDevice = MapHandle(physicalDevice, &VulkanObjectInfoTable::GetPhysicalDeviceInfo); uint32_t* out_pTimeDomainCount = pTimeDomainCount->IsNull() ? nullptr : pTimeDomainCount->AllocateOutputData(1, GetOutputArrayCount("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", returnValue, physicalDevice, kPhysicalDeviceArrayGetPhysicalDeviceCalibrateableTimeDomainsEXT, pTimeDomainCount, pTimeDomains, &VulkanObjectInfoTable::GetPhysicalDeviceInfo)); - VkTimeDomainEXT* out_pTimeDomains = pTimeDomains->IsNull() ? nullptr : pTimeDomains->AllocateOutputData(*out_pTimeDomainCount); + VkTimeDomainKHR* out_pTimeDomains = pTimeDomains->IsNull() ? nullptr : pTimeDomains->AllocateOutputData(*out_pTimeDomainCount); VkResult replay_result = GetInstanceTable(in_physicalDevice)->GetPhysicalDeviceCalibrateableTimeDomainsEXT(in_physicalDevice, out_pTimeDomainCount, out_pTimeDomains); CheckResult("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", returnValue, replay_result, call_info); @@ -6743,12 +6778,12 @@ void VulkanReplayConsumer::Process_vkGetCalibratedTimestampsEXT( VkResult returnValue, format::HandleId device, uint32_t timestampCount, - StructPointerDecoder* pTimestampInfos, + StructPointerDecoder* pTimestampInfos, PointerDecoder* pTimestamps, PointerDecoder* pMaxDeviation) { VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); - const VkCalibratedTimestampInfoEXT* in_pTimestampInfos = pTimestampInfos->GetPointer(); + const VkCalibratedTimestampInfoKHR* in_pTimestampInfos = pTimestampInfos->GetPointer(); uint64_t* out_pTimestamps = pTimestamps->IsNull() ? nullptr : pTimestamps->AllocateOutputData(timestampCount); uint64_t* out_pMaxDeviation = pMaxDeviation->IsNull() ? nullptr : pMaxDeviation->AllocateOutputData(1, static_cast(0)); @@ -11007,6 +11042,26 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -11382,6 +11437,11 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -11667,11 +11727,6 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -11687,16 +11742,6 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: - { - output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); - break; - } case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -12602,6 +12647,11 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -12622,6 +12672,21 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -12657,6 +12722,31 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -12907,6 +12997,11 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: { 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 4d3f8d27b6..f525f1c2c0 100644 --- a/framework/generated/generated_vulkan_replay_consumer.h +++ b/framework/generated/generated_vulkan_replay_consumer.h @@ -2473,6 +2473,22 @@ class VulkanReplayConsumer : public VulkanReplayConsumerBase PointerDecoder* pPropertyCount, StructPointerDecoder* pProperties) override; + virtual void Process_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId physicalDevice, + PointerDecoder* pTimeDomainCount, + PointerDecoder* pTimeDomains) override; + + virtual void Process_vkGetCalibratedTimestampsKHR( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + uint32_t timestampCount, + StructPointerDecoder* pTimestampInfos, + PointerDecoder* pTimestamps, + PointerDecoder* pMaxDeviation) override; + virtual void Process_vkFrameBoundaryANDROID( const ApiCallInfo& call_info, format::HandleId device, @@ -3072,14 +3088,14 @@ class VulkanReplayConsumer : public VulkanReplayConsumerBase VkResult returnValue, format::HandleId physicalDevice, PointerDecoder* pTimeDomainCount, - PointerDecoder* pTimeDomains) override; + PointerDecoder* pTimeDomains) override; virtual void Process_vkGetCalibratedTimestampsEXT( const ApiCallInfo& call_info, VkResult returnValue, format::HandleId device, uint32_t timestampCount, - StructPointerDecoder* pTimestampInfos, + StructPointerDecoder* pTimestampInfos, PointerDecoder* pTimestamps, PointerDecoder* pMaxDeviation) override; diff --git a/framework/generated/generated_vulkan_struct_decoders.cpp b/framework/generated/generated_vulkan_struct_decoders.cpp index 5c03a9949d..09226f7734 100644 --- a/framework/generated/generated_vulkan_struct_decoders.cpp +++ b/framework/generated/generated_vulkan_struct_decoders.cpp @@ -10104,6 +10104,84 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxVertexAttribDivisor)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportsNonZeroFirstInstance)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDivisorDescriptionKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkVertexInputBindingDivisorDescriptionKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->divisor)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineVertexInputDivisorStateCreateInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexBindingDivisorCount)); + wrapper->pVertexBindingDivisors = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pVertexBindingDivisors->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pVertexBindingDivisors = wrapper->pVertexBindingDivisors->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateDivisor)); + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateZeroDivisor)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoKHR* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkCalibratedTimestampInfoKHR* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeDomain)); + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDebugReportCallbackCreateInfoEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -11693,6 +11771,21 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkHdrMeta return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->relaxedLineRasterization)); + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIOSSurfaceCreateInfoMVK* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -12942,21 +13035,6 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelin return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoEXT* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkCalibratedTimestampInfoEXT* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->timeDomain)); - - return bytes_read; -} - size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesAMD* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -13015,53 +13093,6 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica return bytes_read; } -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkVertexInputBindingDivisorDescriptionEXT* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkVertexInputBindingDivisorDescriptionEXT* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->binding)); - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->divisor)); - - return bytes_read; -} - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoEXT* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkPipelineVertexInputDivisorStateCreateInfoEXT* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexBindingDivisorCount)); - wrapper->pVertexBindingDivisors = DecodeAllocator::Allocate>(); - bytes_read += wrapper->pVertexBindingDivisors->Decode((buffer + bytes_read), (buffer_size - bytes_read)); - value->pVertexBindingDivisors = wrapper->pVertexBindingDivisors->GetPointer(); - - return bytes_read; -} - -size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* wrapper) -{ - assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); - - size_t bytes_read = 0; - VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* value = wrapper->decoded_value; - - bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); - bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); - value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateDivisor)); - bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexAttributeInstanceRateZeroDivisor)); - - return bytes_read; -} - size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPresentFrameTokenGGP* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -16536,6 +16567,21 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->clusterShadingRate)); + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -16602,6 +16648,51 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDeviceQueueShaderCoreControlCreateInfoARM* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCoreCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSchedulingControlsFeaturesARM* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->schedulingControls)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceSchedulingControlsPropertiesARM* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlags64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->schedulingControlsFlags)); + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -16711,6 +16802,92 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceRenderPassStripedFeaturesARM* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeVkBool32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->renderPassStriped)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceRenderPassStripedPropertiesARM* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->renderPassStripeGranularity = DecodeAllocator::Allocate(); + wrapper->renderPassStripeGranularity->decoded_value = &(value->renderPassStripeGranularity); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->renderPassStripeGranularity); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxRenderPassStripes)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeInfoARM* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassStripeInfoARM* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + wrapper->stripeArea = DecodeAllocator::Allocate(); + wrapper->stripeArea->decoded_value = &(value->stripeArea); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->stripeArea); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeBeginInfoARM* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassStripeBeginInfoARM* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stripeInfoCount)); + wrapper->pStripeInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStripeInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStripeInfos = wrapper->pStripeInfos->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkRenderPassStripeSubmitInfoARM* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkRenderPassStripeSubmitInfoARM* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stripeSemaphoreInfoCount)); + wrapper->pStripeSemaphoreInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pStripeSemaphoreInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pStripeSemaphoreInfos = wrapper->pStripeSemaphoreInfos->GetPointer(); + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -17666,6 +17843,43 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysica return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLayerSettingEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkLayerSettingEXT* value = wrapper->decoded_value; + + bytes_read += wrapper->pLayerName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pLayerName = wrapper->pLayerName.GetPointer(); + bytes_read += wrapper->pSettingName.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSettingName = wrapper->pSettingName.GetPointer(); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->valueCount)); + bytes_read += wrapper->pValues.DecodeVoid((buffer + bytes_read), (buffer_size - bytes_read)); + value->pValues = wrapper->pValues.GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkLayerSettingsCreateInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkLayerSettingsCreateInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->settingCount)); + wrapper->pSettings = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSettings->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSettings = wrapper->pSettings->GetPointer(); + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* 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 e54f7c4efd..61fcbf5b31 100644 --- a/framework/generated/generated_vulkan_struct_decoders.h +++ b/framework/generated/generated_vulkan_struct_decoders.h @@ -5090,6 +5090,50 @@ struct Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR PNextNode* pNext{ nullptr }; }; +struct Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR +{ + using struct_type = VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR; + + VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkVertexInputBindingDivisorDescriptionKHR +{ + using struct_type = VkVertexInputBindingDivisorDescriptionKHR; + + VkVertexInputBindingDivisorDescriptionKHR* decoded_value{ nullptr }; +}; + +struct Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR +{ + using struct_type = VkPipelineVertexInputDivisorStateCreateInfoKHR; + + VkPipelineVertexInputDivisorStateCreateInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pVertexBindingDivisors{ nullptr }; +}; + +struct Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR +{ + using struct_type = VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR; + + VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkCalibratedTimestampInfoKHR +{ + using struct_type = VkCalibratedTimestampInfoKHR; + + VkCalibratedTimestampInfoKHR* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + struct Decoded_VkDebugReportCallbackCreateInfoEXT { using struct_type = VkDebugReportCallbackCreateInfoEXT; @@ -5920,6 +5964,15 @@ struct Decoded_VkHdrMetadataEXT Decoded_VkXYColorEXT* whitePoint{ nullptr }; }; +struct Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG +{ + using struct_type = VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + struct Decoded_VkIOSSurfaceCreateInfoMVK { using struct_type = VkIOSSurfaceCreateInfoMVK; @@ -6617,14 +6670,7 @@ struct Decoded_VkPipelineCompilerControlCreateInfoAMD PNextNode* pNext{ nullptr }; }; -struct Decoded_VkCalibratedTimestampInfoEXT -{ - using struct_type = VkCalibratedTimestampInfoEXT; - - VkCalibratedTimestampInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; +typedef Decoded_VkCalibratedTimestampInfoKHR Decoded_VkCalibratedTimestampInfoEXT; struct Decoded_VkPhysicalDeviceShaderCorePropertiesAMD { @@ -6653,31 +6699,11 @@ struct Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT PNextNode* pNext{ nullptr }; }; -struct Decoded_VkVertexInputBindingDivisorDescriptionEXT -{ - using struct_type = VkVertexInputBindingDivisorDescriptionEXT; +typedef Decoded_VkVertexInputBindingDivisorDescriptionKHR Decoded_VkVertexInputBindingDivisorDescriptionEXT; - VkVertexInputBindingDivisorDescriptionEXT* decoded_value{ nullptr }; -}; +typedef Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR Decoded_VkPipelineVertexInputDivisorStateCreateInfoEXT; -struct Decoded_VkPipelineVertexInputDivisorStateCreateInfoEXT -{ - using struct_type = VkPipelineVertexInputDivisorStateCreateInfoEXT; - - VkPipelineVertexInputDivisorStateCreateInfoEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; - StructPointerDecoder* pVertexBindingDivisors{ nullptr }; -}; - -struct Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT -{ - using struct_type = VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; - - VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* decoded_value{ nullptr }; - - PNextNode* pNext{ nullptr }; -}; +typedef Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; struct Decoded_VkPresentFrameTokenGGP { @@ -8610,6 +8636,15 @@ struct Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI PointerDecoder maxWorkGroupSize; }; +struct Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI +{ + using struct_type = VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + + VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + struct Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT { using struct_type = VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; @@ -8647,6 +8682,33 @@ struct Decoded_VkPhysicalDeviceShaderCorePropertiesARM PNextNode* pNext{ nullptr }; }; +struct Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM +{ + using struct_type = VkDeviceQueueShaderCoreControlCreateInfoARM; + + VkDeviceQueueShaderCoreControlCreateInfoARM* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM +{ + using struct_type = VkPhysicalDeviceSchedulingControlsFeaturesARM; + + VkPhysicalDeviceSchedulingControlsFeaturesARM* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM +{ + using struct_type = VkPhysicalDeviceSchedulingControlsPropertiesARM; + + VkPhysicalDeviceSchedulingControlsPropertiesARM* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + struct Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT { using struct_type = VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; @@ -8711,6 +8773,55 @@ struct Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT PNextNode* pNext{ nullptr }; }; +struct Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM +{ + using struct_type = VkPhysicalDeviceRenderPassStripedFeaturesARM; + + VkPhysicalDeviceRenderPassStripedFeaturesARM* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM +{ + using struct_type = VkPhysicalDeviceRenderPassStripedPropertiesARM; + + VkPhysicalDeviceRenderPassStripedPropertiesARM* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + Decoded_VkExtent2D* renderPassStripeGranularity{ nullptr }; +}; + +struct Decoded_VkRenderPassStripeInfoARM +{ + using struct_type = VkRenderPassStripeInfoARM; + + VkRenderPassStripeInfoARM* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + Decoded_VkRect2D* stripeArea{ nullptr }; +}; + +struct Decoded_VkRenderPassStripeBeginInfoARM +{ + using struct_type = VkRenderPassStripeBeginInfoARM; + + VkRenderPassStripeBeginInfoARM* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pStripeInfos{ nullptr }; +}; + +struct Decoded_VkRenderPassStripeSubmitInfoARM +{ + using struct_type = VkRenderPassStripeSubmitInfoARM; + + VkRenderPassStripeSubmitInfoARM* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pStripeSemaphoreInfos{ nullptr }; +}; + struct Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { using struct_type = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; @@ -9226,6 +9337,27 @@ struct Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV PNextNode* pNext{ nullptr }; }; +struct Decoded_VkLayerSettingEXT +{ + using struct_type = VkLayerSettingEXT; + + VkLayerSettingEXT* decoded_value{ nullptr }; + + StringDecoder pLayerName; + StringDecoder pSettingName; + PointerDecoder pValues; +}; + +struct Decoded_VkLayerSettingsCreateInfoEXT +{ + using struct_type = VkLayerSettingsCreateInfoEXT; + + VkLayerSettingsCreateInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pSettings{ nullptr }; +}; + struct Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM { using struct_type = VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; diff --git a/framework/generated/generated_vulkan_struct_decoders_forward.h b/framework/generated/generated_vulkan_struct_decoders_forward.h index 645a852c2f..b22e1e7007 100644 --- a/framework/generated/generated_vulkan_struct_decoders_forward.h +++ b/framework/generated/generated_vulkan_struct_decoders_forward.h @@ -1119,6 +1119,20 @@ size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* wrapper); +struct Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR; +struct Decoded_VkVertexInputBindingDivisorDescriptionKHR; +struct Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR; +struct Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVertexInputBindingDivisorDescriptionKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* wrapper); + +struct Decoded_VkCalibratedTimestampInfoKHR; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoKHR* wrapper); + struct Decoded_VkDebugReportCallbackCreateInfoEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDebugReportCallbackCreateInfoEXT* wrapper); @@ -1357,6 +1371,10 @@ struct Decoded_VkHdrMetadataEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkXYColorEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkHdrMetadataEXT* wrapper); +struct Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* wrapper); + struct Decoded_VkIOSSurfaceCreateInfoMVK; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIOSSurfaceCreateInfoMVK* wrapper); @@ -1529,10 +1547,6 @@ struct Decoded_VkPipelineCompilerControlCreateInfoAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineCompilerControlCreateInfoAMD* wrapper); -struct Decoded_VkCalibratedTimestampInfoEXT; - -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkCalibratedTimestampInfoEXT* wrapper); - struct Decoded_VkPhysicalDeviceShaderCorePropertiesAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesAMD* wrapper); @@ -1542,14 +1556,8 @@ struct Decoded_VkDeviceMemoryOverallocationCreateInfoAMD; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceMemoryOverallocationCreateInfoAMD* wrapper); struct Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; -struct Decoded_VkVertexInputBindingDivisorDescriptionEXT; -struct Decoded_VkPipelineVertexInputDivisorStateCreateInfoEXT; -struct Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkVertexInputBindingDivisorDescriptionEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineVertexInputDivisorStateCreateInfoEXT* wrapper); -size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* wrapper); struct Decoded_VkPresentFrameTokenGGP; @@ -2111,9 +2119,11 @@ size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded struct Decoded_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; struct Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; +struct Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* wrapper); struct Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; struct Decoded_VkSamplerBorderColorComponentMappingCreateInfoEXT; @@ -2129,6 +2139,14 @@ struct Decoded_VkPhysicalDeviceShaderCorePropertiesARM; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderCorePropertiesARM* wrapper); +struct Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM; +struct Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM; +struct Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM* wrapper); + struct Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; struct Decoded_VkImageViewSlicedCreateInfoEXT; @@ -2151,6 +2169,18 @@ struct Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* wrapper); +struct Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM; +struct Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM; +struct Decoded_VkRenderPassStripeInfoARM; +struct Decoded_VkRenderPassStripeBeginInfoARM; +struct Decoded_VkRenderPassStripeSubmitInfoARM; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassStripeInfoARM* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassStripeBeginInfoARM* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkRenderPassStripeSubmitInfoARM* wrapper); + struct Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; struct Decoded_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; struct Decoded_VkSubpassFragmentDensityMapOffsetEndInfoQCOM; @@ -2303,6 +2333,12 @@ struct Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* wrapper); +struct Decoded_VkLayerSettingEXT; +struct Decoded_VkLayerSettingsCreateInfoEXT; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLayerSettingEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkLayerSettingsCreateInfoEXT* wrapper); + struct Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; struct Decoded_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; diff --git a/framework/generated/generated_vulkan_struct_encoders.cpp b/framework/generated/generated_vulkan_struct_encoders.cpp index 4428697adb..020ea61552 100644 --- a/framework/generated/generated_vulkan_struct_encoders.cpp +++ b/framework/generated/generated_vulkan_struct_encoders.cpp @@ -5112,6 +5112,43 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceCooperativeMa encoder->EncodeFlagsValue(value.cooperativeMatrixSupportedStages); } +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.maxVertexAttribDivisor); + encoder->EncodeVkBool32Value(value.supportsNonZeroFirstInstance); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkVertexInputBindingDivisorDescriptionKHR& value) +{ + encoder->EncodeUInt32Value(value.binding); + encoder->EncodeUInt32Value(value.divisor); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkPipelineVertexInputDivisorStateCreateInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.vertexBindingDivisorCount); + EncodeStructArray(encoder, value.pVertexBindingDivisors, value.vertexBindingDivisorCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.vertexAttributeInstanceRateDivisor); + encoder->EncodeVkBool32Value(value.vertexAttributeInstanceRateZeroDivisor); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkCalibratedTimestampInfoKHR& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeEnumValue(value.timeDomain); +} + void EncodeStruct(ParameterEncoder* encoder, const VkDebugReportCallbackCreateInfoEXT& value) { encoder->EncodeEnumValue(value.sType); @@ -5912,6 +5949,13 @@ void EncodeStruct(ParameterEncoder* encoder, const VkHdrMetadataEXT& value) encoder->EncodeFloatValue(value.maxFrameAverageLightLevel); } +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.relaxedLineRasterization); +} + void EncodeStruct(ParameterEncoder* encoder, const VkIOSSurfaceCreateInfoMVK& value) { encoder->EncodeEnumValue(value.sType); @@ -6521,13 +6565,6 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPipelineCompilerControlCrea encoder->EncodeFlagsValue(value.compilerControlFlags); } -void EncodeStruct(ParameterEncoder* encoder, const VkCalibratedTimestampInfoEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeEnumValue(value.timeDomain); -} - void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderCorePropertiesAMD& value) { encoder->EncodeEnumValue(value.sType); @@ -6562,28 +6599,6 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttribu encoder->EncodeUInt32Value(value.maxVertexAttribDivisor); } -void EncodeStruct(ParameterEncoder* encoder, const VkVertexInputBindingDivisorDescriptionEXT& value) -{ - encoder->EncodeUInt32Value(value.binding); - encoder->EncodeUInt32Value(value.divisor); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPipelineVertexInputDivisorStateCreateInfoEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeUInt32Value(value.vertexBindingDivisorCount); - EncodeStructArray(encoder, value.pVertexBindingDivisors, value.vertexBindingDivisorCount); -} - -void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& value) -{ - encoder->EncodeEnumValue(value.sType); - EncodePNextStruct(encoder, value.pNext); - encoder->EncodeVkBool32Value(value.vertexAttributeInstanceRateDivisor); - encoder->EncodeVkBool32Value(value.vertexAttributeInstanceRateZeroDivisor); -} - void EncodeStruct(ParameterEncoder* encoder, const VkPresentFrameTokenGGP& value) { encoder->EncodeEnumValue(value.sType); @@ -8305,6 +8320,13 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceClusterCullin encoder->EncodeVkDeviceSizeValue(value.indirectBufferOffsetAlignment); } +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.clusterShadingRate); +} + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& value) { encoder->EncodeEnumValue(value.sType); @@ -8337,6 +8359,27 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderCorePro encoder->EncodeUInt32Value(value.fmaRate); } +void EncodeStruct(ParameterEncoder* encoder, const VkDeviceQueueShaderCoreControlCreateInfoARM& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.shaderCoreCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceSchedulingControlsFeaturesARM& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.schedulingControls); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceSchedulingControlsPropertiesARM& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlags64Value(value.schedulingControlsFlags); +} + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& value) { encoder->EncodeEnumValue(value.sType); @@ -8389,6 +8432,44 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceNonSeamlessCu encoder->EncodeVkBool32Value(value.nonSeamlessCubeMap); } +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRenderPassStripedFeaturesARM& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVkBool32Value(value.renderPassStriped); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRenderPassStripedPropertiesARM& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + EncodeStruct(encoder, value.renderPassStripeGranularity); + encoder->EncodeUInt32Value(value.maxRenderPassStripes); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkRenderPassStripeInfoARM& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + EncodeStruct(encoder, value.stripeArea); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkRenderPassStripeBeginInfoARM& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.stripeInfoCount); + EncodeStructArray(encoder, value.pStripeInfos, value.stripeInfoCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkRenderPassStripeSubmitInfoARM& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.stripeSemaphoreInfoCount); + EncodeStructArray(encoder, value.pStripeSemaphoreInfos, value.stripeSemaphoreInfoCount); +} + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& value) { encoder->EncodeEnumValue(value.sType); @@ -8866,6 +8947,23 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceExtendedSpars encoder->EncodeFlagsValue(value.extendedSparseBufferUsageFlags); } +void EncodeStruct(ParameterEncoder* encoder, const VkLayerSettingEXT& value) +{ + encoder->EncodeString(value.pLayerName); + encoder->EncodeString(value.pSettingName); + encoder->EncodeEnumValue(value.type); + encoder->EncodeUInt32Value(value.valueCount); + encoder->EncodeVoidArray(value.pValues, value.valueCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkLayerSettingsCreateInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.settingCount); + EncodeStructArray(encoder, value.pSettings, value.settingCount); +} + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& value) { encoder->EncodeEnumValue(value.sType); diff --git a/framework/generated/generated_vulkan_struct_encoders.h b/framework/generated/generated_vulkan_struct_encoders.h index 489d37012c..dcb1bffcfe 100644 --- a/framework/generated/generated_vulkan_struct_encoders.h +++ b/framework/generated/generated_vulkan_struct_encoders.h @@ -586,6 +586,13 @@ void EncodeStruct(ParameterEncoder* encoder, const VkCooperativeMatrixProperties void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceCooperativeMatrixFeaturesKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceCooperativeMatrixPropertiesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkVertexInputBindingDivisorDescriptionKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPipelineVertexInputDivisorStateCreateInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& value); + +void EncodeStruct(ParameterEncoder* encoder, const VkCalibratedTimestampInfoKHR& value); + void EncodeStruct(ParameterEncoder* encoder, const VkDebugReportCallbackCreateInfoEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkPipelineRasterizationStateRasterizationOrderAMD& value); @@ -705,6 +712,8 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPipelineRasterizationDepthC void EncodeStruct(ParameterEncoder* encoder, const VkXYColorEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkHdrMetadataEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& value); + void EncodeStruct(ParameterEncoder* encoder, const VkIOSSurfaceCreateInfoMVK& value); void EncodeStruct(ParameterEncoder* encoder, const VkMacOSSurfaceCreateInfoMVK& value); @@ -791,16 +800,11 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceExternalMemor void EncodeStruct(ParameterEncoder* encoder, const VkPipelineCompilerControlCreateInfoAMD& value); -void EncodeStruct(ParameterEncoder* encoder, const VkCalibratedTimestampInfoEXT& value); - void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderCorePropertiesAMD& value); void EncodeStruct(ParameterEncoder* encoder, const VkDeviceMemoryOverallocationCreateInfoAMD& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkVertexInputBindingDivisorDescriptionEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkPipelineVertexInputDivisorStateCreateInfoEXT& value); -void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkPresentFrameTokenGGP& value); @@ -1083,6 +1087,7 @@ void EncodeStruct(ParameterEncoder* encoder, const VkAccelerationStructureTriang void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkSamplerBorderColorComponentMappingCreateInfoEXT& value); @@ -1091,6 +1096,10 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDevicePageableDevic void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderCorePropertiesARM& value); +void EncodeStruct(ParameterEncoder* encoder, const VkDeviceQueueShaderCoreControlCreateInfoARM& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceSchedulingControlsFeaturesARM& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceSchedulingControlsPropertiesARM& value); + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkImageViewSlicedCreateInfoEXT& value); @@ -1102,6 +1111,12 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceDepthClampZer void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRenderPassStripedFeaturesARM& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRenderPassStripedPropertiesARM& value); +void EncodeStruct(ParameterEncoder* encoder, const VkRenderPassStripeInfoARM& value); +void EncodeStruct(ParameterEncoder* encoder, const VkRenderPassStripeBeginInfoARM& value); +void EncodeStruct(ParameterEncoder* encoder, const VkRenderPassStripeSubmitInfoARM& value); + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& value); void EncodeStruct(ParameterEncoder* encoder, const VkSubpassFragmentDensityMapOffsetEndInfoQCOM& value); @@ -1178,6 +1193,9 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRayTracingInv void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV& value); +void EncodeStruct(ParameterEncoder* encoder, const VkLayerSettingEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkLayerSettingsCreateInfoEXT& value); + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM& value); diff --git a/framework/generated/generated_vulkan_struct_handle_mappers.cpp b/framework/generated/generated_vulkan_struct_handle_mappers.cpp index 01d33d007e..d7192a8ddc 100644 --- a/framework/generated/generated_vulkan_struct_handle_mappers.cpp +++ b/framework/generated/generated_vulkan_struct_handle_mappers.cpp @@ -1674,6 +1674,14 @@ void MapStructHandles(Decoded_VkDescriptorSetBindingReferenceVALVE* wrapper, con } } +void MapStructHandles(Decoded_VkRenderPassStripeSubmitInfoARM* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if (wrapper != nullptr) + { + MapStructArrayHandles(wrapper->pStripeSemaphoreInfos->GetMetaStructPointer(), wrapper->pStripeSemaphoreInfos->GetLength(), object_info_table); + } +} + void MapStructHandles(Decoded_VkPipelineIndirectDeviceAddressInfoNV* wrapper, const VulkanObjectInfoTable& object_info_table) { if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) @@ -1866,6 +1874,9 @@ void MapPNextStructHandles(const void* value, void* wrapper, const VulkanObjectI case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: MapStructHandles(reinterpret_cast(wrapper), object_info_table); break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + MapStructHandles(reinterpret_cast(wrapper), object_info_table); + break; case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: MapStructHandles(reinterpret_cast(wrapper), object_info_table); break; diff --git a/framework/generated/generated_vulkan_struct_handle_mappers.h b/framework/generated/generated_vulkan_struct_handle_mappers.h index 9022879ddb..f2c5378b88 100644 --- a/framework/generated/generated_vulkan_struct_handle_mappers.h +++ b/framework/generated/generated_vulkan_struct_handle_mappers.h @@ -343,6 +343,8 @@ void MapStructHandles(Decoded_VkAccelerationStructureTrianglesDisplacementMicrom void MapStructHandles(Decoded_VkDescriptorSetBindingReferenceVALVE* wrapper, const VulkanObjectInfoTable& object_info_table); +void MapStructHandles(Decoded_VkRenderPassStripeSubmitInfoARM* wrapper, const VulkanObjectInfoTable& object_info_table); + void MapStructHandles(Decoded_VkPipelineIndirectDeviceAddressInfoNV* wrapper, const VulkanObjectInfoTable& object_info_table); void MapStructHandles(Decoded_VkShaderCreateInfoEXT* 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 05c458e3d2..aa0cbecc91 100644 --- a/framework/generated/generated_vulkan_struct_handle_wrappers.cpp +++ b/framework/generated/generated_vulkan_struct_handle_wrappers.cpp @@ -1170,6 +1170,14 @@ void UnwrapStructHandles(VkDescriptorSetBindingReferenceVALVE* value, HandleUnwr } } +void UnwrapStructHandles(VkRenderPassStripeSubmitInfoARM* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + value->pStripeSemaphoreInfos = UnwrapStructArrayHandles(value->pStripeSemaphoreInfos, value->stripeSemaphoreInfoCount, unwrap_memory); + } +} + void UnwrapStructHandles(VkPipelineIndirectDeviceAddressInfoNV* value, HandleUnwrapMemory* unwrap_memory) { if (value != nullptr) @@ -1815,6 +1823,15 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -1995,6 +2012,9 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -2115,12 +2135,6 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: - copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); - break; case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -2535,6 +2549,9 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -2547,6 +2564,15 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -2562,6 +2588,18 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -2685,6 +2723,9 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -2826,6 +2867,8 @@ const void* UnwrapPNextStructHandles(const void* value, HandleUnwrapMemory* unwr return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); } diff --git a/framework/generated/generated_vulkan_struct_handle_wrappers.h b/framework/generated/generated_vulkan_struct_handle_wrappers.h index 50be57d357..6434d8fcf7 100644 --- a/framework/generated/generated_vulkan_struct_handle_wrappers.h +++ b/framework/generated/generated_vulkan_struct_handle_wrappers.h @@ -343,6 +343,8 @@ void UnwrapStructHandles(VkAccelerationStructureTrianglesDisplacementMicromapNV* void UnwrapStructHandles(VkDescriptorSetBindingReferenceVALVE* value, HandleUnwrapMemory* unwrap_memory); +void UnwrapStructHandles(VkRenderPassStripeSubmitInfoARM* value, HandleUnwrapMemory* unwrap_memory); + void UnwrapStructHandles(VkPipelineIndirectDeviceAddressInfoNV* value, HandleUnwrapMemory* unwrap_memory); void UnwrapStructHandles(VkShaderCreateInfoEXT* 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 cb0ec6b3e5..ffab7e9541 100644 --- a/framework/generated/generated_vulkan_struct_to_json.cpp +++ b/framework/generated/generated_vulkan_struct_to_json.cpp @@ -7980,6 +7980,73 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCo } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["maxVertexAttribDivisor"], decoded_value.maxVertexAttribDivisor, options); + jdata["supportsNonZeroFirstInstance"] = static_cast(decoded_value.supportsNonZeroFirstInstance); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVertexInputBindingDivisorDescriptionKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkVertexInputBindingDivisorDescriptionKHR& decoded_value = *data->decoded_value; + const Decoded_VkVertexInputBindingDivisorDescriptionKHR& meta_struct = *data; + + FieldToJson(jdata["binding"], decoded_value.binding, options); + FieldToJson(jdata["divisor"], decoded_value.divisor, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPipelineVertexInputDivisorStateCreateInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["vertexBindingDivisorCount"], decoded_value.vertexBindingDivisorCount, options); + FieldToJson(jdata["pVertexBindingDivisors"], meta_struct.pVertexBindingDivisors, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["vertexAttributeInstanceRateDivisor"] = static_cast(decoded_value.vertexAttributeInstanceRateDivisor); + jdata["vertexAttributeInstanceRateZeroDivisor"] = static_cast(decoded_value.vertexAttributeInstanceRateZeroDivisor); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCalibratedTimestampInfoKHR* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkCalibratedTimestampInfoKHR& decoded_value = *data->decoded_value; + const Decoded_VkCalibratedTimestampInfoKHR& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["timeDomain"], decoded_value.timeDomain, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugReportCallbackCreateInfoEXT* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -9308,6 +9375,19 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkHdrMetadataEXT* } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["relaxedLineRasterization"] = static_cast(decoded_value.relaxedLineRasterization); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIOSSurfaceCreateInfoMVK* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -10331,19 +10411,6 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineCompiler } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCalibratedTimestampInfoEXT* data, const JsonOptions& options) -{ - if (data && data->decoded_value) - { - const VkCalibratedTimestampInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkCalibratedTimestampInfoEXT& meta_struct = *data; - - FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["timeDomain"], decoded_value.timeDomain, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); - } -} - void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderCorePropertiesAMD* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -10396,46 +10463,6 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVe } } -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVertexInputBindingDivisorDescriptionEXT* data, const JsonOptions& options) -{ - if (data && data->decoded_value) - { - const VkVertexInputBindingDivisorDescriptionEXT& decoded_value = *data->decoded_value; - const Decoded_VkVertexInputBindingDivisorDescriptionEXT& meta_struct = *data; - - FieldToJson(jdata["binding"], decoded_value.binding, options); - FieldToJson(jdata["divisor"], decoded_value.divisor, options); - } -} - -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineVertexInputDivisorStateCreateInfoEXT* data, const JsonOptions& options) -{ - if (data && data->decoded_value) - { - const VkPipelineVertexInputDivisorStateCreateInfoEXT& decoded_value = *data->decoded_value; - const Decoded_VkPipelineVertexInputDivisorStateCreateInfoEXT& meta_struct = *data; - - FieldToJson(jdata["sType"], decoded_value.sType, options); - FieldToJson(jdata["vertexBindingDivisorCount"], decoded_value.vertexBindingDivisorCount, options); - FieldToJson(jdata["pVertexBindingDivisors"], meta_struct.pVertexBindingDivisors, options); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); - } -} - -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* data, const JsonOptions& options) -{ - if (data && data->decoded_value) - { - const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& decoded_value = *data->decoded_value; - const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& meta_struct = *data; - - FieldToJson(jdata["sType"], decoded_value.sType, options); - jdata["vertexAttributeInstanceRateDivisor"] = static_cast(decoded_value.vertexAttributeInstanceRateDivisor); - jdata["vertexAttributeInstanceRateZeroDivisor"] = static_cast(decoded_value.vertexAttributeInstanceRateZeroDivisor); - FieldToJson(jdata["pNext"], meta_struct.pNext, options); - } -} - void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPresentFrameTokenGGP* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -13345,6 +13372,19 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCl } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["clusterShadingRate"] = static_cast(decoded_value.clusterShadingRate); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -13401,6 +13441,45 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceSh } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkDeviceQueueShaderCoreControlCreateInfoARM& decoded_value = *data->decoded_value; + const Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["shaderCoreCount"], decoded_value.shaderCoreCount, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceSchedulingControlsFeaturesARM& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["schedulingControls"] = static_cast(decoded_value.schedulingControls); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceSchedulingControlsPropertiesARM& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkPhysicalDeviceSchedulingControlsFlagsARM_t(),jdata["schedulingControlsFlags"], decoded_value.schedulingControlsFlags, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -13495,6 +13574,74 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceNo } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceRenderPassStripedFeaturesARM& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["renderPassStriped"] = static_cast(decoded_value.renderPassStriped); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceRenderPassStripedPropertiesARM& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["renderPassStripeGranularity"], meta_struct.renderPassStripeGranularity, options); + FieldToJson(jdata["maxRenderPassStripes"], decoded_value.maxRenderPassStripes, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderPassStripeInfoARM* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkRenderPassStripeInfoARM& decoded_value = *data->decoded_value; + const Decoded_VkRenderPassStripeInfoARM& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["stripeArea"], meta_struct.stripeArea, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderPassStripeBeginInfoARM* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkRenderPassStripeBeginInfoARM& decoded_value = *data->decoded_value; + const Decoded_VkRenderPassStripeBeginInfoARM& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["stripeInfoCount"], decoded_value.stripeInfoCount, options); + FieldToJson(jdata["pStripeInfos"], meta_struct.pStripeInfos, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderPassStripeSubmitInfoARM* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkRenderPassStripeSubmitInfoARM& decoded_value = *data->decoded_value; + const Decoded_VkRenderPassStripeSubmitInfoARM& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["stripeSemaphoreInfoCount"], decoded_value.stripeSemaphoreInfoCount, options); + FieldToJson(jdata["pStripeSemaphoreInfos"], meta_struct.pStripeSemaphoreInfos, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -14302,6 +14449,35 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceEx } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkLayerSettingEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkLayerSettingEXT& decoded_value = *data->decoded_value; + const Decoded_VkLayerSettingEXT& meta_struct = *data; + + FieldToJson(jdata["pLayerName"], &meta_struct.pLayerName, options); + FieldToJson(jdata["pSettingName"], &meta_struct.pSettingName, options); + FieldToJson(jdata["type"], decoded_value.type, options); + FieldToJson(jdata["valueCount"], decoded_value.valueCount, options); + FieldToJson(jdata["pValues"], meta_struct.pValues, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkLayerSettingsCreateInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkLayerSettingsCreateInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkLayerSettingsCreateInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["settingCount"], decoded_value.settingCount, options); + FieldToJson(jdata["pSettings"], meta_struct.pSettings, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -16261,6 +16437,27 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); @@ -16681,6 +16878,13 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); @@ -16961,20 +17165,6 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: - { - const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); - FieldToJson(jdata, pnext, options); - break; - } - case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); @@ -17941,6 +18131,13 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); @@ -17969,6 +18166,27 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); @@ -18004,6 +18222,34 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); @@ -18291,6 +18537,13 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: { 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 f3b56d50ea..3709294f5d 100644 --- a/framework/generated/generated_vulkan_struct_to_json.h +++ b/framework/generated/generated_vulkan_struct_to_json.h @@ -518,6 +518,11 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRa void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCooperativeMatrixPropertiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCooperativeMatrixFeaturesKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCooperativeMatrixPropertiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVertexInputBindingDivisorDescriptionKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineVertexInputDivisorStateCreateInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCalibratedTimestampInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugReportCallbackCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineRasterizationStateRasterizationOrderAMD* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugMarkerObjectNameInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); @@ -606,6 +611,7 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDe void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineRasterizationDepthClipStateCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkXYColorEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkHdrMetadataEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIOSSurfaceCreateInfoMVK* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMacOSSurfaceCreateInfoMVK* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDebugUtilsLabelEXT* data, const util::JsonOptions& options = util::JsonOptions()); @@ -675,13 +681,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImportMemoryHost void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkMemoryHostPointerPropertiesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineCompilerControlCreateInfoAMD* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkCalibratedTimestampInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderCorePropertiesAMD* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDeviceMemoryOverallocationCreateInfoAMD* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkVertexInputBindingDivisorDescriptionEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineVertexInputDivisorStateCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); -void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPresentFrameTokenGGP* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceMeshShaderFeaturesNV* data, const util::JsonOptions& options = util::JsonOptions()); @@ -880,10 +882,14 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDi void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAccelerationStructureTrianglesDisplacementMicromapNV* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSamplerBorderColorComponentMappingCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderCorePropertiesARM* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDeviceQueueShaderCoreControlCreateInfoARM* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceSchedulingControlsFeaturesARM* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceSchedulingControlsPropertiesARM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageViewSlicedCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* data, const util::JsonOptions& options = util::JsonOptions()); @@ -891,6 +897,11 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDescriptorSetBin void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDescriptorSetLayoutHostMappingInfoVALVE* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRenderPassStripedFeaturesARM* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRenderPassStripedPropertiesARM* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderPassStripeInfoARM* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderPassStripeBeginInfoARM* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkRenderPassStripeSubmitInfoARM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkSubpassFragmentDensityMapOffsetEndInfoQCOM* data, const util::JsonOptions& options = util::JsonOptions()); @@ -946,6 +957,8 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRa void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkLayerSettingEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkLayerSettingsCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); diff --git a/framework/generated/vulkan_generators/base_generator.py b/framework/generated/vulkan_generators/base_generator.py index 107353bff7..8ebb7511c7 100644 --- a/framework/generated/vulkan_generators/base_generator.py +++ b/framework/generated/vulkan_generators/base_generator.py @@ -87,6 +87,7 @@ def _make_re_string(list, default=None): "VK_NV_low_latency2", "VK_NV_memory_decompression", "VK_QNX_external_memory_screen_buffer", + "VK_NV_cuda_kernel_launch", ] _supported_subsets = [ diff --git a/layer/trace_layer.cpp b/layer/trace_layer.cpp index 878d9015c5..098f074b33 100644 --- a/layer/trace_layer.cpp +++ b/layer/trace_layer.cpp @@ -75,19 +75,18 @@ const std::vector kDeviceExtensionProps = { /// An alphabetical list of device extensions which we do not report upstream if /// other layers or ICDs expose them to us. -const char* const kUnsupportedDeviceExtensions[] = { - VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME, - VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME, - VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME, - VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME, - VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME, - VK_NVX_BINARY_IMPORT_EXTENSION_NAME, - VK_NVX_BINARY_IMPORT_EXTENSION_NAME, - VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME, - VK_NV_LOW_LATENCY_2_EXTENSION_NAME, - VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME, - VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME, -}; +const char* const kUnsupportedDeviceExtensions[] = { VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME, + VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME, + VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME, + VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME, + VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME, + VK_NVX_BINARY_IMPORT_EXTENSION_NAME, + VK_NVX_BINARY_IMPORT_EXTENSION_NAME, + VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME, + VK_NV_LOW_LATENCY_2_EXTENSION_NAME, + VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME, + VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME, + VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME }; static void remove_extensions(std::vector& extensionProps, const char* const screenedExtensions[],