From 4a2631e1db2925d6003eda89fb471326d57dfb3c Mon Sep 17 00:00:00 2001 From: Nick Driscoll <159576920+nickdriscoll-lunarg@users.noreply.github.com> Date: Mon, 30 Sep 2024 15:39:50 -0400 Subject: [PATCH] Update Vulkan Headers to 1.3.296 (#1773) Update Vulkan Headers to 1.3.296. --- external/Vulkan-Headers | 2 +- .../decode/custom_vulkan_struct_decoders.cpp | 69 +++ .../decode/custom_vulkan_struct_decoders.h | 44 ++ .../custom_vulkan_struct_decoders_forward.h | 6 + .../decode/custom_vulkan_struct_to_json.cpp | 44 ++ .../decode/custom_vulkan_struct_to_json.h | 8 + framework/decode/vulkan_cpp_structs.cpp | 82 ++++ framework/decode/vulkan_cpp_structs.h | 10 + framework/decode/vulkan_object_info.h | 2 + .../encode/custom_vulkan_struct_encoders.cpp | 44 ++ .../encode/custom_vulkan_struct_encoders.h | 2 + framework/encode/vulkan_handle_wrappers.h | 2 + framework/encode/vulkan_state_info.h | 2 + framework/format/api_call_id.h | 10 + .../generated_decode_pnext_struct.cpp | 24 + .../generated_encode_pnext_struct.cpp | 18 + .../generated/generated_layer_func_table.h | 10 + .../generated_vulkan_api_call_encoders.cpp | 410 +++++++++++++++++ .../generated_vulkan_api_call_encoders.h | 54 +++ .../generated_vulkan_command_buffer_util.cpp | 79 ++++ .../generated_vulkan_command_buffer_util.h | 4 + .../generated/generated_vulkan_consumer.h | 66 +++ .../generated_vulkan_cpp_consumer.cpp | 277 +++++++++++ .../generated/generated_vulkan_cpp_consumer.h | 65 +++ ...enerated_vulkan_cpp_consumer_extension.cpp | 60 +++ .../generated_vulkan_cpp_structs.cpp | 431 ++++++++++++++++++ .../generated/generated_vulkan_cpp_structs.h | 44 ++ .../generated/generated_vulkan_decoder.cpp | 242 ++++++++++ .../generated/generated_vulkan_decoder.h | 20 + .../generated_vulkan_dispatch_table.h | 30 ++ .../generated_vulkan_enum_to_json.cpp | 226 +++++++++ .../generated/generated_vulkan_enum_to_json.h | 9 + .../generated_vulkan_enum_to_string.cpp | 95 ++++ .../generated_vulkan_enum_to_string.h | 7 + .../generated_vulkan_feature_util.cpp | 37 ++ .../generated_vulkan_json_consumer.cpp | 165 +++++++ .../generated_vulkan_json_consumer.h | 66 +++ ...generated_vulkan_object_info_table_base2.h | 12 + ...ed_vulkan_referenced_resource_consumer.cpp | 31 ++ ...ated_vulkan_referenced_resource_consumer.h | 12 + .../generated_vulkan_replay_consumer.cpp | 248 ++++++++++ .../generated_vulkan_replay_consumer.h | 66 +++ ...generated_vulkan_replay_dump_resources.cpp | 81 ++++ .../generated_vulkan_replay_dump_resources.h | 22 + .../generated/generated_vulkan_state_table.h | 28 ++ .../generated_vulkan_struct_decoders.cpp | 376 +++++++++++++++ .../generated_vulkan_struct_decoders.h | 200 ++++++++ ...generated_vulkan_struct_decoders_forward.h | 48 ++ .../generated_vulkan_struct_deep_copy.cpp | 407 +++++++++++++++++ ...enerated_vulkan_struct_deep_copy_stype.cpp | 64 +++ .../generated_vulkan_struct_encoders.cpp | 186 ++++++++ .../generated_vulkan_struct_encoders.h | 24 + ...generated_vulkan_struct_handle_mappers.cpp | 127 ++++++ .../generated_vulkan_struct_handle_mappers.h | 20 + ...enerated_vulkan_struct_handle_wrappers.cpp | 105 +++++ .../generated_vulkan_struct_handle_wrappers.h | 20 + .../generated_vulkan_struct_to_json.cpp | 360 +++++++++++++++ .../generated_vulkan_struct_to_json.h | 22 + .../generated/generated_vulkan_stype_util.h | 16 + .../vulkan_generators/blacklists.json | 6 +- ...n_struct_handle_wrappers_body_generator.py | 6 +- 61 files changed, 5250 insertions(+), 3 deletions(-) diff --git a/external/Vulkan-Headers b/external/Vulkan-Headers index c6391a7b8c..29f979ee5a 160000 --- a/external/Vulkan-Headers +++ b/external/Vulkan-Headers @@ -1 +1 @@ -Subproject commit c6391a7b8cd57e79ce6b6c832c8e3043c4d9967b +Subproject commit 29f979ee5aa58b7b005f805ea8df7a855c39ff37 diff --git a/framework/decode/custom_vulkan_struct_decoders.cpp b/framework/decode/custom_vulkan_struct_decoders.cpp index 6a70ecd473..69eff38703 100644 --- a/framework/decode/custom_vulkan_struct_decoders.cpp +++ b/framework/decode/custom_vulkan_struct_decoders.cpp @@ -386,5 +386,74 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_SECURITY_ return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectExecutionSetCreateInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectExecutionSetCreateInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &wrapper->pNext); + bytes_read += + ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &wrapper->decoded_type); + + switch (wrapper->decoded_type) + { + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: + wrapper->info->pPipelineInfo = DecodeAllocator::Allocate(); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->info->pPipelineInfo); + break; + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: + wrapper->info->pShaderInfo = DecodeAllocator::Allocate(); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->info->pShaderInfo); + break; + default: + break; + } + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutTokenEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectCommandsLayoutTokenEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &wrapper->pNext); + bytes_read += + ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &wrapper->decoded_type); + + switch (wrapper->decoded_type) + { + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: + wrapper->data->pPushConstant = DecodeAllocator::Allocate(); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data->pPushConstant); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: + wrapper->data->pVertexBuffer = DecodeAllocator::Allocate(); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data->pVertexBuffer); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: + wrapper->data->pIndexBuffer = DecodeAllocator::Allocate(); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data->pIndexBuffer); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: + wrapper->data->pExecutionSet = DecodeAllocator::Allocate(); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->data->pExecutionSet); + break; + default: + break; + } + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &wrapper->offset); + + return bytes_read; +} + GFXRECON_END_NAMESPACE(decode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/custom_vulkan_struct_decoders.h b/framework/decode/custom_vulkan_struct_decoders.h index 1ab8e530d7..e23b15cc74 100644 --- a/framework/decode/custom_vulkan_struct_decoders.h +++ b/framework/decode/custom_vulkan_struct_decoders.h @@ -197,6 +197,50 @@ struct Decoded_SECURITY_ATTRIBUTES StructPointerDecoder* lpSecurityDescriptor{ nullptr }; }; +// This union wrapper does not have a DecodeStruct function. It is decoded by the +// Decoded_VkIndirectExecutionSetCreateInfoEXT DecodeStruct function, based on the value of +// VkIndirectExecutionSetCreateInfoEXT::type. +struct Decoded_VkIndirectExecutionSetInfoEXT +{ + using struct_type = VkIndirectExecutionSetEXT; + + Decoded_VkIndirectExecutionSetPipelineInfoEXT* pPipelineInfo; + Decoded_VkIndirectExecutionSetShaderInfoEXT* pShaderInfo; +}; + +struct Decoded_VkIndirectExecutionSetCreateInfoEXT +{ + using struct_type = VkIndirectExecutionSetCreateInfoEXT; + + VkIndirectExecutionSetCreateInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + VkIndirectExecutionSetInfoTypeEXT decoded_type; + Decoded_VkIndirectExecutionSetInfoEXT* info; +}; + +struct Decoded_VkIndirectCommandsTokenDataEXT +{ + using struct_type = VkIndirectCommandsTokenDataEXT; + + Decoded_VkIndirectCommandsPushConstantTokenEXT* pPushConstant; + Decoded_VkIndirectCommandsVertexBufferTokenEXT* pVertexBuffer; + Decoded_VkIndirectCommandsIndexBufferTokenEXT* pIndexBuffer; + Decoded_VkIndirectCommandsExecutionSetTokenEXT* pExecutionSet; +}; + +struct Decoded_VkIndirectCommandsLayoutTokenEXT +{ + using struct_type = VkIndirectCommandsLayoutTokenEXT; + + VkIndirectCommandsLayoutTokenEXT* decoded_value; + + PNextNode* pNext{ nullptr }; + VkIndirectCommandsTokenTypeEXT decoded_type; + Decoded_VkIndirectCommandsTokenDataEXT* data; + uint32_t offset; +}; + GFXRECON_END_NAMESPACE(decode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/custom_vulkan_struct_decoders_forward.h b/framework/decode/custom_vulkan_struct_decoders_forward.h index 01f921f02b..05b5a0ad13 100644 --- a/framework/decode/custom_vulkan_struct_decoders_forward.h +++ b/framework/decode/custom_vulkan_struct_decoders_forward.h @@ -39,6 +39,8 @@ struct Decoded_VkDeviceOrHostAddressConstKHR; struct Decoded_VkAccelerationStructureGeometryDataKHR; struct Decoded_VkAccelerationStructureMotionInstanceNV; struct Decoded_VkPerformanceValueDataINTEL; +struct Decoded_VkIndirectExecutionSetInfoEXT; +struct Decoded_VkIndirectCommandsTokenDataEXT; size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearColorValue* wrapper); size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkClearValue* wrapper); @@ -55,12 +57,16 @@ struct Decoded_VkWriteDescriptorSet; struct Decoded_VkPerformanceValueINTEL; struct Decoded_VkAccelerationStructureGeometryKHR; struct Decoded_VkPushDescriptorSetWithTemplateInfoKHR; +struct Decoded_VkIndirectExecutionSetCreateInfoEXT; +struct Decoded_VkIndirectCommandsLayoutTokenEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDescriptorImageInfo* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWriteDescriptorSet* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPerformanceValueINTEL* wrapper); size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureGeometryKHR* wrapper); size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPushDescriptorSetWithTemplateInfoKHR* wrapper); +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectExecutionSetCreateInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutTokenEXT* wrapper); // Decoded struct wrappers for SECURITY_ATTRIBUTES and related WIN32 structures. struct Decoded_ACL; diff --git a/framework/decode/custom_vulkan_struct_to_json.cpp b/framework/decode/custom_vulkan_struct_to_json.cpp index db653bbab5..14a0df5398 100644 --- a/framework/decode/custom_vulkan_struct_to_json.cpp +++ b/framework/decode/custom_vulkan_struct_to_json.cpp @@ -418,5 +418,49 @@ void FieldToJson(nlohmann::ordered_json& jda FieldToJson(jdata["pData"], &pData->pData, options); } +void FieldToJson(nlohmann::ordered_json& jdata, + const Decoded_VkIndirectExecutionSetCreateInfoEXT* const pData, + const util::JsonOptions& options) +{ + FieldToJson(jdata["type"], pData->decoded_type, options); + switch (pData->decoded_type) + { + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: + FieldToJson(jdata["info"], pData->info->pPipelineInfo, options); + break; + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: + FieldToJson(jdata["info"], pData->info->pShaderInfo, options); + break; + default: + break; + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, + const Decoded_VkIndirectCommandsLayoutTokenEXT* const pData, + const util::JsonOptions& options) +{ + FieldToJson(jdata["type"], pData->decoded_type, options); + switch (pData->decoded_type) + { + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: + FieldToJson(jdata["data"], pData->data->pPushConstant, options); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: + FieldToJson(jdata["data"], pData->data->pVertexBuffer, options); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: + FieldToJson(jdata["data"], pData->data->pIndexBuffer, options); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: + FieldToJson(jdata["data"], pData->data->pExecutionSet, options); + break; + default: + break; + } + FieldToJson(jdata["offset"], pData->offset, options); +} + GFXRECON_END_NAMESPACE(decode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/custom_vulkan_struct_to_json.h b/framework/decode/custom_vulkan_struct_to_json.h index 18970221d8..32c781a1f6 100644 --- a/framework/decode/custom_vulkan_struct_to_json.h +++ b/framework/decode/custom_vulkan_struct_to_json.h @@ -115,6 +115,14 @@ void FieldToJson(nlohmann::ordered_json& jda const Decoded_VkPushDescriptorSetWithTemplateInfoKHR* const pData, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, + const Decoded_VkIndirectExecutionSetCreateInfoEXT* const pData, + const util::JsonOptions& options = util::JsonOptions()); + +void FieldToJson(nlohmann::ordered_json& jdata, + const Decoded_VkIndirectCommandsLayoutTokenEXT* const pData, + const util::JsonOptions& options = util::JsonOptions()); + GFXRECON_END_NAMESPACE(decode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/decode/vulkan_cpp_structs.cpp b/framework/decode/vulkan_cpp_structs.cpp index 55365d27d0..2212d44d43 100644 --- a/framework/decode/vulkan_cpp_structs.cpp +++ b/framework/decode/vulkan_cpp_structs.cpp @@ -1210,5 +1210,87 @@ std::string GenerateStruct_VkImportMemoryHostPointerInfoEXT(std::ostream& return variable_name; } +std::string GenerateStruct_VkIndirectExecutionSetCreateInfoEXT(std::ostream& out, + const VkIndirectExecutionSetCreateInfoEXT* structInfo, + Decoded_VkIndirectExecutionSetCreateInfoEXT* metaInfo, + VulkanCppConsumerBase& consumer) +{ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + // sType + struct_body << "\t" + << "VkStructureType(" << structInfo->sType << ")" << std::endl; + // pNext + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + // type + struct_body << "\t\t\t" + << "VkIndirectExecutionSetInfoTypeEXT(" << structInfo->type << ")" << std::endl; + // info + switch (metaInfo->decoded_type) + { + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: + struct_body << "\t\t\t" + << "VkIndirectExecutionSetInfoEXT(" << structInfo->info.pPipelineInfo << ")" << std::endl; + break; + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: + struct_body << "\t\t\t" + << "VkIndirectExecutionSetInfoEXT(" << structInfo->info.pShaderInfo << ")" << std::endl; + break; + } + + out << "\t"; + std::string variable_name = consumer.AddStruct(struct_body, "type"); + out << "VkIndirectExecutionSetInfoTypeEXT " << variable_name << " {" << std::endl; + + return variable_name; +} + +std::string GenerateStruct_VkIndirectCommandsLayoutTokenEXT(std::ostream& out, + const VkIndirectCommandsLayoutTokenEXT* structInfo, + Decoded_VkIndirectCommandsLayoutTokenEXT* metaInfo, + VulkanCppConsumerBase& consumer) +{ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + // sType + struct_body << "\t" + << "VkStructureType(" << structInfo->sType << ")" << std::endl; + // pNext + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + // type + struct_body << "\t\t\t" + << "VkIndirectCommandsTokenTypeEXT(" << structInfo->type << ")" << std::endl; + // data + switch (metaInfo->decoded_type) + { + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: + struct_body << "\t\t\t" + << "VkIndirectCommandsTokenDataEXT(" << structInfo->data.pPushConstant << ")" << std::endl; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: + struct_body << "\t\t\t" + << "VkIndirectCommandsTokenDataEXT(" << structInfo->data.pVertexBuffer << ")" << std::endl; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: + struct_body << "\t\t\t" + << "VkIndirectCommandsTokenDataEXT(" << structInfo->data.pIndexBuffer << ")" << std::endl; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: + struct_body << "\t\t\t" + << "VkIndirectCommandsTokenDataEXT(" << structInfo->data.pExecutionSet << ")" << std::endl; + break; + } + // offset + struct_body << "\t\t\t" + << "uint32_t(" << structInfo->offset << ")" << std::endl; + + out << "\t"; + std::string variable_name = consumer.AddStruct(struct_body, "type"); + out << "VkIndirectExecutionSetInfoTypeEXT " << variable_name << " {" << std::endl; + + return variable_name; +} + GFXRECON_END_NAMESPACE(gfxrecon) GFXRECON_END_NAMESPACE(decode) diff --git a/framework/decode/vulkan_cpp_structs.h b/framework/decode/vulkan_cpp_structs.h index a9356ec1b7..ee908e402a 100644 --- a/framework/decode/vulkan_cpp_structs.h +++ b/framework/decode/vulkan_cpp_structs.h @@ -127,6 +127,16 @@ std::string GenerateStruct_VkImportMemoryHostPointerInfoEXT(std::ostream& Decoded_VkImportMemoryHostPointerInfoEXT* metaInfo, VulkanCppConsumerBase& consumer); +std::string GenerateStruct_VkIndirectExecutionSetCreateInfoEXT(std::ostream& out, + const VkIndirectExecutionSetCreateInfoEXT* structInfo, + Decoded_VkIndirectExecutionSetCreateInfoEXT* metaInfo, + VulkanCppConsumerBase& consumer); + +std::string GenerateStruct_VkIndirectCommandsLayoutTokenEXT(std::ostream& out, + const VkIndirectCommandsLayoutTokenEXT* structInfo, + Decoded_VkIndirectCommandsLayoutTokenEXT* metaInfo, + VulkanCppConsumerBase& consumer); + GFXRECON_END_NAMESPACE(gfxrecon) GFXRECON_END_NAMESPACE(decode) diff --git a/framework/decode/vulkan_object_info.h b/framework/decode/vulkan_object_info.h index 5e86641d65..be21b1b932 100644 --- a/framework/decode/vulkan_object_info.h +++ b/framework/decode/vulkan_object_info.h @@ -241,6 +241,8 @@ typedef VulkanObjectInfo DevicePi typedef VulkanObjectInfo PipelineBinaryInfoKHRInfo; typedef VulkanObjectInfo PhysicalDevicePipelineBinaryFeaturesKHRInfo; typedef VulkanObjectInfo PhysicalDevicePipelineBinaryPropertiesKHRInfo; +typedef VulkanObjectInfo IndirectCommandsLayoutEXTInfo; +typedef VulkanObjectInfo IndirectExecutionSetEXTInfo; // // Declarations for Vulkan objects with additional replay state info. diff --git a/framework/encode/custom_vulkan_struct_encoders.cpp b/framework/encode/custom_vulkan_struct_encoders.cpp index 33d4396820..7bc5138e77 100644 --- a/framework/encode/custom_vulkan_struct_encoders.cpp +++ b/framework/encode/custom_vulkan_struct_encoders.cpp @@ -288,5 +288,49 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPushDescriptorSetWithTempla encoder->EncodeUInt32Value(value.set); } +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectExecutionSetCreateInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeEnumValue(value.type); + switch (value.type) + { + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: + EncodeStructPtr(encoder, value.info.pPipelineInfo); + break; + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: + EncodeStructPtr(encoder, value.info.pShaderInfo); + break; + default: + break; + } +} + +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsLayoutTokenEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeEnumValue(value.type); + switch (value.type) + { + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: + EncodeStructPtr(encoder, value.data.pPushConstant); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: + EncodeStructPtr(encoder, value.data.pVertexBuffer); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: + EncodeStructPtr(encoder, value.data.pIndexBuffer); + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: + EncodeStructPtr(encoder, value.data.pExecutionSet); + break; + default: + break; + } + encoder->EncodeUInt32Value(value.offset); +} + GFXRECON_END_NAMESPACE(encode) GFXRECON_END_NAMESPACE(gfxrecon) diff --git a/framework/encode/custom_vulkan_struct_encoders.h b/framework/encode/custom_vulkan_struct_encoders.h index 8ee3b473f6..4bedb266d9 100644 --- a/framework/encode/custom_vulkan_struct_encoders.h +++ b/framework/encode/custom_vulkan_struct_encoders.h @@ -47,6 +47,8 @@ void EncodeStruct(ParameterEncoder* encoder, const VkWriteDescriptorSet& value); void EncodeStruct(ParameterEncoder* encoder, const VkPerformanceValueINTEL& value); void EncodeStruct(ParameterEncoder* encoder, const VkAccelerationStructureGeometryKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkPushDescriptorSetWithTemplateInfoKHR& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectExecutionSetCreateInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsLayoutTokenEXT& value); // Platform defined structures that are external to Vulkan. void EncodeStruct(ParameterEncoder* encoder, const ACL& value); diff --git a/framework/encode/vulkan_handle_wrappers.h b/framework/encode/vulkan_handle_wrappers.h index 5df36dcc89..8c6c7438e6 100644 --- a/framework/encode/vulkan_handle_wrappers.h +++ b/framework/encode/vulkan_handle_wrappers.h @@ -98,6 +98,8 @@ struct DevicePipelineBinaryInternalCacheControlKHRWrapper : public HandleWr struct PipelineBinaryInfoKHRWrapper : public HandleWrapper {}; struct PhysicalDevicePipelineBinaryFeaturesKHRWrapper : public HandleWrapper {}; struct PhysicalDevicePipelineBinaryPropertiesKHRWrapper : public HandleWrapper {}; +struct IndirectCommandsLayoutEXTWrapper : public HandleWrapper {}; +struct IndirectExecutionSetEXTWrapper : public HandleWrapper {}; // This handle type has a create function, but no destroy function. The handle wrapper will be owned by its parent VkDisplayKHR diff --git a/framework/encode/vulkan_state_info.h b/framework/encode/vulkan_state_info.h index 97f9af567b..440f66359c 100644 --- a/framework/encode/vulkan_state_info.h +++ b/framework/encode/vulkan_state_info.h @@ -130,6 +130,8 @@ enum CommandHandleType : uint32_t ShaderEXTHandle, DescriptorSetLayoutHandle, DescriptorUpdateTemplateHandle, + IndirectCommandsLayoutEXTHandle, + IndirectExecutionSetEXTHandle, NumHandleTypes // THIS MUST BE THE LAST ENUM VALUE ! }; diff --git a/framework/format/api_call_id.h b/framework/format/api_call_id.h index ec4ada101b..34694d9b4a 100644 --- a/framework/format/api_call_id.h +++ b/framework/format/api_call_id.h @@ -725,6 +725,16 @@ enum ApiCallId : uint32_t ApiCall_vkGetPipelineKeyKHR = MakeApiCallId(ApiFamily_Vulkan, 0x12f0), ApiCall_vkReleaseCapturedPipelineDataKHR = MakeApiCallId(ApiFamily_Vulkan, 0x12f1), ApiCall_vkAntiLagUpdateAMD = MakeApiCallId(ApiFamily_Vulkan, 0x12f2), + ApiCall_vkGetGeneratedCommandsMemoryRequirementsEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12f3), + ApiCall_vkCmdPreprocessGeneratedCommandsEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12f4), + ApiCall_vkCmdExecuteGeneratedCommandsEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12f5), + ApiCall_vkCreateIndirectCommandsLayoutEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12f6), + ApiCall_vkDestroyIndirectCommandsLayoutEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12f7), + ApiCall_vkCreateIndirectExecutionSetEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12f8), + ApiCall_vkDestroyIndirectExecutionSetEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12f9), + ApiCall_vkUpdateIndirectExecutionSetPipelineEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12fa), + ApiCall_vkUpdateIndirectExecutionSetShaderEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12fb), + ApiCall_vkCmdSetDepthClampRangeEXT = MakeApiCallId(ApiFamily_Vulkan, 0x12fc), ApiCall_VulkanLast, diff --git a/framework/generated/generated_decode_pnext_struct.cpp b/framework/generated/generated_decode_pnext_struct.cpp index 2a92a3c908..f974a87472 100644 --- a/framework/generated/generated_decode_pnext_struct.cpp +++ b/framework/generated/generated_decode_pnext_struct.cpp @@ -2259,6 +2259,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_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); @@ -2271,6 +2287,14 @@ size_t DecodePNextStruct(const uint8_t* parameter_buffer, size_t buffer_size, P (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + (*pNext) = DecodeAllocator::Allocate>(); + bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); + break; case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: (*pNext) = DecodeAllocator::Allocate>(); bytes_read = (*pNext)->Decode(parameter_buffer, buffer_size); diff --git a/framework/generated/generated_encode_pnext_struct.cpp b/framework/generated/generated_encode_pnext_struct.cpp index 1af8a21865..579386fa8b 100644 --- a/framework/generated/generated_encode_pnext_struct.cpp +++ b/framework/generated/generated_encode_pnext_struct.cpp @@ -1716,6 +1716,18 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: EncodeStructPtr(encoder, reinterpret_cast(base)); break; @@ -1725,6 +1737,12 @@ void EncodePNextStruct(ParameterEncoder* encoder, const void* value) case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: EncodeStructPtr(encoder, reinterpret_cast(base)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + EncodeStructPtr(encoder, reinterpret_cast(base)); + break; case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: EncodeStructPtr(encoder, reinterpret_cast(base)); break; diff --git a/framework/generated/generated_layer_func_table.h b/framework/generated/generated_layer_func_table.h index 75e0ae83b2..dfeb6fab29 100644 --- a/framework/generated/generated_layer_func_table.h +++ b/framework/generated/generated_layer_func_table.h @@ -659,6 +659,7 @@ const std::unordered_map vulkan_func_table = { { "vkDestroyShaderEXT", reinterpret_cast(encode::DestroyShaderEXT) }, { "vkGetShaderBinaryDataEXT", reinterpret_cast(encode::GetShaderBinaryDataEXT) }, { "vkCmdBindShadersEXT", reinterpret_cast(encode::CmdBindShadersEXT) }, + { "vkCmdSetDepthClampRangeEXT", reinterpret_cast(encode::CmdSetDepthClampRangeEXT) }, { "vkGetFramebufferTilePropertiesQCOM", reinterpret_cast(encode::GetFramebufferTilePropertiesQCOM) }, { "vkGetDynamicRenderingTilePropertiesQCOM", reinterpret_cast(encode::GetDynamicRenderingTilePropertiesQCOM) }, { "vkSetLatencySleepModeNV", reinterpret_cast(encode::SetLatencySleepModeNV) }, @@ -667,6 +668,15 @@ const std::unordered_map vulkan_func_table = { { "vkGetLatencyTimingsNV", reinterpret_cast(encode::GetLatencyTimingsNV) }, { "vkQueueNotifyOutOfBandNV", reinterpret_cast(encode::QueueNotifyOutOfBandNV) }, { "vkCmdSetAttachmentFeedbackLoopEnableEXT", reinterpret_cast(encode::CmdSetAttachmentFeedbackLoopEnableEXT) }, + { "vkGetGeneratedCommandsMemoryRequirementsEXT", reinterpret_cast(encode::GetGeneratedCommandsMemoryRequirementsEXT) }, + { "vkCmdPreprocessGeneratedCommandsEXT", reinterpret_cast(encode::CmdPreprocessGeneratedCommandsEXT) }, + { "vkCmdExecuteGeneratedCommandsEXT", reinterpret_cast(encode::CmdExecuteGeneratedCommandsEXT) }, + { "vkCreateIndirectCommandsLayoutEXT", reinterpret_cast(encode::CreateIndirectCommandsLayoutEXT) }, + { "vkDestroyIndirectCommandsLayoutEXT", reinterpret_cast(encode::DestroyIndirectCommandsLayoutEXT) }, + { "vkCreateIndirectExecutionSetEXT", reinterpret_cast(encode::CreateIndirectExecutionSetEXT) }, + { "vkDestroyIndirectExecutionSetEXT", reinterpret_cast(encode::DestroyIndirectExecutionSetEXT) }, + { "vkUpdateIndirectExecutionSetPipelineEXT", reinterpret_cast(encode::UpdateIndirectExecutionSetPipelineEXT) }, + { "vkUpdateIndirectExecutionSetShaderEXT", reinterpret_cast(encode::UpdateIndirectExecutionSetShaderEXT) }, { "vkCreateAccelerationStructureKHR", reinterpret_cast(encode::CreateAccelerationStructureKHR) }, { "vkDestroyAccelerationStructureKHR", reinterpret_cast(encode::DestroyAccelerationStructureKHR) }, { "vkCmdBuildAccelerationStructuresKHR", reinterpret_cast(encode::CmdBuildAccelerationStructuresKHR) }, diff --git a/framework/generated/generated_vulkan_api_call_encoders.cpp b/framework/generated/generated_vulkan_api_call_encoders.cpp index e738b6b43f..b969e78082 100644 --- a/framework/generated/generated_vulkan_api_call_encoders.cpp +++ b/framework/generated/generated_vulkan_api_call_encoders.cpp @@ -23990,6 +23990,41 @@ VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT( CustomEncoderPostCall::Dispatch(manager, commandBuffer, stageCount, pStages, pShaders); } +VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT( + VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, commandBuffer, depthClampMode, pDepthClampRange); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdSetDepthClampRangeEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(commandBuffer); + encoder->EncodeEnumValue(depthClampMode); + EncodeStructPtr(encoder, pDepthClampRange); + manager->EndCommandApiCallCapture(commandBuffer); + } + + vulkan_wrappers::GetDeviceTable(commandBuffer)->CmdSetDepthClampRangeEXT(commandBuffer, depthClampMode, pDepthClampRange); + + CustomEncoderPostCall::Dispatch(manager, commandBuffer, depthClampMode, pDepthClampRange); +} + VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( VkDevice device, VkFramebuffer framebuffer, @@ -24298,6 +24333,381 @@ VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT( CustomEncoderPostCall::Dispatch(manager, commandBuffer, aspectMask); } +VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, device, pInfo, pMemoryRequirements); + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo_unwrapped = vulkan_wrappers::UnwrapStructPtrHandles(pInfo, handle_unwrap_memory); + + vulkan_wrappers::GetDeviceTable(device)->GetGeneratedCommandsMemoryRequirementsEXT(device, pInfo_unwrapped, pMemoryRequirements); + + auto encoder = manager->BeginApiCallCapture(format::ApiCallId::ApiCall_vkGetGeneratedCommandsMemoryRequirementsEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(device); + EncodeStructPtr(encoder, pInfo); + EncodeStructPtr(encoder, pMemoryRequirements); + manager->EndApiCallCapture(); + } + + CustomEncoderPostCall::Dispatch(manager, device, pInfo, pMemoryRequirements); +} + +VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdPreprocessGeneratedCommandsEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(commandBuffer); + EncodeStructPtr(encoder, pGeneratedCommandsInfo); + encoder->EncodeVulkanHandleValue(stateCommandBuffer); + manager->EndCommandApiCallCapture(commandBuffer, TrackCmdPreprocessGeneratedCommandsEXTHandles, pGeneratedCommandsInfo, stateCommandBuffer); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo_unwrapped = vulkan_wrappers::UnwrapStructPtrHandles(pGeneratedCommandsInfo, handle_unwrap_memory); + + vulkan_wrappers::GetDeviceTable(commandBuffer)->CmdPreprocessGeneratedCommandsEXT(commandBuffer, pGeneratedCommandsInfo_unwrapped, stateCommandBuffer); + + CustomEncoderPostCall::Dispatch(manager, commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); +} + +VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, commandBuffer, isPreprocessed, pGeneratedCommandsInfo); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCmdExecuteGeneratedCommandsEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(commandBuffer); + encoder->EncodeUInt32Value(isPreprocessed); + EncodeStructPtr(encoder, pGeneratedCommandsInfo); + manager->EndCommandApiCallCapture(commandBuffer, TrackCmdExecuteGeneratedCommandsEXTHandles, pGeneratedCommandsInfo); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo_unwrapped = vulkan_wrappers::UnwrapStructPtrHandles(pGeneratedCommandsInfo, handle_unwrap_memory); + + vulkan_wrappers::GetDeviceTable(commandBuffer)->CmdExecuteGeneratedCommandsEXT(commandBuffer, isPreprocessed, pGeneratedCommandsInfo_unwrapped); + + CustomEncoderPostCall::Dispatch(manager, commandBuffer, isPreprocessed, pGeneratedCommandsInfo); +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) +{ + 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, pCreateInfo, pAllocator, pIndirectCommandsLayout); + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo_unwrapped = vulkan_wrappers::UnwrapStructPtrHandles(pCreateInfo, handle_unwrap_memory); + + VkResult result = vulkan_wrappers::GetDeviceTable(device)->CreateIndirectCommandsLayoutEXT(device, pCreateInfo_unwrapped, pAllocator, pIndirectCommandsLayout); + + if (result >= 0) + { + vulkan_wrappers::CreateWrappedHandle(device, vulkan_wrappers::NoParentWrapper::kHandleValue, pIndirectCommandsLayout, VulkanCaptureManager::GetUniqueId); + } + else + { + omit_output_data = true; + } + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCreateIndirectCommandsLayoutEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(device); + EncodeStructPtr(encoder, pCreateInfo); + EncodeStructPtr(encoder, pAllocator); + encoder->EncodeVulkanHandlePtr(pIndirectCommandsLayout, omit_output_data); + encoder->EncodeEnumValue(result); + manager->EndCreateApiCallCapture(result, device, pIndirectCommandsLayout, pCreateInfo); + } + + CustomEncoderPostCall::Dispatch(manager, result, device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + + return result; +} + +VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT( + VkDevice device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, device, indirectCommandsLayout, pAllocator); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkDestroyIndirectCommandsLayoutEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(device); + encoder->EncodeVulkanHandleValue(indirectCommandsLayout); + EncodeStructPtr(encoder, pAllocator); + manager->EndDestroyApiCallCapture(indirectCommandsLayout); + } + + ScopedDestroyLock exclusive_scoped_lock; + vulkan_wrappers::GetDeviceTable(device)->DestroyIndirectCommandsLayoutEXT(device, indirectCommandsLayout, pAllocator); + + CustomEncoderPostCall::Dispatch(manager, device, indirectCommandsLayout, pAllocator); + + vulkan_wrappers::DestroyWrappedHandle(indirectCommandsLayout); +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT( + VkDevice device, + const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectExecutionSetEXT* pIndirectExecutionSet) +{ + 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, pCreateInfo, pAllocator, pIndirectExecutionSet); + + VkResult result = vulkan_wrappers::GetDeviceTable(device)->CreateIndirectExecutionSetEXT(device, pCreateInfo, pAllocator, pIndirectExecutionSet); + + if (result >= 0) + { + vulkan_wrappers::CreateWrappedHandle(device, vulkan_wrappers::NoParentWrapper::kHandleValue, pIndirectExecutionSet, VulkanCaptureManager::GetUniqueId); + } + else + { + omit_output_data = true; + } + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkCreateIndirectExecutionSetEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(device); + EncodeStructPtr(encoder, pCreateInfo); + EncodeStructPtr(encoder, pAllocator); + encoder->EncodeVulkanHandlePtr(pIndirectExecutionSet, omit_output_data); + encoder->EncodeEnumValue(result); + manager->EndCreateApiCallCapture(result, device, pIndirectExecutionSet, pCreateInfo); + } + + CustomEncoderPostCall::Dispatch(manager, result, device, pCreateInfo, pAllocator, pIndirectExecutionSet); + + return result; +} + +VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks* pAllocator) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, device, indirectExecutionSet, pAllocator); + + auto encoder = manager->BeginTrackedApiCallCapture(format::ApiCallId::ApiCall_vkDestroyIndirectExecutionSetEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(device); + encoder->EncodeVulkanHandleValue(indirectExecutionSet); + EncodeStructPtr(encoder, pAllocator); + manager->EndDestroyApiCallCapture(indirectExecutionSet); + } + + ScopedDestroyLock exclusive_scoped_lock; + vulkan_wrappers::GetDeviceTable(device)->DestroyIndirectExecutionSetEXT(device, indirectExecutionSet, pAllocator); + + CustomEncoderPostCall::Dispatch(manager, device, indirectExecutionSet, pAllocator); + + vulkan_wrappers::DestroyWrappedHandle(indirectExecutionSet); +} + +VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); + + auto encoder = manager->BeginApiCallCapture(format::ApiCallId::ApiCall_vkUpdateIndirectExecutionSetPipelineEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(device); + encoder->EncodeVulkanHandleValue(indirectExecutionSet); + encoder->EncodeUInt32Value(executionSetWriteCount); + EncodeStructArray(encoder, pExecutionSetWrites, executionSetWriteCount); + manager->EndApiCallCapture(); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites_unwrapped = vulkan_wrappers::UnwrapStructArrayHandles(pExecutionSetWrites, executionSetWriteCount, handle_unwrap_memory); + + vulkan_wrappers::GetDeviceTable(device)->UpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites_unwrapped); + + CustomEncoderPostCall::Dispatch(manager, device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); +} + +VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) +{ + VulkanCaptureManager* manager = VulkanCaptureManager::Get(); + GFXRECON_ASSERT(manager != nullptr); + auto force_command_serialization = manager->GetForceCommandSerialization(); + std::shared_lock shared_api_call_lock; + std::unique_lock exclusive_api_call_lock; + if (force_command_serialization) + { + exclusive_api_call_lock = VulkanCaptureManager::AcquireExclusiveApiCallLock(); + } + else + { + shared_api_call_lock = VulkanCaptureManager::AcquireSharedApiCallLock(); + } + + CustomEncoderPreCall::Dispatch(manager, device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); + + auto encoder = manager->BeginApiCallCapture(format::ApiCallId::ApiCall_vkUpdateIndirectExecutionSetShaderEXT); + if (encoder) + { + encoder->EncodeVulkanHandleValue(device); + encoder->EncodeVulkanHandleValue(indirectExecutionSet); + encoder->EncodeUInt32Value(executionSetWriteCount); + EncodeStructArray(encoder, pExecutionSetWrites, executionSetWriteCount); + manager->EndApiCallCapture(); + } + + auto handle_unwrap_memory = manager->GetHandleUnwrapMemory(); + const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites_unwrapped = vulkan_wrappers::UnwrapStructArrayHandles(pExecutionSetWrites, executionSetWriteCount, handle_unwrap_memory); + + vulkan_wrappers::GetDeviceTable(device)->UpdateIndirectExecutionSetShaderEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites_unwrapped); + + CustomEncoderPostCall::Dispatch(manager, device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); +} + VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/framework/generated/generated_vulkan_api_call_encoders.h b/framework/generated/generated_vulkan_api_call_encoders.h index ad75c77c3c..e33adb661d 100644 --- a/framework/generated/generated_vulkan_api_call_encoders.h +++ b/framework/generated/generated_vulkan_api_call_encoders.h @@ -3245,6 +3245,11 @@ VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT( const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); +VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT( + VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange); + VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( VkDevice device, VkFramebuffer framebuffer, @@ -3284,6 +3289,55 @@ VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT( VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); +VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer); + +VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); + +VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); + +VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT( + VkDevice device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT( + VkDevice device, + const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectExecutionSetEXT* pIndirectExecutionSet); + +VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); + +VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); + VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, diff --git a/framework/generated/generated_vulkan_command_buffer_util.cpp b/framework/generated/generated_vulkan_command_buffer_util.cpp index ac54844e0d..0f7133d92c 100644 --- a/framework/generated/generated_vulkan_command_buffer_util.cpp +++ b/framework/generated/generated_vulkan_command_buffer_util.cpp @@ -1582,6 +1582,85 @@ void TrackCmdBindShadersEXTHandles(vulkan_wrappers::CommandBufferWrapper* wrappe } } +void TrackCmdPreprocessGeneratedCommandsEXTHandles(vulkan_wrappers::CommandBufferWrapper* wrapper, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) +{ + assert(wrapper != nullptr); + + if (pGeneratedCommandsInfo != nullptr) + { + auto pnext_header = reinterpret_cast(pGeneratedCommandsInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + { + auto pnext_value = reinterpret_cast(pnext_header); + if(pnext_value->pipeline != VK_NULL_HANDLE) wrapper->command_handles[vulkan_state_info::CommandHandleType::PipelineHandle].insert(vulkan_wrappers::GetWrappedId(pnext_value->pipeline)); + break; + } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pShaders != nullptr) + { + for (uint32_t pShaders_index = 0; pShaders_index < pnext_value->shaderCount; ++pShaders_index) + { + if(pnext_value->pShaders[pShaders_index] != VK_NULL_HANDLE) wrapper->command_handles[vulkan_state_info::CommandHandleType::ShaderEXTHandle].insert(vulkan_wrappers::GetWrappedId(pnext_value->pShaders[pShaders_index])); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + if(pGeneratedCommandsInfo->indirectExecutionSet != VK_NULL_HANDLE) wrapper->command_handles[vulkan_state_info::CommandHandleType::IndirectExecutionSetEXTHandle].insert(vulkan_wrappers::GetWrappedId(pGeneratedCommandsInfo->indirectExecutionSet)); + if(pGeneratedCommandsInfo->indirectCommandsLayout != VK_NULL_HANDLE) wrapper->command_handles[vulkan_state_info::CommandHandleType::IndirectCommandsLayoutEXTHandle].insert(vulkan_wrappers::GetWrappedId(pGeneratedCommandsInfo->indirectCommandsLayout)); + } + if(stateCommandBuffer != VK_NULL_HANDLE) wrapper->command_handles[vulkan_state_info::CommandHandleType::CommandBufferHandle].insert(vulkan_wrappers::GetWrappedId(stateCommandBuffer)); +} + +void TrackCmdExecuteGeneratedCommandsEXTHandles(vulkan_wrappers::CommandBufferWrapper* wrapper, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) +{ + assert(wrapper != nullptr); + + if (pGeneratedCommandsInfo != nullptr) + { + auto pnext_header = reinterpret_cast(pGeneratedCommandsInfo->pNext); + while (pnext_header) + { + switch (pnext_header->sType) + { + default: + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + { + auto pnext_value = reinterpret_cast(pnext_header); + if(pnext_value->pipeline != VK_NULL_HANDLE) wrapper->command_handles[vulkan_state_info::CommandHandleType::PipelineHandle].insert(vulkan_wrappers::GetWrappedId(pnext_value->pipeline)); + break; + } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + { + auto pnext_value = reinterpret_cast(pnext_header); + if (pnext_value->pShaders != nullptr) + { + for (uint32_t pShaders_index = 0; pShaders_index < pnext_value->shaderCount; ++pShaders_index) + { + if(pnext_value->pShaders[pShaders_index] != VK_NULL_HANDLE) wrapper->command_handles[vulkan_state_info::CommandHandleType::ShaderEXTHandle].insert(vulkan_wrappers::GetWrappedId(pnext_value->pShaders[pShaders_index])); + } + } + break; + } + } + pnext_header = pnext_header->pNext; + } + if(pGeneratedCommandsInfo->indirectExecutionSet != VK_NULL_HANDLE) wrapper->command_handles[vulkan_state_info::CommandHandleType::IndirectExecutionSetEXTHandle].insert(vulkan_wrappers::GetWrappedId(pGeneratedCommandsInfo->indirectExecutionSet)); + if(pGeneratedCommandsInfo->indirectCommandsLayout != VK_NULL_HANDLE) wrapper->command_handles[vulkan_state_info::CommandHandleType::IndirectCommandsLayoutEXTHandle].insert(vulkan_wrappers::GetWrappedId(pGeneratedCommandsInfo->indirectCommandsLayout)); + } +} + void TrackCmdBuildAccelerationStructuresKHRHandles(vulkan_wrappers::CommandBufferWrapper* wrapper, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos) { assert(wrapper != nullptr); diff --git a/framework/generated/generated_vulkan_command_buffer_util.h b/framework/generated/generated_vulkan_command_buffer_util.h index 6d8963687a..eb271c4636 100644 --- a/framework/generated/generated_vulkan_command_buffer_util.h +++ b/framework/generated/generated_vulkan_command_buffer_util.h @@ -251,6 +251,10 @@ void TrackCmdOpticalFlowExecuteNVHandles(vulkan_wrappers::CommandBufferWrapper* void TrackCmdBindShadersEXTHandles(vulkan_wrappers::CommandBufferWrapper* wrapper, uint32_t stageCount, const VkShaderEXT* pShaders); +void TrackCmdPreprocessGeneratedCommandsEXTHandles(vulkan_wrappers::CommandBufferWrapper* wrapper, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer); + +void TrackCmdExecuteGeneratedCommandsEXTHandles(vulkan_wrappers::CommandBufferWrapper* wrapper, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); + void TrackCmdBuildAccelerationStructuresKHRHandles(vulkan_wrappers::CommandBufferWrapper* wrapper, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos); void TrackCmdBuildAccelerationStructuresIndirectKHRHandles(vulkan_wrappers::CommandBufferWrapper* wrapper, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos); diff --git a/framework/generated/generated_vulkan_consumer.h b/framework/generated/generated_vulkan_consumer.h index 830fa65760..15fad1524f 100644 --- a/framework/generated/generated_vulkan_consumer.h +++ b/framework/generated/generated_vulkan_consumer.h @@ -4128,6 +4128,12 @@ class VulkanConsumer : public VulkanConsumerBase PointerDecoder* pStages, HandlePointerDecoder* pShaders) {} + virtual void Process_vkCmdSetDepthClampRangeEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkDepthClampModeEXT depthClampMode, + StructPointerDecoder* pDepthClampRange) {} + virtual void Process_vkGetFramebufferTilePropertiesQCOM( const ApiCallInfo& call_info, VkResult returnValue, @@ -4179,6 +4185,66 @@ class VulkanConsumer : public VulkanConsumerBase format::HandleId commandBuffer, VkImageAspectFlags aspectMask) {} + virtual void Process_vkGetGeneratedCommandsMemoryRequirementsEXT( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pMemoryRequirements) {} + + virtual void Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pGeneratedCommandsInfo, + format::HandleId stateCommandBuffer) {} + + virtual void Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkBool32 isPreprocessed, + StructPointerDecoder* pGeneratedCommandsInfo) {} + + virtual void Process_vkCreateIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectCommandsLayout) {} + + virtual void Process_vkDestroyIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectCommandsLayout, + StructPointerDecoder* pAllocator) {} + + virtual void Process_vkCreateIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectExecutionSet) {} + + virtual void Process_vkDestroyIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + StructPointerDecoder* pAllocator) {} + + virtual void Process_vkUpdateIndirectExecutionSetPipelineEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) {} + + virtual void Process_vkUpdateIndirectExecutionSetShaderEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) {} + virtual void Process_vkCreateAccelerationStructureKHR( const ApiCallInfo& call_info, VkResult returnValue, diff --git a/framework/generated/generated_vulkan_cpp_consumer.cpp b/framework/generated/generated_vulkan_cpp_consumer.cpp index 2b5ab8d16f..b85d576b50 100644 --- a/framework/generated/generated_vulkan_cpp_consumer.cpp +++ b/framework/generated/generated_vulkan_cpp_consumer.cpp @@ -14718,6 +14718,30 @@ void VulkanCppConsumer::Process_vkCmdBindShadersEXT( Post_APICall(format::ApiCallId::ApiCall_vkCmdBindShadersEXT); } +void VulkanCppConsumer::Process_vkCmdSetDepthClampRangeEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkDepthClampModeEXT depthClampMode, + StructPointerDecoder* pDepthClampRange) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + std::stringstream stream_pdepth_clamp_range; + std::string pdepth_clamp_range_struct = GenerateStruct_VkDepthClampRangeEXT(stream_pdepth_clamp_range, + pDepthClampRange->GetPointer(), + pDepthClampRange->GetMetaStructPointer(), + *this); + fprintf(file, "%s", stream_pdepth_clamp_range.str().c_str()); + pfn_loader_.AddMethodName("vkCmdSetDepthClampRangeEXT"); + fprintf(file, + "\t\tloaded_vkCmdSetDepthClampRangeEXT(%s, %s, &%s);\n", + this->GetHandle(commandBuffer).c_str(), + util::ToString(depthClampMode).c_str(), + pdepth_clamp_range_struct.c_str()); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkCmdSetDepthClampRangeEXT); +} + void VulkanCppConsumer::Process_vkCreateShadersEXT( const ApiCallInfo& call_info, VkResult returnValue, @@ -15016,6 +15040,259 @@ void VulkanCppConsumer::Process_vkCmdSetAttachmentFeedbackLoopEnableEXT( fprintf(file, "\t}\n"); Post_APICall(format::ApiCallId::ApiCall_vkCmdSetAttachmentFeedbackLoopEnableEXT); } +void VulkanCppConsumer::Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkBool32 isPreprocessed, + StructPointerDecoder* pGeneratedCommandsInfo) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + std::stringstream stream_pgenerated_commands_info; + std::string pgenerated_commands_info_struct = GenerateStruct_VkGeneratedCommandsInfoEXT(stream_pgenerated_commands_info, + pGeneratedCommandsInfo->GetPointer(), + pGeneratedCommandsInfo->GetMetaStructPointer(), + *this); + fprintf(file, "%s", stream_pgenerated_commands_info.str().c_str()); + pfn_loader_.AddMethodName("vkCmdExecuteGeneratedCommandsEXT"); + fprintf(file, + "\t\tloaded_vkCmdExecuteGeneratedCommandsEXT(%s, %u, &%s);\n", + this->GetHandle(commandBuffer).c_str(), + isPreprocessed, + pgenerated_commands_info_struct.c_str()); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkCmdExecuteGeneratedCommandsEXT); +} + +void VulkanCppConsumer::Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pGeneratedCommandsInfo, + format::HandleId stateCommandBuffer) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + std::stringstream stream_pgenerated_commands_info; + std::string pgenerated_commands_info_struct = GenerateStruct_VkGeneratedCommandsInfoEXT(stream_pgenerated_commands_info, + pGeneratedCommandsInfo->GetPointer(), + pGeneratedCommandsInfo->GetMetaStructPointer(), + *this); + fprintf(file, "%s", stream_pgenerated_commands_info.str().c_str()); + pfn_loader_.AddMethodName("vkCmdPreprocessGeneratedCommandsEXT"); + fprintf(file, + "\t\tloaded_vkCmdPreprocessGeneratedCommandsEXT(%s, &%s, %s);\n", + this->GetHandle(commandBuffer).c_str(), + pgenerated_commands_info_struct.c_str(), + this->GetHandle(stateCommandBuffer).c_str()); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkCmdPreprocessGeneratedCommandsEXT); +} + +void VulkanCppConsumer::Process_vkCreateIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectCommandsLayout) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + std::stringstream stream_pcreate_info; + std::string pcreate_info_struct = GenerateStruct_VkIndirectCommandsLayoutCreateInfoEXT(stream_pcreate_info, + pCreateInfo->GetPointer(), + pCreateInfo->GetMetaStructPointer(), + *this); + fprintf(file, "%s", stream_pcreate_info.str().c_str()); + std::string pindirect_commands_layout_name = "pIndirectCommandsLayout_" + std::to_string(this->GetNextId(VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT)); + AddKnownVariables("VkIndirectCommandsLayoutEXT", pindirect_commands_layout_name, pIndirectCommandsLayout->GetPointer()); + if (returnValue == VK_SUCCESS) { + this->AddHandles(pindirect_commands_layout_name, + pIndirectCommandsLayout->GetPointer()); + } + pfn_loader_.AddMethodName("vkCreateIndirectCommandsLayoutEXT"); + fprintf(file, + "\t\tVK_CALL_CHECK(loaded_vkCreateIndirectCommandsLayoutEXT(%s, &%s, %s, &%s), %s);\n", + this->GetHandle(device).c_str(), + pcreate_info_struct.c_str(), + "nullptr", + pindirect_commands_layout_name.c_str(), + util::ToString(returnValue).c_str()); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkCreateIndirectCommandsLayoutEXT); +} + +void VulkanCppConsumer::Process_vkCreateIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectExecutionSet) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + std::stringstream stream_pcreate_info; + std::string pcreate_info_struct = GenerateStruct_VkIndirectExecutionSetCreateInfoEXT(stream_pcreate_info, + pCreateInfo->GetPointer(), + pCreateInfo->GetMetaStructPointer(), + *this); + fprintf(file, "%s", stream_pcreate_info.str().c_str()); + std::string pindirect_execution_set_name = "pIndirectExecutionSet_" + std::to_string(this->GetNextId(VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT)); + AddKnownVariables("VkIndirectExecutionSetEXT", pindirect_execution_set_name, pIndirectExecutionSet->GetPointer()); + if (returnValue == VK_SUCCESS) { + this->AddHandles(pindirect_execution_set_name, + pIndirectExecutionSet->GetPointer()); + } + pfn_loader_.AddMethodName("vkCreateIndirectExecutionSetEXT"); + fprintf(file, + "\t\tVK_CALL_CHECK(loaded_vkCreateIndirectExecutionSetEXT(%s, &%s, %s, &%s), %s);\n", + this->GetHandle(device).c_str(), + pcreate_info_struct.c_str(), + "nullptr", + pindirect_execution_set_name.c_str(), + util::ToString(returnValue).c_str()); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkCreateIndirectExecutionSetEXT); +} + +void VulkanCppConsumer::Process_vkDestroyIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectCommandsLayout, + StructPointerDecoder* pAllocator) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + pfn_loader_.AddMethodName("vkDestroyIndirectCommandsLayoutEXT"); + fprintf(file, + "\t\tloaded_vkDestroyIndirectCommandsLayoutEXT(%s, %s, %s);\n", + this->GetHandle(device).c_str(), + this->GetHandle(indirectCommandsLayout).c_str(), + "nullptr"); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkDestroyIndirectCommandsLayoutEXT); +} + +void VulkanCppConsumer::Process_vkDestroyIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + StructPointerDecoder* pAllocator) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + pfn_loader_.AddMethodName("vkDestroyIndirectExecutionSetEXT"); + fprintf(file, + "\t\tloaded_vkDestroyIndirectExecutionSetEXT(%s, %s, %s);\n", + this->GetHandle(device).c_str(), + this->GetHandle(indirectExecutionSet).c_str(), + "nullptr"); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkDestroyIndirectExecutionSetEXT); +} + +void VulkanCppConsumer::Process_vkGetGeneratedCommandsMemoryRequirementsEXT( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pMemoryRequirements) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + std::stringstream stream_pinfo; + std::string pinfo_struct = GenerateStruct_VkGeneratedCommandsMemoryRequirementsInfoEXT(stream_pinfo, + pInfo->GetPointer(), + pInfo->GetMetaStructPointer(), + *this); + fprintf(file, "%s", stream_pinfo.str().c_str()); + std::string pmemory_requirements_name = "NULL"; + if (!pMemoryRequirements->IsNull()) { + pmemory_requirements_name = "pMemoryRequirements_" + std::to_string(this->GetNextId()); + fprintf(file, "\t\tVkMemoryRequirements2 %s = {};\n", pmemory_requirements_name.c_str()); + pmemory_requirements_name.insert(0, "&"); + } + pfn_loader_.AddMethodName("vkGetGeneratedCommandsMemoryRequirementsEXT"); + fprintf(file, + "\t\tloaded_vkGetGeneratedCommandsMemoryRequirementsEXT(%s, &%s, %s);\n", + this->GetHandle(device).c_str(), + pinfo_struct.c_str(), + pmemory_requirements_name.c_str()); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkGetGeneratedCommandsMemoryRequirementsEXT); +} + +void VulkanCppConsumer::Process_vkUpdateIndirectExecutionSetPipelineEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + std::stringstream stream_pexecution_set_writes; + std::string pexecution_set_writes_array = "NULL"; + PointerPairContainerGetPointer()), decltype(pExecutionSetWrites->GetMetaStructPointer())> pexecution_set_writes_pair{ pExecutionSetWrites->GetPointer(), pExecutionSetWrites->GetMetaStructPointer(), executionSetWriteCount }; + std::string pexecution_set_writes_names = toStringJoin(pexecution_set_writes_pair.begin(), + pexecution_set_writes_pair.end(), + [&](auto pair) {{ return GenerateStruct_VkWriteIndirectExecutionSetPipelineEXT(stream_pexecution_set_writes, pair.t1, pair.t2, *this); }}, + ", "); + if (stream_pexecution_set_writes.str().length() > 0) { + fprintf(file, "%s", stream_pexecution_set_writes.str().c_str()); + if (executionSetWriteCount == 1) { + pexecution_set_writes_array = "&" + pexecution_set_writes_names; + } else if (executionSetWriteCount > 1) { + pexecution_set_writes_array = "pExecutionSetWrites_" + std::to_string(this->GetNextId()); + fprintf(file, "\t\tVkWriteIndirectExecutionSetPipelineEXT %s[] = { %s };\n", pexecution_set_writes_array.c_str(), pexecution_set_writes_names.c_str()); + } + } + pfn_loader_.AddMethodName("vkUpdateIndirectExecutionSetPipelineEXT"); + fprintf(file, + "\t\tloaded_vkUpdateIndirectExecutionSetPipelineEXT(%s, %s, %u, %s);\n", + this->GetHandle(device).c_str(), + this->GetHandle(indirectExecutionSet).c_str(), + executionSetWriteCount, + pexecution_set_writes_array.c_str()); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkUpdateIndirectExecutionSetPipelineEXT); +} + +void VulkanCppConsumer::Process_vkUpdateIndirectExecutionSetShaderEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) +{ + FILE* file = GetFrameFile(); + fprintf(file, "\t{\n"); + std::stringstream stream_pexecution_set_writes; + std::string pexecution_set_writes_array = "NULL"; + PointerPairContainerGetPointer()), decltype(pExecutionSetWrites->GetMetaStructPointer())> pexecution_set_writes_pair{ pExecutionSetWrites->GetPointer(), pExecutionSetWrites->GetMetaStructPointer(), executionSetWriteCount }; + std::string pexecution_set_writes_names = toStringJoin(pexecution_set_writes_pair.begin(), + pexecution_set_writes_pair.end(), + [&](auto pair) {{ return GenerateStruct_VkWriteIndirectExecutionSetShaderEXT(stream_pexecution_set_writes, pair.t1, pair.t2, *this); }}, + ", "); + if (stream_pexecution_set_writes.str().length() > 0) { + fprintf(file, "%s", stream_pexecution_set_writes.str().c_str()); + if (executionSetWriteCount == 1) { + pexecution_set_writes_array = "&" + pexecution_set_writes_names; + } else if (executionSetWriteCount > 1) { + pexecution_set_writes_array = "pExecutionSetWrites_" + std::to_string(this->GetNextId()); + fprintf(file, "\t\tVkWriteIndirectExecutionSetShaderEXT %s[] = { %s };\n", pexecution_set_writes_array.c_str(), pexecution_set_writes_names.c_str()); + } + } + pfn_loader_.AddMethodName("vkUpdateIndirectExecutionSetShaderEXT"); + fprintf(file, + "\t\tloaded_vkUpdateIndirectExecutionSetShaderEXT(%s, %s, %u, %s);\n", + this->GetHandle(device).c_str(), + this->GetHandle(indirectExecutionSet).c_str(), + executionSetWriteCount, + pexecution_set_writes_array.c_str()); + fprintf(file, "\t}\n"); + Post_APICall(format::ApiCallId::ApiCall_vkUpdateIndirectExecutionSetShaderEXT); +} void VulkanCppConsumer::Process_vkCmdBuildAccelerationStructuresIndirectKHR( const ApiCallInfo& call_info, format::HandleId commandBuffer, diff --git a/framework/generated/generated_vulkan_cpp_consumer.h b/framework/generated/generated_vulkan_cpp_consumer.h index ad4ec37630..5e9748c0d9 100644 --- a/framework/generated/generated_vulkan_cpp_consumer.h +++ b/framework/generated/generated_vulkan_cpp_consumer.h @@ -3930,6 +3930,12 @@ class VulkanCppConsumer : public VulkanCppConsumerBase PointerDecoder* pStages, HandlePointerDecoder* pShaders) override; + virtual void Process_vkCmdSetDepthClampRangeEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkDepthClampModeEXT depthClampMode, + StructPointerDecoder* pDepthClampRange) override; + virtual void Process_vkCreateShadersEXT( const ApiCallInfo& call_info, VkResult returnValue, @@ -4000,6 +4006,65 @@ class VulkanCppConsumer : public VulkanCppConsumerBase const ApiCallInfo& call_info, format::HandleId commandBuffer, VkImageAspectFlags aspectMask) override; + virtual void Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkBool32 isPreprocessed, + StructPointerDecoder* pGeneratedCommandsInfo) override; + + virtual void Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pGeneratedCommandsInfo, + format::HandleId stateCommandBuffer) override; + + virtual void Process_vkCreateIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectCommandsLayout) override; + + virtual void Process_vkCreateIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectExecutionSet) override; + + virtual void Process_vkDestroyIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectCommandsLayout, + StructPointerDecoder* pAllocator) override; + + virtual void Process_vkDestroyIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + StructPointerDecoder* pAllocator) override; + + virtual void Process_vkGetGeneratedCommandsMemoryRequirementsEXT( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pMemoryRequirements) override; + + virtual void Process_vkUpdateIndirectExecutionSetPipelineEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) override; + + virtual void Process_vkUpdateIndirectExecutionSetShaderEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) override; virtual void Process_vkCmdBuildAccelerationStructuresIndirectKHR( const ApiCallInfo& call_info, format::HandleId commandBuffer, diff --git a/framework/generated/generated_vulkan_cpp_consumer_extension.cpp b/framework/generated/generated_vulkan_cpp_consumer_extension.cpp index 606c562fa1..259d01a5f1 100644 --- a/framework/generated/generated_vulkan_cpp_consumer_extension.cpp +++ b/framework/generated/generated_vulkan_cpp_consumer_extension.cpp @@ -5513,6 +5513,46 @@ std::string GenerateExtension(std::ostream& out, const void* struct_info, void* break; } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: { + auto casted_struct = reinterpret_cast(struct_info); + auto decoded_struct = reinterpret_cast(pnext_meta_data->GetMetaStructPointer()); + next_var_name = "&" + GenerateStruct_VkGeneratedCommandsPipelineInfoEXT(out, + casted_struct, + decoded_struct, + consumer); + + break; + } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: { + auto casted_struct = reinterpret_cast(struct_info); + auto decoded_struct = reinterpret_cast(pnext_meta_data->GetMetaStructPointer()); + next_var_name = "&" + GenerateStruct_VkGeneratedCommandsShaderInfoEXT(out, + casted_struct, + decoded_struct, + consumer); + + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: { + auto casted_struct = reinterpret_cast(struct_info); + auto decoded_struct = reinterpret_cast(pnext_meta_data->GetMetaStructPointer()); + next_var_name = "&" + GenerateStruct_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(out, + casted_struct, + decoded_struct, + consumer); + + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: { + auto casted_struct = reinterpret_cast(struct_info); + auto decoded_struct = reinterpret_cast(pnext_meta_data->GetMetaStructPointer()); + next_var_name = "&" + GenerateStruct_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(out, + casted_struct, + decoded_struct, + consumer); + + break; + } case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: { auto casted_struct = reinterpret_cast(struct_info); auto decoded_struct = reinterpret_cast(pnext_meta_data->GetMetaStructPointer()); @@ -5543,6 +5583,26 @@ std::string GenerateExtension(std::ostream& out, const void* struct_info, void* break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: { + auto casted_struct = reinterpret_cast(struct_info); + auto decoded_struct = reinterpret_cast(pnext_meta_data->GetMetaStructPointer()); + next_var_name = "&" + GenerateStruct_VkPhysicalDeviceDepthClampControlFeaturesEXT(out, + casted_struct, + decoded_struct, + consumer); + + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: { + auto casted_struct = reinterpret_cast(struct_info); + auto decoded_struct = reinterpret_cast(pnext_meta_data->GetMetaStructPointer()); + next_var_name = "&" + GenerateStruct_VkPipelineViewportDepthClampControlCreateInfoEXT(out, + casted_struct, + decoded_struct, + consumer); + + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: { auto casted_struct = reinterpret_cast(struct_info); auto decoded_struct = reinterpret_cast(pnext_meta_data->GetMetaStructPointer()); diff --git a/framework/generated/generated_vulkan_cpp_structs.cpp b/framework/generated/generated_vulkan_cpp_structs.cpp index e129747d40..c52c46332e 100644 --- a/framework/generated/generated_vulkan_cpp_structs.cpp +++ b/framework/generated/generated_vulkan_cpp_structs.cpp @@ -20054,6 +20054,18 @@ std::string GenerateStruct_VkPhysicalDeviceAntiLagFeaturesAMD(std::ostream &out, } +std::string GenerateStruct_VkDepthClampRangeEXT(std::ostream &out, const VkDepthClampRangeEXT* structInfo, Decoded_VkDepthClampRangeEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + struct_body << "\t" << structInfo->minDepthClamp << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxDepthClamp << ","; + std::string variable_name = consumer.AddStruct(struct_body, "depthClampRangeEXT"); + out << "\t\t" << "VkDepthClampRangeEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + std::string GenerateStruct_VkPhysicalDeviceShaderObjectFeaturesEXT(std::ostream &out, const VkPhysicalDeviceShaderObjectFeaturesEXT* structInfo, Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT* metaInfo, VulkanCppConsumerBase &consumer){ std::stringstream struct_body; std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); @@ -20905,6 +20917,388 @@ std::string GenerateStruct_VkPhysicalDeviceRayTracingValidationFeaturesNV(std::o } +std::string GenerateStruct_VkBindIndexBufferIndirectCommandEXT(std::ostream &out, const VkBindIndexBufferIndirectCommandEXT* structInfo, Decoded_VkBindIndexBufferIndirectCommandEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + struct_body << "\t" << structInfo->bufferAddress << "UL" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->size << "," << std::endl; + struct_body << "\t\t\t" << "VkIndexType(" << structInfo->indexType << ")" << ","; + std::string variable_name = consumer.AddStruct(struct_body, "bindIndexBufferIndirectCommandEXT"); + out << "\t\t" << "VkBindIndexBufferIndirectCommandEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkBindVertexBufferIndirectCommandEXT(std::ostream &out, const VkBindVertexBufferIndirectCommandEXT* structInfo, Decoded_VkBindVertexBufferIndirectCommandEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + struct_body << "\t" << structInfo->bufferAddress << "UL" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->size << "," << std::endl; + struct_body << "\t\t\t" << structInfo->stride << ","; + std::string variable_name = consumer.AddStruct(struct_body, "bindVertexBufferIndirectCommandEXT"); + out << "\t\t" << "VkBindVertexBufferIndirectCommandEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkDrawIndirectCountIndirectCommandEXT(std::ostream &out, const VkDrawIndirectCountIndirectCommandEXT* structInfo, Decoded_VkDrawIndirectCountIndirectCommandEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + struct_body << "\t" << structInfo->bufferAddress << "UL" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->stride << "," << std::endl; + struct_body << "\t\t\t" << structInfo->commandCount << ","; + std::string variable_name = consumer.AddStruct(struct_body, "drawIndirectCountIndirectCommandEXT"); + out << "\t\t" << "VkDrawIndirectCountIndirectCommandEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkGeneratedCommandsInfoEXT(std::ostream &out, const VkGeneratedCommandsInfoEXT* structInfo, Decoded_VkGeneratedCommandsInfoEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << "VkShaderStageFlags(" << structInfo->shaderStages << ")" << "," << std::endl; + struct_body << "\t\t\t" << consumer.GetHandle(metaInfo->indirectExecutionSet) << "," << std::endl; + struct_body << "\t\t\t" << consumer.GetHandle(metaInfo->indirectCommandsLayout) << "," << std::endl; + struct_body << "\t\t\t" << structInfo->indirectAddress << "UL" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->indirectAddressSize << "UL" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->preprocessAddress << "UL" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->preprocessSize << "UL" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxSequenceCount << "," << std::endl; + struct_body << "\t\t\t" << structInfo->sequenceCountAddress << "UL" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxDrawCount << ","; + std::string variable_name = consumer.AddStruct(struct_body, "generatedCommandsInfoEXT"); + out << "\t\t" << "VkGeneratedCommandsInfoEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkGeneratedCommandsMemoryRequirementsInfoEXT(std::ostream &out, const VkGeneratedCommandsMemoryRequirementsInfoEXT* structInfo, Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << consumer.GetHandle(metaInfo->indirectExecutionSet) << "," << std::endl; + struct_body << "\t\t\t" << consumer.GetHandle(metaInfo->indirectCommandsLayout) << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxSequenceCount << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxDrawCount << ","; + std::string variable_name = consumer.AddStruct(struct_body, "generatedCommandsMemoryRequirementsInfoEXT"); + out << "\t\t" << "VkGeneratedCommandsMemoryRequirementsInfoEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkGeneratedCommandsPipelineInfoEXT(std::ostream &out, const VkGeneratedCommandsPipelineInfoEXT* structInfo, Decoded_VkGeneratedCommandsPipelineInfoEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << consumer.GetHandle(metaInfo->pipeline) << ","; + std::string variable_name = consumer.AddStruct(struct_body, "generatedCommandsPipelineInfoEXT"); + out << "\t\t" << "VkGeneratedCommandsPipelineInfoEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkGeneratedCommandsShaderInfoEXT(std::ostream &out, const VkGeneratedCommandsShaderInfoEXT* structInfo, Decoded_VkGeneratedCommandsShaderInfoEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + std::string pshaders_array = "NULL"; + if (metaInfo->pShaders.GetPointer() != NULL && structInfo->shaderCount > 0) { + pshaders_array = "pshaders_array_" + std::to_string(consumer.GetNextId(VK_OBJECT_TYPE_SHADER_EXT)); + std::string pshaders_values = toStringJoin(metaInfo->pShaders.GetPointer(), + metaInfo->pShaders.GetPointer() + structInfo->shaderCount, + [&](const format::HandleId current) { return consumer.GetHandle(current); }, + ", "); + if (structInfo->shaderCount == 1) { + pshaders_array = "&" + pshaders_values; + } else if (structInfo->shaderCount > 1) { + out << "\t\t" << "VkShaderEXT " << pshaders_array << "[] = {" << pshaders_values << "};" << std::endl; + } + } + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << structInfo->shaderCount << "," << std::endl; + struct_body << "\t\t\t" << pshaders_array << ","; + std::string variable_name = consumer.AddStruct(struct_body, "generatedCommandsShaderInfoEXT"); + out << "\t\t" << "VkGeneratedCommandsShaderInfoEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkIndirectCommandsExecutionSetTokenEXT(std::ostream &out, const VkIndirectCommandsExecutionSetTokenEXT* structInfo, Decoded_VkIndirectCommandsExecutionSetTokenEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + struct_body << "\t" << "VkIndirectExecutionSetInfoTypeEXT(" << structInfo->type << ")" << "," << std::endl; + struct_body << "\t\t\t" << "VkShaderStageFlags(" << structInfo->shaderStages << ")" << ","; + std::string variable_name = consumer.AddStruct(struct_body, "indirectCommandsExecutionSetTokenEXT"); + out << "\t\t" << "VkIndirectCommandsExecutionSetTokenEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkIndirectCommandsIndexBufferTokenEXT(std::ostream &out, const VkIndirectCommandsIndexBufferTokenEXT* structInfo, Decoded_VkIndirectCommandsIndexBufferTokenEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + struct_body << "\t" << "VkIndirectCommandsInputModeFlagBitsEXT(" << structInfo->mode << ")" << ","; + std::string variable_name = consumer.AddStruct(struct_body, "indirectCommandsIndexBufferTokenEXT"); + out << "\t\t" << "VkIndirectCommandsIndexBufferTokenEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkIndirectCommandsLayoutCreateInfoEXT(std::ostream &out, const VkIndirectCommandsLayoutCreateInfoEXT* structInfo, Decoded_VkIndirectCommandsLayoutCreateInfoEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + std::string ptokens_array = "NULL"; + if (structInfo->pTokens != NULL) { + ptokens_array = "pTokens_" + std::to_string(consumer.GetNextId()); + std::string ptokens_names; + for (uint32_t idx = 0; idx < structInfo->tokenCount; idx++) { + std::string variable_name = "NULL"; + if (structInfo->pTokens + idx != NULL) { + variable_name = GenerateStruct_VkIndirectCommandsLayoutTokenEXT(out, + structInfo->pTokens + idx, + metaInfo->pTokens->GetMetaStructPointer() + idx, + consumer); + } + ptokens_names += variable_name + ", "; + } + out << "\t\t" << "VkIndirectCommandsLayoutTokenEXT " << ptokens_array << "[] = {" << ptokens_names << "};" << std::endl; + } + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << "VkIndirectCommandsLayoutUsageFlagsEXT(" << structInfo->flags << ")" << "," << std::endl; + struct_body << "\t\t\t" << "VkShaderStageFlags(" << structInfo->shaderStages << ")" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->indirectStride << "," << std::endl; + struct_body << "\t\t\t" << consumer.GetHandle(metaInfo->pipelineLayout) << "," << std::endl; + struct_body << "\t\t\t" << structInfo->tokenCount << "," << std::endl; + struct_body << "\t\t\t" << ptokens_array << ","; + std::string variable_name = consumer.AddStruct(struct_body, "indirectCommandsLayoutCreateInfoEXT"); + out << "\t\t" << "VkIndirectCommandsLayoutCreateInfoEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkIndirectCommandsPushConstantTokenEXT(std::ostream &out, const VkIndirectCommandsPushConstantTokenEXT* structInfo, Decoded_VkIndirectCommandsPushConstantTokenEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string update_range_info_var = GenerateStruct_VkPushConstantRange(out, + &structInfo->updateRange, + metaInfo->updateRange, + consumer); + struct_body << "\t" << update_range_info_var << ","; + std::string variable_name = consumer.AddStruct(struct_body, "indirectCommandsPushConstantTokenEXT"); + out << "\t\t" << "VkIndirectCommandsPushConstantTokenEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkIndirectCommandsVertexBufferTokenEXT(std::ostream &out, const VkIndirectCommandsVertexBufferTokenEXT* structInfo, Decoded_VkIndirectCommandsVertexBufferTokenEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + struct_body << "\t" << structInfo->vertexBindingUnit << ","; + std::string variable_name = consumer.AddStruct(struct_body, "indirectCommandsVertexBufferTokenEXT"); + out << "\t\t" << "VkIndirectCommandsVertexBufferTokenEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkIndirectExecutionSetPipelineInfoEXT(std::ostream &out, const VkIndirectExecutionSetPipelineInfoEXT* structInfo, Decoded_VkIndirectExecutionSetPipelineInfoEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << consumer.GetHandle(metaInfo->initialPipeline) << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxPipelineCount << ","; + std::string variable_name = consumer.AddStruct(struct_body, "indirectExecutionSetPipelineInfoEXT"); + out << "\t\t" << "VkIndirectExecutionSetPipelineInfoEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkIndirectExecutionSetShaderInfoEXT(std::ostream &out, const VkIndirectExecutionSetShaderInfoEXT* structInfo, Decoded_VkIndirectExecutionSetShaderInfoEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + std::string pinitial_shaders_array = "NULL"; + if (metaInfo->pInitialShaders.GetPointer() != NULL && structInfo->shaderCount > 0) { + pinitial_shaders_array = "pinitial_shaders_array_" + std::to_string(consumer.GetNextId(VK_OBJECT_TYPE_SHADER_EXT)); + std::string pinitial_shaders_values = toStringJoin(metaInfo->pInitialShaders.GetPointer(), + metaInfo->pInitialShaders.GetPointer() + structInfo->shaderCount, + [&](const format::HandleId current) { return consumer.GetHandle(current); }, + ", "); + if (structInfo->shaderCount == 1) { + pinitial_shaders_array = "&" + pinitial_shaders_values; + } else if (structInfo->shaderCount > 1) { + out << "\t\t" << "VkShaderEXT " << pinitial_shaders_array << "[] = {" << pinitial_shaders_values << "};" << std::endl; + } + } + std::string pset_layout_infos_array = "NULL"; + if (structInfo->pSetLayoutInfos != NULL) { + pset_layout_infos_array = "pSetLayoutInfos_" + std::to_string(consumer.GetNextId()); + std::string pset_layout_infos_names; + for (uint32_t idx = 0; idx < structInfo->shaderCount; idx++) { + std::string variable_name = "NULL"; + if (structInfo->pSetLayoutInfos + idx != NULL) { + variable_name = GenerateStruct_VkIndirectExecutionSetShaderLayoutInfoEXT(out, + structInfo->pSetLayoutInfos + idx, + metaInfo->pSetLayoutInfos->GetMetaStructPointer() + idx, + consumer); + } + pset_layout_infos_names += variable_name + ", "; + } + out << "\t\t" << "VkIndirectExecutionSetShaderLayoutInfoEXT " << pset_layout_infos_array << "[] = {" << pset_layout_infos_names << "};" << std::endl; + } + std::string ppush_constant_ranges_array = "NULL"; + if (structInfo->pPushConstantRanges != NULL) { + ppush_constant_ranges_array = "pPushConstantRanges_" + std::to_string(consumer.GetNextId()); + std::string ppush_constant_ranges_names; + for (uint32_t idx = 0; idx < structInfo->pushConstantRangeCount; idx++) { + std::string variable_name = "NULL"; + if (structInfo->pPushConstantRanges + idx != NULL) { + variable_name = GenerateStruct_VkPushConstantRange(out, + structInfo->pPushConstantRanges + idx, + metaInfo->pPushConstantRanges->GetMetaStructPointer() + idx, + consumer); + } + ppush_constant_ranges_names += variable_name + ", "; + } + out << "\t\t" << "VkPushConstantRange " << ppush_constant_ranges_array << "[] = {" << ppush_constant_ranges_names << "};" << std::endl; + } + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << structInfo->shaderCount << "," << std::endl; + struct_body << "\t\t\t" << pinitial_shaders_array << "," << std::endl; + struct_body << "\t\t\t" << pset_layout_infos_array << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxShaderCount << "," << std::endl; + struct_body << "\t\t\t" << structInfo->pushConstantRangeCount << "," << std::endl; + struct_body << "\t\t\t" << ppush_constant_ranges_array << ","; + std::string variable_name = consumer.AddStruct(struct_body, "indirectExecutionSetShaderInfoEXT"); + out << "\t\t" << "VkIndirectExecutionSetShaderInfoEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkIndirectExecutionSetShaderLayoutInfoEXT(std::ostream &out, const VkIndirectExecutionSetShaderLayoutInfoEXT* structInfo, Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + std::string pset_layouts_array = "NULL"; + if (metaInfo->pSetLayouts.GetPointer() != NULL && structInfo->setLayoutCount > 0) { + pset_layouts_array = "pset_layouts_array_" + std::to_string(consumer.GetNextId(VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT)); + std::string pset_layouts_values = toStringJoin(metaInfo->pSetLayouts.GetPointer(), + metaInfo->pSetLayouts.GetPointer() + structInfo->setLayoutCount, + [&](const format::HandleId current) { return consumer.GetHandle(current); }, + ", "); + if (structInfo->setLayoutCount == 1) { + pset_layouts_array = "&" + pset_layouts_values; + } else if (structInfo->setLayoutCount > 1) { + out << "\t\t" << "VkDescriptorSetLayout " << pset_layouts_array << "[] = {" << pset_layouts_values << "};" << std::endl; + } + } + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << structInfo->setLayoutCount << "," << std::endl; + struct_body << "\t\t\t" << pset_layouts_array << ","; + std::string variable_name = consumer.AddStruct(struct_body, "indirectExecutionSetShaderLayoutInfoEXT"); + out << "\t\t" << "VkIndirectExecutionSetShaderLayoutInfoEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(std::ostream &out, const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* structInfo, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << structInfo->deviceGeneratedCommands << "," << std::endl; + struct_body << "\t\t\t" << structInfo->dynamicGeneratedPipelineLayout << ","; + std::string variable_name = consumer.AddStruct(struct_body, "physicalDeviceDeviceGeneratedCommandsFeaturesEXT"); + out << "\t\t" << "VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(std::ostream &out, const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* structInfo, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxIndirectPipelineCount << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxIndirectShaderObjectCount << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxIndirectSequenceCount << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxIndirectCommandsTokenCount << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxIndirectCommandsTokenOffset << "," << std::endl; + struct_body << "\t\t\t" << structInfo->maxIndirectCommandsIndirectStride << "," << std::endl; + struct_body << "\t\t\t" << "VkIndirectCommandsInputModeFlagsEXT(" << structInfo->supportedIndirectCommandsInputModes << ")" << "," << std::endl; + struct_body << "\t\t\t" << "VkShaderStageFlags(" << structInfo->supportedIndirectCommandsShaderStages << ")" << "," << std::endl; + struct_body << "\t\t\t" << "VkShaderStageFlags(" << structInfo->supportedIndirectCommandsShaderStagesPipelineBinding << ")" << "," << std::endl; + struct_body << "\t\t\t" << "VkShaderStageFlags(" << structInfo->supportedIndirectCommandsShaderStagesShaderBinding << ")" << "," << std::endl; + struct_body << "\t\t\t" << structInfo->deviceGeneratedCommandsTransformFeedback << "," << std::endl; + struct_body << "\t\t\t" << structInfo->deviceGeneratedCommandsMultiDrawIndirectCount << ","; + std::string variable_name = consumer.AddStruct(struct_body, "physicalDeviceDeviceGeneratedCommandsPropertiesEXT"); + out << "\t\t" << "VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkWriteIndirectExecutionSetPipelineEXT(std::ostream &out, const VkWriteIndirectExecutionSetPipelineEXT* structInfo, Decoded_VkWriteIndirectExecutionSetPipelineEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << structInfo->index << "," << std::endl; + struct_body << "\t\t\t" << consumer.GetHandle(metaInfo->pipeline) << ","; + std::string variable_name = consumer.AddStruct(struct_body, "writeIndirectExecutionSetPipelineEXT"); + out << "\t\t" << "VkWriteIndirectExecutionSetPipelineEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkWriteIndirectExecutionSetShaderEXT(std::ostream &out, const VkWriteIndirectExecutionSetShaderEXT* structInfo, Decoded_VkWriteIndirectExecutionSetShaderEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << structInfo->index << "," << std::endl; + struct_body << "\t\t\t" << consumer.GetHandle(metaInfo->shader) << ","; + std::string variable_name = consumer.AddStruct(struct_body, "writeIndirectExecutionSetShaderEXT"); + out << "\t\t" << "VkWriteIndirectExecutionSetShaderEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + std::string GenerateStruct_VkImageAlignmentControlCreateInfoMESA(std::ostream &out, const VkImageAlignmentControlCreateInfoMESA* structInfo, Decoded_VkImageAlignmentControlCreateInfoMESA* metaInfo, VulkanCppConsumerBase &consumer){ std::stringstream struct_body; std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); @@ -20947,6 +21341,43 @@ std::string GenerateStruct_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(s } +std::string GenerateStruct_VkPhysicalDeviceDepthClampControlFeaturesEXT(std::ostream &out, const VkPhysicalDeviceDepthClampControlFeaturesEXT* structInfo, Decoded_VkPhysicalDeviceDepthClampControlFeaturesEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << structInfo->depthClampControl << ","; + std::string variable_name = consumer.AddStruct(struct_body, "physicalDeviceDepthClampControlFeaturesEXT"); + out << "\t\t" << "VkPhysicalDeviceDepthClampControlFeaturesEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + +std::string GenerateStruct_VkPipelineViewportDepthClampControlCreateInfoEXT(std::ostream &out, const VkPipelineViewportDepthClampControlCreateInfoEXT* structInfo, Decoded_VkPipelineViewportDepthClampControlCreateInfoEXT* metaInfo, VulkanCppConsumerBase &consumer){ + std::stringstream struct_body; + std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); + std::string pdepth_clamp_range_struct = "NULL"; + if (structInfo->pDepthClampRange != NULL) { + pdepth_clamp_range_struct = GenerateStruct_VkDepthClampRangeEXT(out, + structInfo->pDepthClampRange, + metaInfo->pDepthClampRange->GetMetaStructPointer(), + consumer); + pdepth_clamp_range_struct.insert(0, "&"); + } + struct_body << "\t" << "VkStructureType(" << structInfo->sType << ")" << "," << std::endl; + struct_body << "\t\t\t" << pnext_name << "," << std::endl; + struct_body << "\t\t\t" << "VkDepthClampModeEXT(" << structInfo->depthClampMode << ")" << "," << std::endl; + struct_body << "\t\t\t" << pdepth_clamp_range_struct << ","; + std::string variable_name = consumer.AddStruct(struct_body, "pipelineViewportDepthClampControlCreateInfoEXT"); + out << "\t\t" << "VkPipelineViewportDepthClampControlCreateInfoEXT " << variable_name << " {" << std::endl; + out << "\t\t" << struct_body.str() << std::endl; + out << "\t\t" << "};" << std::endl; + return variable_name; +} + + std::string GenerateStruct_VkAccelerationStructureBuildGeometryInfoKHR(std::ostream &out, const VkAccelerationStructureBuildGeometryInfoKHR* structInfo, Decoded_VkAccelerationStructureBuildGeometryInfoKHR* metaInfo, VulkanCppConsumerBase &consumer){ std::stringstream struct_body; std::string pnext_name = GenerateExtension(out, structInfo->pNext, metaInfo->pNext, consumer); diff --git a/framework/generated/generated_vulkan_cpp_structs.h b/framework/generated/generated_vulkan_cpp_structs.h index 0c6ab935a9..894b535b16 100644 --- a/framework/generated/generated_vulkan_cpp_structs.h +++ b/framework/generated/generated_vulkan_cpp_structs.h @@ -1987,6 +1987,8 @@ std::string GenerateStruct_VkAntiLagPresentationInfoAMD(std::ostream &out, const std::string GenerateStruct_VkPhysicalDeviceAntiLagFeaturesAMD(std::ostream &out, const VkPhysicalDeviceAntiLagFeaturesAMD* structInfo, Decoded_VkPhysicalDeviceAntiLagFeaturesAMD* metaInfo, VulkanCppConsumerBase &consumer); +std::string GenerateStruct_VkDepthClampRangeEXT(std::ostream &out, const VkDepthClampRangeEXT* structInfo, Decoded_VkDepthClampRangeEXT* metaInfo, VulkanCppConsumerBase &consumer); + std::string GenerateStruct_VkPhysicalDeviceShaderObjectFeaturesEXT(std::ostream &out, const VkPhysicalDeviceShaderObjectFeaturesEXT* structInfo, Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT* metaInfo, VulkanCppConsumerBase &consumer); std::string GenerateStruct_VkPhysicalDeviceShaderObjectPropertiesEXT(std::ostream &out, const VkPhysicalDeviceShaderObjectPropertiesEXT* structInfo, Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT* metaInfo, VulkanCppConsumerBase &consumer); @@ -2085,12 +2087,54 @@ std::string GenerateStruct_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT std::string GenerateStruct_VkPhysicalDeviceRayTracingValidationFeaturesNV(std::ostream &out, const VkPhysicalDeviceRayTracingValidationFeaturesNV* structInfo, Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV* metaInfo, VulkanCppConsumerBase &consumer); +std::string GenerateStruct_VkBindIndexBufferIndirectCommandEXT(std::ostream &out, const VkBindIndexBufferIndirectCommandEXT* structInfo, Decoded_VkBindIndexBufferIndirectCommandEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkBindVertexBufferIndirectCommandEXT(std::ostream &out, const VkBindVertexBufferIndirectCommandEXT* structInfo, Decoded_VkBindVertexBufferIndirectCommandEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkDrawIndirectCountIndirectCommandEXT(std::ostream &out, const VkDrawIndirectCountIndirectCommandEXT* structInfo, Decoded_VkDrawIndirectCountIndirectCommandEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkGeneratedCommandsInfoEXT(std::ostream &out, const VkGeneratedCommandsInfoEXT* structInfo, Decoded_VkGeneratedCommandsInfoEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkGeneratedCommandsMemoryRequirementsInfoEXT(std::ostream &out, const VkGeneratedCommandsMemoryRequirementsInfoEXT* structInfo, Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkGeneratedCommandsPipelineInfoEXT(std::ostream &out, const VkGeneratedCommandsPipelineInfoEXT* structInfo, Decoded_VkGeneratedCommandsPipelineInfoEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkGeneratedCommandsShaderInfoEXT(std::ostream &out, const VkGeneratedCommandsShaderInfoEXT* structInfo, Decoded_VkGeneratedCommandsShaderInfoEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkIndirectCommandsExecutionSetTokenEXT(std::ostream &out, const VkIndirectCommandsExecutionSetTokenEXT* structInfo, Decoded_VkIndirectCommandsExecutionSetTokenEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkIndirectCommandsIndexBufferTokenEXT(std::ostream &out, const VkIndirectCommandsIndexBufferTokenEXT* structInfo, Decoded_VkIndirectCommandsIndexBufferTokenEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkIndirectCommandsLayoutCreateInfoEXT(std::ostream &out, const VkIndirectCommandsLayoutCreateInfoEXT* structInfo, Decoded_VkIndirectCommandsLayoutCreateInfoEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkIndirectCommandsPushConstantTokenEXT(std::ostream &out, const VkIndirectCommandsPushConstantTokenEXT* structInfo, Decoded_VkIndirectCommandsPushConstantTokenEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkIndirectCommandsVertexBufferTokenEXT(std::ostream &out, const VkIndirectCommandsVertexBufferTokenEXT* structInfo, Decoded_VkIndirectCommandsVertexBufferTokenEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkIndirectExecutionSetPipelineInfoEXT(std::ostream &out, const VkIndirectExecutionSetPipelineInfoEXT* structInfo, Decoded_VkIndirectExecutionSetPipelineInfoEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkIndirectExecutionSetShaderInfoEXT(std::ostream &out, const VkIndirectExecutionSetShaderInfoEXT* structInfo, Decoded_VkIndirectExecutionSetShaderInfoEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkIndirectExecutionSetShaderLayoutInfoEXT(std::ostream &out, const VkIndirectExecutionSetShaderLayoutInfoEXT* structInfo, Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT(std::ostream &out, const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* structInfo, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT(std::ostream &out, const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* structInfo, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkWriteIndirectExecutionSetPipelineEXT(std::ostream &out, const VkWriteIndirectExecutionSetPipelineEXT* structInfo, Decoded_VkWriteIndirectExecutionSetPipelineEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkWriteIndirectExecutionSetShaderEXT(std::ostream &out, const VkWriteIndirectExecutionSetShaderEXT* structInfo, Decoded_VkWriteIndirectExecutionSetShaderEXT* metaInfo, VulkanCppConsumerBase &consumer); + std::string GenerateStruct_VkImageAlignmentControlCreateInfoMESA(std::ostream &out, const VkImageAlignmentControlCreateInfoMESA* structInfo, Decoded_VkImageAlignmentControlCreateInfoMESA* metaInfo, VulkanCppConsumerBase &consumer); std::string GenerateStruct_VkPhysicalDeviceImageAlignmentControlFeaturesMESA(std::ostream &out, const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* structInfo, Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* metaInfo, VulkanCppConsumerBase &consumer); std::string GenerateStruct_VkPhysicalDeviceImageAlignmentControlPropertiesMESA(std::ostream &out, const VkPhysicalDeviceImageAlignmentControlPropertiesMESA* structInfo, Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* metaInfo, VulkanCppConsumerBase &consumer); +std::string GenerateStruct_VkPhysicalDeviceDepthClampControlFeaturesEXT(std::ostream &out, const VkPhysicalDeviceDepthClampControlFeaturesEXT* structInfo, Decoded_VkPhysicalDeviceDepthClampControlFeaturesEXT* metaInfo, VulkanCppConsumerBase &consumer); + +std::string GenerateStruct_VkPipelineViewportDepthClampControlCreateInfoEXT(std::ostream &out, const VkPipelineViewportDepthClampControlCreateInfoEXT* structInfo, Decoded_VkPipelineViewportDepthClampControlCreateInfoEXT* metaInfo, VulkanCppConsumerBase &consumer); + std::string GenerateStruct_VkAccelerationStructureBuildGeometryInfoKHR(std::ostream &out, const VkAccelerationStructureBuildGeometryInfoKHR* structInfo, Decoded_VkAccelerationStructureBuildGeometryInfoKHR* metaInfo, VulkanCppConsumerBase &consumer); std::string GenerateStruct_VkAccelerationStructureBuildRangeInfoKHR(std::ostream &out, const VkAccelerationStructureBuildRangeInfoKHR* structInfo, Decoded_VkAccelerationStructureBuildRangeInfoKHR* metaInfo, VulkanCppConsumerBase &consumer); diff --git a/framework/generated/generated_vulkan_decoder.cpp b/framework/generated/generated_vulkan_decoder.cpp index 52f0e950eb..fb3d59cb05 100644 --- a/framework/generated/generated_vulkan_decoder.cpp +++ b/framework/generated/generated_vulkan_decoder.cpp @@ -12984,6 +12984,26 @@ size_t VulkanDecoder::Decode_vkCmdBindShadersEXT(const ApiCallInfo& call_info, c return bytes_read; } +size_t VulkanDecoder::Decode_vkCmdSetDepthClampRangeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkDepthClampModeEXT depthClampMode; + StructPointerDecoder pDepthClampRange; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeEnumValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &depthClampMode); + bytes_read += pDepthClampRange.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdSetDepthClampRangeEXT(call_info, commandBuffer, depthClampMode, &pDepthClampRange); + } + + return bytes_read; +} + size_t VulkanDecoder::Decode_vkGetFramebufferTilePropertiesQCOM(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) { size_t bytes_read = 0; @@ -13150,6 +13170,198 @@ size_t VulkanDecoder::Decode_vkCmdSetAttachmentFeedbackLoopEnableEXT(const ApiCa return bytes_read; } +size_t VulkanDecoder::Decode_vkGetGeneratedCommandsMemoryRequirementsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pInfo; + StructPointerDecoder pMemoryRequirements; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pMemoryRequirements.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkGetGeneratedCommandsMemoryRequirementsEXT(call_info, device, &pInfo, &pMemoryRequirements); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkCmdPreprocessGeneratedCommandsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + StructPointerDecoder pGeneratedCommandsInfo; + format::HandleId stateCommandBuffer; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += pGeneratedCommandsInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &stateCommandBuffer); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdPreprocessGeneratedCommandsEXT(call_info, commandBuffer, &pGeneratedCommandsInfo, stateCommandBuffer); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkCmdExecuteGeneratedCommandsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId commandBuffer; + VkBool32 isPreprocessed; + StructPointerDecoder pGeneratedCommandsInfo; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &commandBuffer); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &isPreprocessed); + bytes_read += pGeneratedCommandsInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkCmdExecuteGeneratedCommandsEXT(call_info, commandBuffer, isPreprocessed, &pGeneratedCommandsInfo); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkCreateIndirectCommandsLayoutEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pIndirectCommandsLayout; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pIndirectCommandsLayout.Decode((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_vkCreateIndirectCommandsLayoutEXT(call_info, return_value, device, &pCreateInfo, &pAllocator, &pIndirectCommandsLayout); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkDestroyIndirectCommandsLayoutEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId indirectCommandsLayout; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indirectCommandsLayout); + bytes_read += pAllocator.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkDestroyIndirectCommandsLayoutEXT(call_info, device, indirectCommandsLayout, &pAllocator); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkCreateIndirectExecutionSetEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + StructPointerDecoder pCreateInfo; + StructPointerDecoder pAllocator; + HandlePointerDecoder pIndirectExecutionSet; + VkResult return_value; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += pCreateInfo.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pAllocator.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + bytes_read += pIndirectExecutionSet.Decode((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_vkCreateIndirectExecutionSetEXT(call_info, return_value, device, &pCreateInfo, &pAllocator, &pIndirectExecutionSet); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkDestroyIndirectExecutionSetEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId indirectExecutionSet; + StructPointerDecoder pAllocator; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indirectExecutionSet); + bytes_read += pAllocator.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkDestroyIndirectExecutionSetEXT(call_info, device, indirectExecutionSet, &pAllocator); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkUpdateIndirectExecutionSetPipelineEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId indirectExecutionSet; + uint32_t executionSetWriteCount; + StructPointerDecoder pExecutionSetWrites; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indirectExecutionSet); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &executionSetWriteCount); + bytes_read += pExecutionSetWrites.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkUpdateIndirectExecutionSetPipelineEXT(call_info, device, indirectExecutionSet, executionSetWriteCount, &pExecutionSetWrites); + } + + return bytes_read; +} + +size_t VulkanDecoder::Decode_vkUpdateIndirectExecutionSetShaderEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) +{ + size_t bytes_read = 0; + + format::HandleId device; + format::HandleId indirectExecutionSet; + uint32_t executionSetWriteCount; + StructPointerDecoder pExecutionSetWrites; + + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &device); + bytes_read += ValueDecoder::DecodeHandleIdValue((parameter_buffer + bytes_read), (buffer_size - bytes_read), &indirectExecutionSet); + bytes_read += ValueDecoder::DecodeUInt32Value((parameter_buffer + bytes_read), (buffer_size - bytes_read), &executionSetWriteCount); + bytes_read += pExecutionSetWrites.Decode((parameter_buffer + bytes_read), (buffer_size - bytes_read)); + + for (auto consumer : GetConsumers()) + { + consumer->Process_vkUpdateIndirectExecutionSetShaderEXT(call_info, device, indirectExecutionSet, executionSetWriteCount, &pExecutionSetWrites); + } + + return bytes_read; +} + size_t VulkanDecoder::Decode_vkCreateAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size) { size_t bytes_read = 0; @@ -15468,6 +15680,9 @@ void VulkanDecoder::DecodeFunctionCall(format::ApiCallId call_id, case format::ApiCallId::ApiCall_vkCmdBindShadersEXT: Decode_vkCmdBindShadersEXT(call_info, parameter_buffer, buffer_size); break; + case format::ApiCallId::ApiCall_vkCmdSetDepthClampRangeEXT: + Decode_vkCmdSetDepthClampRangeEXT(call_info, parameter_buffer, buffer_size); + break; case format::ApiCallId::ApiCall_vkGetFramebufferTilePropertiesQCOM: Decode_vkGetFramebufferTilePropertiesQCOM(call_info, parameter_buffer, buffer_size); break; @@ -15492,6 +15707,33 @@ void VulkanDecoder::DecodeFunctionCall(format::ApiCallId call_id, case format::ApiCallId::ApiCall_vkCmdSetAttachmentFeedbackLoopEnableEXT: Decode_vkCmdSetAttachmentFeedbackLoopEnableEXT(call_info, parameter_buffer, buffer_size); break; + case format::ApiCallId::ApiCall_vkGetGeneratedCommandsMemoryRequirementsEXT: + Decode_vkGetGeneratedCommandsMemoryRequirementsEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdPreprocessGeneratedCommandsEXT: + Decode_vkCmdPreprocessGeneratedCommandsEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCmdExecuteGeneratedCommandsEXT: + Decode_vkCmdExecuteGeneratedCommandsEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateIndirectCommandsLayoutEXT: + Decode_vkCreateIndirectCommandsLayoutEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyIndirectCommandsLayoutEXT: + Decode_vkDestroyIndirectCommandsLayoutEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkCreateIndirectExecutionSetEXT: + Decode_vkCreateIndirectExecutionSetEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkDestroyIndirectExecutionSetEXT: + Decode_vkDestroyIndirectExecutionSetEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkUpdateIndirectExecutionSetPipelineEXT: + Decode_vkUpdateIndirectExecutionSetPipelineEXT(call_info, parameter_buffer, buffer_size); + break; + case format::ApiCallId::ApiCall_vkUpdateIndirectExecutionSetShaderEXT: + Decode_vkUpdateIndirectExecutionSetShaderEXT(call_info, parameter_buffer, buffer_size); + break; case format::ApiCallId::ApiCall_vkCreateAccelerationStructureKHR: Decode_vkCreateAccelerationStructureKHR(call_info, parameter_buffer, buffer_size); break; diff --git a/framework/generated/generated_vulkan_decoder.h b/framework/generated/generated_vulkan_decoder.h index a11caf170e..454b983c2d 100644 --- a/framework/generated/generated_vulkan_decoder.h +++ b/framework/generated/generated_vulkan_decoder.h @@ -1256,6 +1256,8 @@ class VulkanDecoder : public VulkanDecoderBase size_t Decode_vkCmdBindShadersEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + size_t Decode_vkCmdSetDepthClampRangeEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + size_t Decode_vkGetFramebufferTilePropertiesQCOM(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); size_t Decode_vkGetDynamicRenderingTilePropertiesQCOM(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); @@ -1272,6 +1274,24 @@ class VulkanDecoder : public VulkanDecoderBase size_t Decode_vkCmdSetAttachmentFeedbackLoopEnableEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + size_t Decode_vkGetGeneratedCommandsMemoryRequirementsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdPreprocessGeneratedCommandsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCmdExecuteGeneratedCommandsEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateIndirectCommandsLayoutEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyIndirectCommandsLayoutEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkCreateIndirectExecutionSetEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkDestroyIndirectExecutionSetEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkUpdateIndirectExecutionSetPipelineEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + + size_t Decode_vkUpdateIndirectExecutionSetShaderEXT(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); + size_t Decode_vkCreateAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); size_t Decode_vkDestroyAccelerationStructureKHR(const ApiCallInfo& call_info, const uint8_t* parameter_buffer, size_t buffer_size); diff --git a/framework/generated/generated_vulkan_dispatch_table.h b/framework/generated/generated_vulkan_dispatch_table.h index fe8033c365..7db4f79351 100644 --- a/framework/generated/generated_vulkan_dispatch_table.h +++ b/framework/generated/generated_vulkan_dispatch_table.h @@ -673,6 +673,7 @@ inline VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT(VkDevice, uint32_t, const inline VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT(VkDevice, VkShaderEXT, const VkAllocationCallbacks*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDestroyShaderEXT was called, resulting in no-op behavior."); } inline VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT(VkDevice, VkShaderEXT, size_t*, void*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetShaderBinaryDataEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } inline VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT(VkCommandBuffer, uint32_t, const VkShaderStageFlagBits*, const VkShaderEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdBindShadersEXT was called, resulting in no-op behavior."); } +inline VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampRangeEXT(VkCommandBuffer, VkDepthClampModeEXT, const VkDepthClampRangeEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdSetDepthClampRangeEXT was called, resulting in no-op behavior."); } inline VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM(VkDevice, VkFramebuffer, uint32_t*, VkTilePropertiesQCOM*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetFramebufferTilePropertiesQCOM was called, resulting in no-op behavior."); return VK_SUCCESS; } inline VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM(VkDevice, const VkRenderingInfo*, VkTilePropertiesQCOM*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetDynamicRenderingTilePropertiesQCOM was called, resulting in no-op behavior."); return VK_SUCCESS; } inline VKAPI_ATTR VkResult VKAPI_CALL SetLatencySleepModeNV(VkDevice, VkSwapchainKHR, const VkLatencySleepModeInfoNV*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkSetLatencySleepModeNV was called, resulting in no-op behavior."); return VK_SUCCESS; } @@ -681,6 +682,15 @@ inline VKAPI_ATTR void VKAPI_CALL SetLatencyMarkerNV(VkDevice, VkSwapchainKHR, c inline VKAPI_ATTR void VKAPI_CALL GetLatencyTimingsNV(VkDevice, VkSwapchainKHR, VkGetLatencyMarkerInfoNV*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetLatencyTimingsNV was called, resulting in no-op behavior."); } inline VKAPI_ATTR void VKAPI_CALL QueueNotifyOutOfBandNV(VkQueue, const VkOutOfBandQueueTypeInfoNV*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkQueueNotifyOutOfBandNV was called, resulting in no-op behavior."); } inline VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer, VkImageAspectFlags) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdSetAttachmentFeedbackLoopEnableEXT was called, resulting in no-op behavior."); } +inline VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsEXT(VkDevice, const VkGeneratedCommandsMemoryRequirementsInfoEXT*, VkMemoryRequirements2*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkGetGeneratedCommandsMemoryRequirementsEXT was called, resulting in no-op behavior."); } +inline VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsEXT(VkCommandBuffer, const VkGeneratedCommandsInfoEXT*, VkCommandBuffer) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdPreprocessGeneratedCommandsEXT was called, resulting in no-op behavior."); } +inline VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsEXT(VkCommandBuffer, VkBool32, const VkGeneratedCommandsInfoEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdExecuteGeneratedCommandsEXT was called, resulting in no-op behavior."); } +inline VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutEXT(VkDevice, const VkIndirectCommandsLayoutCreateInfoEXT*, const VkAllocationCallbacks*, VkIndirectCommandsLayoutEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCreateIndirectCommandsLayoutEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } +inline VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutEXT(VkDevice, VkIndirectCommandsLayoutEXT, const VkAllocationCallbacks*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDestroyIndirectCommandsLayoutEXT was called, resulting in no-op behavior."); } +inline VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectExecutionSetEXT(VkDevice, const VkIndirectExecutionSetCreateInfoEXT*, const VkAllocationCallbacks*, VkIndirectExecutionSetEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCreateIndirectExecutionSetEXT was called, resulting in no-op behavior."); return VK_SUCCESS; } +inline VKAPI_ATTR void VKAPI_CALL DestroyIndirectExecutionSetEXT(VkDevice, VkIndirectExecutionSetEXT, const VkAllocationCallbacks*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDestroyIndirectExecutionSetEXT was called, resulting in no-op behavior."); } +inline VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetPipelineEXT(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetPipelineEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkUpdateIndirectExecutionSetPipelineEXT was called, resulting in no-op behavior."); } +inline VKAPI_ATTR void VKAPI_CALL UpdateIndirectExecutionSetShaderEXT(VkDevice, VkIndirectExecutionSetEXT, uint32_t, const VkWriteIndirectExecutionSetShaderEXT*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkUpdateIndirectExecutionSetShaderEXT was called, resulting in no-op behavior."); } inline VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(VkDevice, const VkAccelerationStructureCreateInfoKHR*, const VkAllocationCallbacks*, VkAccelerationStructureKHR*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCreateAccelerationStructureKHR was called, resulting in no-op behavior."); return VK_SUCCESS; } inline VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(VkDevice, VkAccelerationStructureKHR, const VkAllocationCallbacks*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkDestroyAccelerationStructureKHR was called, resulting in no-op behavior."); } inline VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR(VkCommandBuffer, uint32_t, const VkAccelerationStructureBuildGeometryInfoKHR*, const VkAccelerationStructureBuildRangeInfoKHR* const*) { GFXRECON_LOG_WARNING_ONCE("Unsupported function vkCmdBuildAccelerationStructuresKHR was called, resulting in no-op behavior."); } @@ -1327,6 +1337,7 @@ struct VulkanDeviceTable PFN_vkDestroyShaderEXT DestroyShaderEXT{ noop::DestroyShaderEXT }; PFN_vkGetShaderBinaryDataEXT GetShaderBinaryDataEXT{ noop::GetShaderBinaryDataEXT }; PFN_vkCmdBindShadersEXT CmdBindShadersEXT{ noop::CmdBindShadersEXT }; + PFN_vkCmdSetDepthClampRangeEXT CmdSetDepthClampRangeEXT{ noop::CmdSetDepthClampRangeEXT }; PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM{ noop::GetFramebufferTilePropertiesQCOM }; PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM{ noop::GetDynamicRenderingTilePropertiesQCOM }; PFN_vkSetLatencySleepModeNV SetLatencySleepModeNV{ noop::SetLatencySleepModeNV }; @@ -1335,6 +1346,15 @@ struct VulkanDeviceTable PFN_vkGetLatencyTimingsNV GetLatencyTimingsNV{ noop::GetLatencyTimingsNV }; PFN_vkQueueNotifyOutOfBandNV QueueNotifyOutOfBandNV{ noop::QueueNotifyOutOfBandNV }; PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT CmdSetAttachmentFeedbackLoopEnableEXT{ noop::CmdSetAttachmentFeedbackLoopEnableEXT }; + PFN_vkGetGeneratedCommandsMemoryRequirementsEXT GetGeneratedCommandsMemoryRequirementsEXT{ noop::GetGeneratedCommandsMemoryRequirementsEXT }; + PFN_vkCmdPreprocessGeneratedCommandsEXT CmdPreprocessGeneratedCommandsEXT{ noop::CmdPreprocessGeneratedCommandsEXT }; + PFN_vkCmdExecuteGeneratedCommandsEXT CmdExecuteGeneratedCommandsEXT{ noop::CmdExecuteGeneratedCommandsEXT }; + PFN_vkCreateIndirectCommandsLayoutEXT CreateIndirectCommandsLayoutEXT{ noop::CreateIndirectCommandsLayoutEXT }; + PFN_vkDestroyIndirectCommandsLayoutEXT DestroyIndirectCommandsLayoutEXT{ noop::DestroyIndirectCommandsLayoutEXT }; + PFN_vkCreateIndirectExecutionSetEXT CreateIndirectExecutionSetEXT{ noop::CreateIndirectExecutionSetEXT }; + PFN_vkDestroyIndirectExecutionSetEXT DestroyIndirectExecutionSetEXT{ noop::DestroyIndirectExecutionSetEXT }; + PFN_vkUpdateIndirectExecutionSetPipelineEXT UpdateIndirectExecutionSetPipelineEXT{ noop::UpdateIndirectExecutionSetPipelineEXT }; + PFN_vkUpdateIndirectExecutionSetShaderEXT UpdateIndirectExecutionSetShaderEXT{ noop::UpdateIndirectExecutionSetShaderEXT }; PFN_vkCreateAccelerationStructureKHR CreateAccelerationStructureKHR{ noop::CreateAccelerationStructureKHR }; PFN_vkDestroyAccelerationStructureKHR DestroyAccelerationStructureKHR{ noop::DestroyAccelerationStructureKHR }; PFN_vkCmdBuildAccelerationStructuresKHR CmdBuildAccelerationStructuresKHR{ noop::CmdBuildAccelerationStructuresKHR }; @@ -1988,6 +2008,7 @@ static void LoadVulkanDeviceTable(PFN_vkGetDeviceProcAddr gpa, VkDevice device, LoadVulkanFunction(gpa, device, "vkDestroyShaderEXT", &table->DestroyShaderEXT); LoadVulkanFunction(gpa, device, "vkGetShaderBinaryDataEXT", &table->GetShaderBinaryDataEXT); LoadVulkanFunction(gpa, device, "vkCmdBindShadersEXT", &table->CmdBindShadersEXT); + LoadVulkanFunction(gpa, device, "vkCmdSetDepthClampRangeEXT", &table->CmdSetDepthClampRangeEXT); LoadVulkanFunction(gpa, device, "vkGetFramebufferTilePropertiesQCOM", &table->GetFramebufferTilePropertiesQCOM); LoadVulkanFunction(gpa, device, "vkGetDynamicRenderingTilePropertiesQCOM", &table->GetDynamicRenderingTilePropertiesQCOM); LoadVulkanFunction(gpa, device, "vkSetLatencySleepModeNV", &table->SetLatencySleepModeNV); @@ -1996,6 +2017,15 @@ static void LoadVulkanDeviceTable(PFN_vkGetDeviceProcAddr gpa, VkDevice device, LoadVulkanFunction(gpa, device, "vkGetLatencyTimingsNV", &table->GetLatencyTimingsNV); LoadVulkanFunction(gpa, device, "vkQueueNotifyOutOfBandNV", &table->QueueNotifyOutOfBandNV); LoadVulkanFunction(gpa, device, "vkCmdSetAttachmentFeedbackLoopEnableEXT", &table->CmdSetAttachmentFeedbackLoopEnableEXT); + LoadVulkanFunction(gpa, device, "vkGetGeneratedCommandsMemoryRequirementsEXT", &table->GetGeneratedCommandsMemoryRequirementsEXT); + LoadVulkanFunction(gpa, device, "vkCmdPreprocessGeneratedCommandsEXT", &table->CmdPreprocessGeneratedCommandsEXT); + LoadVulkanFunction(gpa, device, "vkCmdExecuteGeneratedCommandsEXT", &table->CmdExecuteGeneratedCommandsEXT); + LoadVulkanFunction(gpa, device, "vkCreateIndirectCommandsLayoutEXT", &table->CreateIndirectCommandsLayoutEXT); + LoadVulkanFunction(gpa, device, "vkDestroyIndirectCommandsLayoutEXT", &table->DestroyIndirectCommandsLayoutEXT); + LoadVulkanFunction(gpa, device, "vkCreateIndirectExecutionSetEXT", &table->CreateIndirectExecutionSetEXT); + LoadVulkanFunction(gpa, device, "vkDestroyIndirectExecutionSetEXT", &table->DestroyIndirectExecutionSetEXT); + LoadVulkanFunction(gpa, device, "vkUpdateIndirectExecutionSetPipelineEXT", &table->UpdateIndirectExecutionSetPipelineEXT); + LoadVulkanFunction(gpa, device, "vkUpdateIndirectExecutionSetShaderEXT", &table->UpdateIndirectExecutionSetShaderEXT); LoadVulkanFunction(gpa, device, "vkCreateAccelerationStructureKHR", &table->CreateAccelerationStructureKHR); LoadVulkanFunction(gpa, device, "vkDestroyAccelerationStructureKHR", &table->DestroyAccelerationStructureKHR); LoadVulkanFunction(gpa, device, "vkCmdBuildAccelerationStructuresKHR", &table->CmdBuildAccelerationStructuresKHR); diff --git a/framework/generated/generated_vulkan_enum_to_json.cpp b/framework/generated/generated_vulkan_enum_to_json.cpp index be9c35950e..7de101707c 100644 --- a/framework/generated/generated_vulkan_enum_to_json.cpp +++ b/framework/generated/generated_vulkan_enum_to_json.cpp @@ -2049,6 +2049,9 @@ void FieldToJson(VkBufferUsageFlagBits2KHR_t, nlohmann::ordered_json& jdata, con case VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: jdata = "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; break; + case VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT: + jdata = "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -2844,6 +2847,21 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkDepthBiasRepresentationE } } +void FieldToJson(nlohmann::ordered_json& jdata, const VkDepthClampModeEXT& value, const JsonOptions& options) +{ + switch (value) { + case VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT: + jdata = "VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT"; + break; + case VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT: + jdata = "VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT"; + break; + default: + jdata = to_hex_fixed_width(value); + break; + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const VkDescriptorBindingFlagBits& value, const JsonOptions& options) { switch (value) { @@ -3561,6 +3579,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkDynamicState& value, con case VK_DYNAMIC_STATE_LINE_STIPPLE_KHR: jdata = "VK_DYNAMIC_STATE_LINE_STIPPLE_KHR"; break; + case VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT: + jdata = "VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -5535,6 +5556,36 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkIndexType& value, const } } +void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsInputModeFlagBitsEXT& value, const JsonOptions& options) +{ + switch (value) { + case VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT: + jdata = "VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT"; + break; + case VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT: + jdata = "VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT"; + break; + default: + jdata = to_hex_fixed_width(value); + break; + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsLayoutUsageFlagBitsEXT& value, const JsonOptions& options) +{ + switch (value) { + case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT: + jdata = "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT"; + break; + case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT: + jdata = "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT"; + break; + default: + jdata = to_hex_fixed_width(value); + break; + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsLayoutUsageFlagBitsNV& value, const JsonOptions& options) { switch (value) { @@ -5553,6 +5604,60 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsLayoutUs } } +void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsTokenTypeEXT& value, const JsonOptions& options) +{ + switch (value) { + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT"; + break; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT: + jdata = "VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT"; + break; + default: + jdata = to_hex_fixed_width(value); + break; + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsTokenTypeNV& value, const JsonOptions& options) { switch (value) { @@ -5595,6 +5700,21 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsTokenTyp } } +void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectExecutionSetInfoTypeEXT& value, const JsonOptions& options) +{ + switch (value) { + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: + jdata = "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT"; + break; + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: + jdata = "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT"; + break; + default: + jdata = to_hex_fixed_width(value); + break; + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectStateFlagBitsNV& value, const JsonOptions& options) { switch (value) { @@ -6099,6 +6219,12 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkObjectType& value, const case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: jdata = "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR"; break; + case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT: + jdata = "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT"; + break; + case VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT: + jdata = "VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -6818,6 +6944,9 @@ void FieldToJson(VkPipelineCreateFlagBits2KHR_t, nlohmann::ordered_json& jdata, case VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR: jdata = "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR"; break; + case VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT: + jdata = "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -8086,6 +8215,9 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkShaderCreateFlagBitsEXT& case VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: jdata = "VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; break; + case VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT: + jdata = "VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -11110,6 +11242,48 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT"; + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT"; + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT"; + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT"; + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT"; + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT"; + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: + jdata = "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT"; + break; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: + jdata = "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT"; + break; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: + jdata = "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT"; + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT"; + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT"; + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT"; + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT"; + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT"; + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA"; break; @@ -11119,6 +11293,12 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkStructureType& value, co case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: jdata = "VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA"; break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + jdata = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT"; + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + jdata = "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT"; + break; default: jdata = to_hex_fixed_width(value); break; @@ -12605,6 +12785,8 @@ void FieldToJson(VkBufferUsageFlags2KHR_t, nlohmann::ordered_json& jdata, const return std::string("VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"); case VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: return std::string("VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"); + case VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT: + return std::string("VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT"); } return to_hex_fixed_width(flags); }); @@ -14031,6 +14213,46 @@ void FieldToJson(VkImageViewCreateFlags_t, nlohmann::ordered_json& jdata, const }); } +void FieldToJson(VkIndirectCommandsInputModeFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +{ + if (!options.expand_flags) + { + jdata = to_hex_fixed_width(flags); + return; + } + jdata = ExpandFlags(flags, [](VkFlags flags) + { + switch (flags) + { + case VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT: + return std::string("VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT"); + case VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT: + return std::string("VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT"); + } + return to_hex_fixed_width(flags); + }); +} + +void FieldToJson(VkIndirectCommandsLayoutUsageFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) +{ + if (!options.expand_flags) + { + jdata = to_hex_fixed_width(flags); + return; + } + jdata = ExpandFlags(flags, [](VkFlags flags) + { + switch (flags) + { + case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT: + return std::string("VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT"); + case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT: + return std::string("VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT"); + } + return to_hex_fixed_width(flags); + }); +} + void FieldToJson(VkIndirectCommandsLayoutUsageFlagsNV_t, nlohmann::ordered_json& jdata, const VkFlags flags, const JsonOptions& options) { if (!options.expand_flags) @@ -14600,6 +14822,8 @@ void FieldToJson(VkPipelineCreateFlags2KHR_t, nlohmann::ordered_json& jdata, con return std::string("VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"); case VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR: return std::string("VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR"); + case VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT: + return std::string("VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT"); } return to_hex_fixed_width(flags); }); @@ -15293,6 +15517,8 @@ void FieldToJson(VkShaderCreateFlagsEXT_t, nlohmann::ordered_json& jdata, const return std::string("VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT"); case VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: return std::string("VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"); + case VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT: + return std::string("VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT"); } return to_hex_fixed_width(flags); }); diff --git a/framework/generated/generated_vulkan_enum_to_json.h b/framework/generated/generated_vulkan_enum_to_json.h index 9c951c96ef..a2891cea8a 100644 --- a/framework/generated/generated_vulkan_enum_to_json.h +++ b/framework/generated/generated_vulkan_enum_to_json.h @@ -117,6 +117,8 @@ struct VkImageCreateFlags_t { }; struct VkImagePipeSurfaceCreateFlagsFUCHSIA_t { }; struct VkImageUsageFlags_t { }; struct VkImageViewCreateFlags_t { }; +struct VkIndirectCommandsInputModeFlagsEXT_t { }; +struct VkIndirectCommandsLayoutUsageFlagsEXT_t { }; struct VkIndirectCommandsLayoutUsageFlagsNV_t { }; struct VkIndirectStateFlagsNV_t { }; struct VkInstanceCreateFlags_t { }; @@ -318,6 +320,7 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkDebugUtilsMessageSeverit void FieldToJson(nlohmann::ordered_json& jdata, const VkDebugUtilsMessageTypeFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkDependencyFlagBits& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkDepthBiasRepresentationEXT& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkDepthClampModeEXT& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkDescriptorBindingFlagBits& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkDescriptorPoolCreateFlagBits& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkDescriptorSetLayoutCreateFlagBits& value, const util::JsonOptions& options = util::JsonOptions()); @@ -378,8 +381,12 @@ void FieldToJson(nlohmann::ordered_json& jdata, const VkImageUsageFlagBits& valu void FieldToJson(nlohmann::ordered_json& jdata, const VkImageViewCreateFlagBits& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkImageViewType& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkIndexType& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsInputModeFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsLayoutUsageFlagBitsEXT& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsLayoutUsageFlagBitsNV& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsTokenTypeEXT& value, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectCommandsTokenTypeNV& value, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const VkIndirectExecutionSetInfoTypeEXT& value, const util::JsonOptions& options = util::JsonOptions()); 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()); @@ -596,6 +603,8 @@ void FieldToJson(VkImageCreateFlags_t, nlohmann::ordered_json& jdata, const VkFl void FieldToJson(VkImagePipeSurfaceCreateFlagsFUCHSIA_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkImageUsageFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkImageViewCreateFlags_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkIndirectCommandsInputModeFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(VkIndirectCommandsLayoutUsageFlagsEXT_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkIndirectCommandsLayoutUsageFlagsNV_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkIndirectStateFlagsNV_t, nlohmann::ordered_json& jdata, const VkFlags flags, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(VkInstanceCreateFlags_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 0ecf446269..46111944ce 100644 --- a/framework/generated/generated_vulkan_enum_to_string.cpp +++ b/framework/generated/generated_vulkan_enum_to_string.cpp @@ -1086,6 +1086,7 @@ template <> std::string ToString(const VkDynamicState& value, To case VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV: return "VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV"; case VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: return "VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT"; case VK_DYNAMIC_STATE_LINE_STIPPLE_KHR: return "VK_DYNAMIC_STATE_LINE_STIPPLE_KHR"; + case VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT: return "VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT"; default: break; } return "Unhandled VkDynamicState"; @@ -1803,6 +1804,8 @@ template <> std::string ToString(const VkObjectType& value, ToStri case VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: return "VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV"; case VK_OBJECT_TYPE_SHADER_EXT: return "VK_OBJECT_TYPE_SHADER_EXT"; case VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: return "VK_OBJECT_TYPE_PIPELINE_BINARY_KHR"; + case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT: return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT"; + case VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT: return "VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT"; default: break; } return "Unhandled VkObjectType"; @@ -3291,9 +3294,25 @@ template <> std::string ToString(const VkStructureType& value, case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT"; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT"; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: return "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT"; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: return "VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT"; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: return "VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT"; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT"; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: return "VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA"; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA"; case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: return "VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA"; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT"; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT"; default: break; } return "Unhandled VkStructureType"; @@ -4752,6 +4771,7 @@ std::string VkBufferUsageFlagBits2KHRToString(const VkBufferUsageFlagBits2KHR va case VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: return "VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT"; case VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: return "VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT"; case VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: return "VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT"; + case VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT: return "VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT"; default: break; } return "Unhandled VkBufferUsageFlagBits2KHR"; @@ -4817,6 +4837,7 @@ std::string VkPipelineCreateFlagBits2KHRToString(const VkPipelineCreateFlagBits2 case VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: return "VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV"; case VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT: return "VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT"; case VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR: return "VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR"; + case VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT: return "VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT"; default: break; } return "Unhandled VkPipelineCreateFlagBits2KHR"; @@ -6109,6 +6130,16 @@ template <> std::string ToString(const VkAntiLagStageAMD& val return "Unhandled VkAntiLagStageAMD"; } +template <> std::string ToString(const VkDepthClampModeEXT& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT: return "VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT"; + case VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT: return "VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT"; + default: break; + } + return "Unhandled VkDepthClampModeEXT"; +} + template <> std::string ToString(const VkShaderCodeTypeEXT& value, ToStringFlags, uint32_t, uint32_t) { switch (value) { @@ -6129,6 +6160,7 @@ template <> std::string ToString(const VkShaderCreate case VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT: return "VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT"; case VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT: return "VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT"; case VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: return "VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT"; + case VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT: return "VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT"; default: break; } return "Unhandled VkShaderCreateFlagBitsEXT"; @@ -6227,6 +6259,69 @@ template <> std::string ToString(const VkLayer return "Unhandled VkLayeredDriverUnderlyingApiMSFT"; } +template <> std::string ToString(const VkIndirectCommandsInputModeFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT: return "VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT"; + case VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT: return "VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT"; + default: break; + } + return "Unhandled VkIndirectCommandsInputModeFlagBitsEXT"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + +template <> std::string ToString(const VkIndirectCommandsLayoutUsageFlagBitsEXT& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT: return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT"; + case VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT: return "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT"; + default: break; + } + return "Unhandled VkIndirectCommandsLayoutUsageFlagBitsEXT"; +} + +template <> std::string ToString(VkFlags vkFlags, ToStringFlags, uint32_t, uint32_t) +{ + return BitmaskToString(vkFlags); +} + +template <> std::string ToString(const VkIndirectCommandsTokenTypeEXT& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT"; + case VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT: return "VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT"; + default: break; + } + return "Unhandled VkIndirectCommandsTokenTypeEXT"; +} + +template <> std::string ToString(const VkIndirectExecutionSetInfoTypeEXT& value, ToStringFlags, uint32_t, uint32_t) +{ + switch (value) { + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: return "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT"; + case VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: return "VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT"; + default: break; + } + return "Unhandled VkIndirectExecutionSetInfoTypeEXT"; +} + template <> std::string ToString(const VkAccelerationStructureCreateFlagBitsKHR& 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 d7736ecd0c..e30251e527 100644 --- a/framework/generated/generated_vulkan_enum_to_string.h +++ b/framework/generated/generated_vulkan_enum_to_string.h @@ -447,6 +447,7 @@ template <> std::string ToString(const VkOpticalFl template <> std::string ToString(VkFlags vkFlags, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkAntiLagModeAMD& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkAntiLagStageAMD& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkDepthClampModeEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkShaderCodeTypeEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); 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); @@ -457,6 +458,12 @@ template <> std::string ToString(const VkOutOfBandQueueT 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); +template <> std::string ToString(const VkIndirectCommandsInputModeFlagBitsEXT& 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 VkIndirectCommandsLayoutUsageFlagBitsEXT& 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 VkIndirectCommandsTokenTypeEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); +template <> std::string ToString(const VkIndirectExecutionSetInfoTypeEXT& value, ToStringFlags toStringFlags, uint32_t tabCount, uint32_t tabSize); template <> std::string ToString(const VkAccelerationStructureCreateFlagBitsKHR& 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 VkBuildAccelerationStructureModeKHR& 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 8761db0781..dca39b96e9 100644 --- a/framework/generated/generated_vulkan_feature_util.cpp +++ b/framework/generated/generated_vulkan_feature_util.cpp @@ -4450,6 +4450,28 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + { + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* currentNext = reinterpret_cast(next); + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->deviceGeneratedCommands == VK_TRUE) && (query.deviceGeneratedCommands == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature deviceGeneratedCommands %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->deviceGeneratedCommands = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + if ((currentNext->dynamicGeneratedPipelineLayout == VK_TRUE) && (query.dynamicGeneratedPipelineLayout == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature dynamicGeneratedPipelineLayout %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->dynamicGeneratedPipelineLayout = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* currentNext = reinterpret_cast(next); @@ -4465,6 +4487,21 @@ void CheckUnsupportedFeatures(VkPhysicalDevice physicalDevice, } break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + { + const VkPhysicalDeviceDepthClampControlFeaturesEXT* currentNext = reinterpret_cast(next); + VkPhysicalDeviceDepthClampControlFeaturesEXT query = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT, nullptr }; + physicalDeviceFeatures2.pNext = &query; + GetPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures2); + if ((currentNext->depthClampControl == VK_TRUE) && (query.depthClampControl == VK_FALSE)) + { + GFXRECON_LOG_WARNING("Feature depthClampControl %s", warn_message); + found_unsupported = true; + const_cast(currentNext)->depthClampControl = + remove_unsupported ? VK_FALSE : VK_TRUE; + } + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: { const VkPhysicalDeviceAccelerationStructureFeaturesKHR* currentNext = reinterpret_cast(next); diff --git a/framework/generated/generated_vulkan_json_consumer.cpp b/framework/generated/generated_vulkan_json_consumer.cpp index 9d0f6a4393..cb8c460b7c 100644 --- a/framework/generated/generated_vulkan_json_consumer.cpp +++ b/framework/generated/generated_vulkan_json_consumer.cpp @@ -10145,6 +10145,22 @@ void VulkanExportJsonConsumer::Process_vkCmdBindShadersEXT( WriteBlockEnd(); } +void VulkanExportJsonConsumer::Process_vkCmdSetDepthClampRangeEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkDepthClampModeEXT depthClampMode, + StructPointerDecoder* pDepthClampRange) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdSetDepthClampRangeEXT"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options); + FieldToJson(args["depthClampMode"], depthClampMode, json_options); + FieldToJson(args["pDepthClampRange"], pDepthClampRange, json_options); + WriteBlockEnd(); +} + void VulkanExportJsonConsumer::Process_vkGetFramebufferTilePropertiesQCOM( const ApiCallInfo& call_info, VkResult returnValue, @@ -10272,6 +10288,155 @@ void VulkanExportJsonConsumer::Process_vkCmdSetAttachmentFeedbackLoopEnableEXT( WriteBlockEnd(); } +void VulkanExportJsonConsumer::Process_vkGetGeneratedCommandsMemoryRequirementsEXT( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pMemoryRequirements) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkGetGeneratedCommandsMemoryRequirementsEXT"); + const JsonOptions& json_options = GetJsonOptions(); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options); + FieldToJson(args["pInfo"], pInfo, json_options); + FieldToJson(args["pMemoryRequirements"], pMemoryRequirements, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pGeneratedCommandsInfo, + format::HandleId stateCommandBuffer) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdPreprocessGeneratedCommandsEXT"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options); + FieldToJson(args["pGeneratedCommandsInfo"], pGeneratedCommandsInfo, json_options); + HandleToJson(args["stateCommandBuffer"], stateCommandBuffer, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkBool32 isPreprocessed, + StructPointerDecoder* pGeneratedCommandsInfo) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCmdExecuteGeneratedCommandsEXT"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameCommandIndex()], GetCommandBufferRecordIndex(commandBuffer), json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["commandBuffer"], commandBuffer, json_options); + Bool32ToJson(args["isPreprocessed"], isPreprocessed, json_options); + FieldToJson(args["pGeneratedCommandsInfo"], pGeneratedCommandsInfo, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkCreateIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectCommandsLayout) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCreateIndirectCommandsLayoutEXT"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameReturn()], returnValue, json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options); + FieldToJson(args["pCreateInfo"], pCreateInfo, json_options); + FieldToJson(args["pAllocator"], pAllocator, json_options); + HandleToJson(args["pIndirectCommandsLayout"], pIndirectCommandsLayout, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkDestroyIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectCommandsLayout, + StructPointerDecoder* pAllocator) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkDestroyIndirectCommandsLayoutEXT"); + const JsonOptions& json_options = GetJsonOptions(); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options); + HandleToJson(args["indirectCommandsLayout"], indirectCommandsLayout, json_options); + FieldToJson(args["pAllocator"], pAllocator, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkCreateIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectExecutionSet) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkCreateIndirectExecutionSetEXT"); + const JsonOptions& json_options = GetJsonOptions(); + FieldToJson(jdata[NameReturn()], returnValue, json_options); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options); + FieldToJson(args["pCreateInfo"], pCreateInfo, json_options); + FieldToJson(args["pAllocator"], pAllocator, json_options); + HandleToJson(args["pIndirectExecutionSet"], pIndirectExecutionSet, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkDestroyIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + StructPointerDecoder* pAllocator) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkDestroyIndirectExecutionSetEXT"); + const JsonOptions& json_options = GetJsonOptions(); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options); + HandleToJson(args["indirectExecutionSet"], indirectExecutionSet, json_options); + FieldToJson(args["pAllocator"], pAllocator, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkUpdateIndirectExecutionSetPipelineEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkUpdateIndirectExecutionSetPipelineEXT"); + const JsonOptions& json_options = GetJsonOptions(); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options); + HandleToJson(args["indirectExecutionSet"], indirectExecutionSet, json_options); + FieldToJson(args["executionSetWriteCount"], executionSetWriteCount, json_options); + FieldToJson(args["pExecutionSetWrites"], pExecutionSetWrites, json_options); + WriteBlockEnd(); +} + +void VulkanExportJsonConsumer::Process_vkUpdateIndirectExecutionSetShaderEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) +{ + nlohmann::ordered_json& jdata = WriteApiCallStart(call_info, "vkUpdateIndirectExecutionSetShaderEXT"); + const JsonOptions& json_options = GetJsonOptions(); + auto& args = jdata[NameArgs()]; + HandleToJson(args["device"], device, json_options); + HandleToJson(args["indirectExecutionSet"], indirectExecutionSet, json_options); + FieldToJson(args["executionSetWriteCount"], executionSetWriteCount, json_options); + FieldToJson(args["pExecutionSetWrites"], pExecutionSetWrites, json_options); + WriteBlockEnd(); +} + void VulkanExportJsonConsumer::Process_vkCreateAccelerationStructureKHR( const ApiCallInfo& call_info, VkResult returnValue, diff --git a/framework/generated/generated_vulkan_json_consumer.h b/framework/generated/generated_vulkan_json_consumer.h index ff195c989a..3d6891d810 100644 --- a/framework/generated/generated_vulkan_json_consumer.h +++ b/framework/generated/generated_vulkan_json_consumer.h @@ -4095,6 +4095,12 @@ class VulkanExportJsonConsumer : public VulkanExportJsonConsumerBase PointerDecoder* pStages, HandlePointerDecoder* pShaders) override; + virtual void Process_vkCmdSetDepthClampRangeEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkDepthClampModeEXT depthClampMode, + StructPointerDecoder* pDepthClampRange) override; + virtual void Process_vkGetFramebufferTilePropertiesQCOM( const ApiCallInfo& call_info, VkResult returnValue, @@ -4146,6 +4152,66 @@ class VulkanExportJsonConsumer : public VulkanExportJsonConsumerBase format::HandleId commandBuffer, VkImageAspectFlags aspectMask) override; + virtual void Process_vkGetGeneratedCommandsMemoryRequirementsEXT( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pMemoryRequirements) override; + + virtual void Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pGeneratedCommandsInfo, + format::HandleId stateCommandBuffer) override; + + virtual void Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkBool32 isPreprocessed, + StructPointerDecoder* pGeneratedCommandsInfo) override; + + virtual void Process_vkCreateIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectCommandsLayout) override; + + virtual void Process_vkDestroyIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectCommandsLayout, + StructPointerDecoder* pAllocator) override; + + virtual void Process_vkCreateIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectExecutionSet) override; + + virtual void Process_vkDestroyIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + StructPointerDecoder* pAllocator) override; + + virtual void Process_vkUpdateIndirectExecutionSetPipelineEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) override; + + virtual void Process_vkUpdateIndirectExecutionSetShaderEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) override; + virtual void Process_vkCreateAccelerationStructureKHR( const ApiCallInfo& call_info, VkResult returnValue, diff --git a/framework/generated/generated_vulkan_object_info_table_base2.h b/framework/generated/generated_vulkan_object_info_table_base2.h index 31b22b2dd8..8b6d45fc9e 100644 --- a/framework/generated/generated_vulkan_object_info_table_base2.h +++ b/framework/generated/generated_vulkan_object_info_table_base2.h @@ -64,7 +64,9 @@ class VulkanObjectInfoTableBase2 : VulkanObjectInfoTableBase void AddFramebufferInfo(FramebufferInfo&& info) { AddObjectInfo(std::move(info), &framebuffer_map_); } void AddImageInfo(ImageInfo&& info) { AddObjectInfo(std::move(info), &image_map_); } void AddImageViewInfo(ImageViewInfo&& info) { AddObjectInfo(std::move(info), &imageView_map_); } + void AddIndirectCommandsLayoutEXTInfo(IndirectCommandsLayoutEXTInfo&& info) { AddObjectInfo(std::move(info), &indirectCommandsLayoutEXT_map_); } void AddIndirectCommandsLayoutNVInfo(IndirectCommandsLayoutNVInfo&& info) { AddObjectInfo(std::move(info), &indirectCommandsLayoutNV_map_); } + void AddIndirectExecutionSetEXTInfo(IndirectExecutionSetEXTInfo&& info) { AddObjectInfo(std::move(info), &indirectExecutionSetEXT_map_); } void AddInstanceInfo(InstanceInfo&& info) { AddObjectInfo(std::move(info), &instance_map_); } void AddMicromapEXTInfo(MicromapEXTInfo&& info) { AddObjectInfo(std::move(info), µmapEXT_map_); } void AddOpticalFlowSessionNVInfo(OpticalFlowSessionNVInfo&& info) { AddObjectInfo(std::move(info), &opticalFlowSessionNV_map_); } @@ -111,7 +113,9 @@ class VulkanObjectInfoTableBase2 : VulkanObjectInfoTableBase void RemoveFramebufferInfo(format::HandleId id) { framebuffer_map_.erase(id); } void RemoveImageInfo(format::HandleId id) { image_map_.erase(id); } void RemoveImageViewInfo(format::HandleId id) { imageView_map_.erase(id); } + void RemoveIndirectCommandsLayoutEXTInfo(format::HandleId id) { indirectCommandsLayoutEXT_map_.erase(id); } void RemoveIndirectCommandsLayoutNVInfo(format::HandleId id) { indirectCommandsLayoutNV_map_.erase(id); } + void RemoveIndirectExecutionSetEXTInfo(format::HandleId id) { indirectExecutionSetEXT_map_.erase(id); } void RemoveInstanceInfo(format::HandleId id) { instance_map_.erase(id); } void RemoveMicromapEXTInfo(format::HandleId id) { micromapEXT_map_.erase(id); } void RemoveOpticalFlowSessionNVInfo(format::HandleId id) { opticalFlowSessionNV_map_.erase(id); } @@ -158,7 +162,9 @@ class VulkanObjectInfoTableBase2 : VulkanObjectInfoTableBase const FramebufferInfo* GetFramebufferInfo(format::HandleId id) const { return GetObjectInfo(id, &framebuffer_map_); } const ImageInfo* GetImageInfo(format::HandleId id) const { return GetObjectInfo(id, &image_map_); } const ImageViewInfo* GetImageViewInfo(format::HandleId id) const { return GetObjectInfo(id, &imageView_map_); } + const IndirectCommandsLayoutEXTInfo* GetIndirectCommandsLayoutEXTInfo(format::HandleId id) const { return GetObjectInfo(id, &indirectCommandsLayoutEXT_map_); } const IndirectCommandsLayoutNVInfo* GetIndirectCommandsLayoutNVInfo(format::HandleId id) const { return GetObjectInfo(id, &indirectCommandsLayoutNV_map_); } + const IndirectExecutionSetEXTInfo* GetIndirectExecutionSetEXTInfo(format::HandleId id) const { return GetObjectInfo(id, &indirectExecutionSetEXT_map_); } const InstanceInfo* GetInstanceInfo(format::HandleId id) const { return GetObjectInfo(id, &instance_map_); } const MicromapEXTInfo* GetMicromapEXTInfo(format::HandleId id) const { return GetObjectInfo(id, µmapEXT_map_); } const OpticalFlowSessionNVInfo* GetOpticalFlowSessionNVInfo(format::HandleId id) const { return GetObjectInfo(id, &opticalFlowSessionNV_map_); } @@ -205,7 +211,9 @@ class VulkanObjectInfoTableBase2 : VulkanObjectInfoTableBase FramebufferInfo* GetFramebufferInfo(format::HandleId id) { return GetObjectInfo(id, &framebuffer_map_); } ImageInfo* GetImageInfo(format::HandleId id) { return GetObjectInfo(id, &image_map_); } ImageViewInfo* GetImageViewInfo(format::HandleId id) { return GetObjectInfo(id, &imageView_map_); } + IndirectCommandsLayoutEXTInfo* GetIndirectCommandsLayoutEXTInfo(format::HandleId id) { return GetObjectInfo(id, &indirectCommandsLayoutEXT_map_); } IndirectCommandsLayoutNVInfo* GetIndirectCommandsLayoutNVInfo(format::HandleId id) { return GetObjectInfo(id, &indirectCommandsLayoutNV_map_); } + IndirectExecutionSetEXTInfo* GetIndirectExecutionSetEXTInfo(format::HandleId id) { return GetObjectInfo(id, &indirectExecutionSetEXT_map_); } InstanceInfo* GetInstanceInfo(format::HandleId id) { return GetObjectInfo(id, &instance_map_); } MicromapEXTInfo* GetMicromapEXTInfo(format::HandleId id) { return GetObjectInfo(id, µmapEXT_map_); } OpticalFlowSessionNVInfo* GetOpticalFlowSessionNVInfo(format::HandleId id) { return GetObjectInfo(id, &opticalFlowSessionNV_map_); } @@ -252,7 +260,9 @@ class VulkanObjectInfoTableBase2 : VulkanObjectInfoTableBase void VisitFramebufferInfo(std::function visitor) const { for (const auto& entry : framebuffer_map_) { visitor(&entry.second); } } void VisitImageInfo(std::function visitor) const { for (const auto& entry : image_map_) { visitor(&entry.second); } } void VisitImageViewInfo(std::function visitor) const { for (const auto& entry : imageView_map_) { visitor(&entry.second); } } + void VisitIndirectCommandsLayoutEXTInfo(std::function visitor) const { for (const auto& entry : indirectCommandsLayoutEXT_map_) { visitor(&entry.second); } } void VisitIndirectCommandsLayoutNVInfo(std::function visitor) const { for (const auto& entry : indirectCommandsLayoutNV_map_) { visitor(&entry.second); } } + void VisitIndirectExecutionSetEXTInfo(std::function visitor) const { for (const auto& entry : indirectExecutionSetEXT_map_) { visitor(&entry.second); } } void VisitInstanceInfo(std::function visitor) const { for (const auto& entry : instance_map_) { visitor(&entry.second); } } void VisitMicromapEXTInfo(std::function visitor) const { for (const auto& entry : micromapEXT_map_) { visitor(&entry.second); } } void VisitOpticalFlowSessionNVInfo(std::function visitor) const { for (const auto& entry : opticalFlowSessionNV_map_) { visitor(&entry.second); } } @@ -300,7 +310,9 @@ class VulkanObjectInfoTableBase2 : VulkanObjectInfoTableBase std::unordered_map framebuffer_map_; std::unordered_map image_map_; std::unordered_map imageView_map_; + std::unordered_map indirectCommandsLayoutEXT_map_; std::unordered_map indirectCommandsLayoutNV_map_; + std::unordered_map indirectExecutionSetEXT_map_; std::unordered_map instance_map_; std::unordered_map micromapEXT_map_; std::unordered_map opticalFlowSessionNV_map_; diff --git a/framework/generated/generated_vulkan_referenced_resource_consumer.cpp b/framework/generated/generated_vulkan_referenced_resource_consumer.cpp index b0afc6a2a6..7576b59e49 100644 --- a/framework/generated/generated_vulkan_referenced_resource_consumer.cpp +++ b/framework/generated/generated_vulkan_referenced_resource_consumer.cpp @@ -1984,6 +1984,37 @@ void VulkanReferencedResourceConsumer::Process_vkCmdDrawClusterIndirectHUAWEI( GetTable().AddResourceToUser(commandBuffer, buffer); } +void VulkanReferencedResourceConsumer::Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pGeneratedCommandsInfo, + format::HandleId stateCommandBuffer) +{ + assert(pGeneratedCommandsInfo != nullptr); + + if (!pGeneratedCommandsInfo->IsNull() && (pGeneratedCommandsInfo->HasData())) + { + auto pGeneratedCommandsInfo_ptr = pGeneratedCommandsInfo->GetMetaStructPointer(); + } + GetTable().AddUserToUser(commandBuffer, stateCommandBuffer); +} + +void VulkanReferencedResourceConsumer::Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkBool32 isPreprocessed, + StructPointerDecoder* pGeneratedCommandsInfo) +{ + GFXRECON_UNREFERENCED_PARAMETER(isPreprocessed); + + assert(pGeneratedCommandsInfo != nullptr); + + if (!pGeneratedCommandsInfo->IsNull() && (pGeneratedCommandsInfo->HasData())) + { + auto pGeneratedCommandsInfo_ptr = pGeneratedCommandsInfo->GetMetaStructPointer(); + } +} + void VulkanReferencedResourceConsumer::Process_vkCmdBuildAccelerationStructuresKHR( const ApiCallInfo& call_info, format::HandleId commandBuffer, diff --git a/framework/generated/generated_vulkan_referenced_resource_consumer.h b/framework/generated/generated_vulkan_referenced_resource_consumer.h index f7247f604f..f124952e82 100644 --- a/framework/generated/generated_vulkan_referenced_resource_consumer.h +++ b/framework/generated/generated_vulkan_referenced_resource_consumer.h @@ -635,6 +635,18 @@ class VulkanReferencedResourceConsumer : public VulkanReferencedResourceConsumer format::HandleId buffer, VkDeviceSize offset) override; + virtual void Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pGeneratedCommandsInfo, + format::HandleId stateCommandBuffer) override; + + virtual void Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkBool32 isPreprocessed, + StructPointerDecoder* pGeneratedCommandsInfo) override; + virtual void Process_vkCmdBuildAccelerationStructuresKHR( const ApiCallInfo& call_info, format::HandleId commandBuffer, diff --git a/framework/generated/generated_vulkan_replay_consumer.cpp b/framework/generated/generated_vulkan_replay_consumer.cpp index 09e9e41580..140836e439 100644 --- a/framework/generated/generated_vulkan_replay_consumer.cpp +++ b/framework/generated/generated_vulkan_replay_consumer.cpp @@ -10176,6 +10176,23 @@ void VulkanReplayConsumer::Process_vkCmdBindShadersEXT( } } +void VulkanReplayConsumer::Process_vkCmdSetDepthClampRangeEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkDepthClampModeEXT depthClampMode, + StructPointerDecoder* pDepthClampRange) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + const VkDepthClampRangeEXT* in_pDepthClampRange = pDepthClampRange->GetPointer(); + + GetDeviceTable(in_commandBuffer)->CmdSetDepthClampRangeEXT(in_commandBuffer, depthClampMode, in_pDepthClampRange); + + if (options_.dumping_resources) + { + resource_dumper.Process_vkCmdSetDepthClampRangeEXT(call_info, GetDeviceTable(in_commandBuffer)->CmdSetDepthClampRangeEXT, in_commandBuffer, depthClampMode, in_pDepthClampRange); + } +} + void VulkanReplayConsumer::Process_vkGetFramebufferTilePropertiesQCOM( const ApiCallInfo& call_info, VkResult returnValue, @@ -10320,6 +10337,157 @@ void VulkanReplayConsumer::Process_vkCmdSetAttachmentFeedbackLoopEnableEXT( } } +void VulkanReplayConsumer::Process_vkGetGeneratedCommandsMemoryRequirementsEXT( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pMemoryRequirements) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + const VkGeneratedCommandsMemoryRequirementsInfoEXT* in_pInfo = pInfo->GetPointer(); + MapStructHandles(pInfo->GetMetaStructPointer(), GetObjectInfoTable()); + VkMemoryRequirements2* out_pMemoryRequirements = pMemoryRequirements->IsNull() ? nullptr : pMemoryRequirements->AllocateOutputData(1, { VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, nullptr }); + InitializeOutputStructPNext(pMemoryRequirements); + + GetDeviceTable(in_device)->GetGeneratedCommandsMemoryRequirementsEXT(in_device, in_pInfo, out_pMemoryRequirements); +} + +void VulkanReplayConsumer::Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pGeneratedCommandsInfo, + format::HandleId stateCommandBuffer) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + const VkGeneratedCommandsInfoEXT* in_pGeneratedCommandsInfo = pGeneratedCommandsInfo->GetPointer(); + MapStructHandles(pGeneratedCommandsInfo->GetMetaStructPointer(), GetObjectInfoTable()); + VkCommandBuffer in_stateCommandBuffer = MapHandle(stateCommandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + + GetDeviceTable(in_commandBuffer)->CmdPreprocessGeneratedCommandsEXT(in_commandBuffer, in_pGeneratedCommandsInfo, in_stateCommandBuffer); + + if (options_.dumping_resources) + { + resource_dumper.Process_vkCmdPreprocessGeneratedCommandsEXT(call_info, GetDeviceTable(in_commandBuffer)->CmdPreprocessGeneratedCommandsEXT, in_commandBuffer, in_pGeneratedCommandsInfo, in_stateCommandBuffer); + } +} + +void VulkanReplayConsumer::Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkBool32 isPreprocessed, + StructPointerDecoder* pGeneratedCommandsInfo) +{ + VkCommandBuffer in_commandBuffer = MapHandle(commandBuffer, &VulkanObjectInfoTable::GetCommandBufferInfo); + const VkGeneratedCommandsInfoEXT* in_pGeneratedCommandsInfo = pGeneratedCommandsInfo->GetPointer(); + MapStructHandles(pGeneratedCommandsInfo->GetMetaStructPointer(), GetObjectInfoTable()); + + GetDeviceTable(in_commandBuffer)->CmdExecuteGeneratedCommandsEXT(in_commandBuffer, isPreprocessed, in_pGeneratedCommandsInfo); + + if (options_.dumping_resources) + { + resource_dumper.Process_vkCmdExecuteGeneratedCommandsEXT(call_info, GetDeviceTable(in_commandBuffer)->CmdExecuteGeneratedCommandsEXT, in_commandBuffer, isPreprocessed, in_pGeneratedCommandsInfo); + } +} + +void VulkanReplayConsumer::Process_vkCreateIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectCommandsLayout) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + const VkIndirectCommandsLayoutCreateInfoEXT* in_pCreateInfo = pCreateInfo->GetPointer(); + MapStructHandles(pCreateInfo->GetMetaStructPointer(), GetObjectInfoTable()); + const VkAllocationCallbacks* in_pAllocator = GetAllocationCallbacks(pAllocator); + if (!pIndirectCommandsLayout->IsNull()) { pIndirectCommandsLayout->SetHandleLength(1); } + VkIndirectCommandsLayoutEXT* out_pIndirectCommandsLayout = pIndirectCommandsLayout->GetHandlePointer(); + + VkResult replay_result = GetDeviceTable(in_device)->CreateIndirectCommandsLayoutEXT(in_device, in_pCreateInfo, in_pAllocator, out_pIndirectCommandsLayout); + CheckResult("vkCreateIndirectCommandsLayoutEXT", returnValue, replay_result, call_info); + + AddHandle(device, pIndirectCommandsLayout->GetPointer(), out_pIndirectCommandsLayout, &VulkanObjectInfoTable::AddIndirectCommandsLayoutEXTInfo); +} + +void VulkanReplayConsumer::Process_vkDestroyIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectCommandsLayout, + StructPointerDecoder* pAllocator) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + VkIndirectCommandsLayoutEXT in_indirectCommandsLayout = MapHandle(indirectCommandsLayout, &VulkanObjectInfoTable::GetIndirectCommandsLayoutEXTInfo); + const VkAllocationCallbacks* in_pAllocator = GetAllocationCallbacks(pAllocator); + + GetDeviceTable(in_device)->DestroyIndirectCommandsLayoutEXT(in_device, in_indirectCommandsLayout, in_pAllocator); + RemoveHandle(indirectCommandsLayout, &VulkanObjectInfoTable::RemoveIndirectCommandsLayoutEXTInfo); +} + +void VulkanReplayConsumer::Process_vkCreateIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectExecutionSet) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + const VkIndirectExecutionSetCreateInfoEXT* in_pCreateInfo = pCreateInfo->GetPointer(); + const VkAllocationCallbacks* in_pAllocator = GetAllocationCallbacks(pAllocator); + if (!pIndirectExecutionSet->IsNull()) { pIndirectExecutionSet->SetHandleLength(1); } + VkIndirectExecutionSetEXT* out_pIndirectExecutionSet = pIndirectExecutionSet->GetHandlePointer(); + + VkResult replay_result = GetDeviceTable(in_device)->CreateIndirectExecutionSetEXT(in_device, in_pCreateInfo, in_pAllocator, out_pIndirectExecutionSet); + CheckResult("vkCreateIndirectExecutionSetEXT", returnValue, replay_result, call_info); + + AddHandle(device, pIndirectExecutionSet->GetPointer(), out_pIndirectExecutionSet, &VulkanObjectInfoTable::AddIndirectExecutionSetEXTInfo); +} + +void VulkanReplayConsumer::Process_vkDestroyIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + StructPointerDecoder* pAllocator) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + VkIndirectExecutionSetEXT in_indirectExecutionSet = MapHandle(indirectExecutionSet, &VulkanObjectInfoTable::GetIndirectExecutionSetEXTInfo); + const VkAllocationCallbacks* in_pAllocator = GetAllocationCallbacks(pAllocator); + + GetDeviceTable(in_device)->DestroyIndirectExecutionSetEXT(in_device, in_indirectExecutionSet, in_pAllocator); + RemoveHandle(indirectExecutionSet, &VulkanObjectInfoTable::RemoveIndirectExecutionSetEXTInfo); +} + +void VulkanReplayConsumer::Process_vkUpdateIndirectExecutionSetPipelineEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + VkIndirectExecutionSetEXT in_indirectExecutionSet = MapHandle(indirectExecutionSet, &VulkanObjectInfoTable::GetIndirectExecutionSetEXTInfo); + const VkWriteIndirectExecutionSetPipelineEXT* in_pExecutionSetWrites = pExecutionSetWrites->GetPointer(); + MapStructArrayHandles(pExecutionSetWrites->GetMetaStructPointer(), pExecutionSetWrites->GetLength(), GetObjectInfoTable()); + + GetDeviceTable(in_device)->UpdateIndirectExecutionSetPipelineEXT(in_device, in_indirectExecutionSet, executionSetWriteCount, in_pExecutionSetWrites); +} + +void VulkanReplayConsumer::Process_vkUpdateIndirectExecutionSetShaderEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) +{ + VkDevice in_device = MapHandle(device, &VulkanObjectInfoTable::GetDeviceInfo); + VkIndirectExecutionSetEXT in_indirectExecutionSet = MapHandle(indirectExecutionSet, &VulkanObjectInfoTable::GetIndirectExecutionSetEXTInfo); + const VkWriteIndirectExecutionSetShaderEXT* in_pExecutionSetWrites = pExecutionSetWrites->GetPointer(); + MapStructArrayHandles(pExecutionSetWrites->GetMetaStructPointer(), pExecutionSetWrites->GetLength(), GetObjectInfoTable()); + + GetDeviceTable(in_device)->UpdateIndirectExecutionSetShaderEXT(in_device, in_indirectExecutionSet, executionSetWriteCount, in_pExecutionSetWrites); +} + void VulkanReplayConsumer::Process_vkCreateAccelerationStructureKHR( const ApiCallInfo& call_info, VkResult returnValue, @@ -14876,6 +15044,76 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); @@ -14891,6 +15129,16 @@ static void InitializeOutputStructPNextImpl(const VkBaseInStructure* in_pnext, V output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + { + output_struct->pNext = reinterpret_cast(DecodeAllocator::Allocate()); + break; + } case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: { 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 82a0fc2b73..2898c8f9fa 100644 --- a/framework/generated/generated_vulkan_replay_consumer.h +++ b/framework/generated/generated_vulkan_replay_consumer.h @@ -4128,6 +4128,12 @@ class VulkanReplayConsumer : public VulkanReplayConsumerBase PointerDecoder* pStages, HandlePointerDecoder* pShaders) override; + virtual void Process_vkCmdSetDepthClampRangeEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkDepthClampModeEXT depthClampMode, + StructPointerDecoder* pDepthClampRange) override; + virtual void Process_vkGetFramebufferTilePropertiesQCOM( const ApiCallInfo& call_info, VkResult returnValue, @@ -4179,6 +4185,66 @@ class VulkanReplayConsumer : public VulkanReplayConsumerBase format::HandleId commandBuffer, VkImageAspectFlags aspectMask) override; + virtual void Process_vkGetGeneratedCommandsMemoryRequirementsEXT( + const ApiCallInfo& call_info, + format::HandleId device, + StructPointerDecoder* pInfo, + StructPointerDecoder* pMemoryRequirements) override; + + virtual void Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + StructPointerDecoder* pGeneratedCommandsInfo, + format::HandleId stateCommandBuffer) override; + + virtual void Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + format::HandleId commandBuffer, + VkBool32 isPreprocessed, + StructPointerDecoder* pGeneratedCommandsInfo) override; + + virtual void Process_vkCreateIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectCommandsLayout) override; + + virtual void Process_vkDestroyIndirectCommandsLayoutEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectCommandsLayout, + StructPointerDecoder* pAllocator) override; + + virtual void Process_vkCreateIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + VkResult returnValue, + format::HandleId device, + StructPointerDecoder* pCreateInfo, + StructPointerDecoder* pAllocator, + HandlePointerDecoder* pIndirectExecutionSet) override; + + virtual void Process_vkDestroyIndirectExecutionSetEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + StructPointerDecoder* pAllocator) override; + + virtual void Process_vkUpdateIndirectExecutionSetPipelineEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) override; + + virtual void Process_vkUpdateIndirectExecutionSetShaderEXT( + const ApiCallInfo& call_info, + format::HandleId device, + format::HandleId indirectExecutionSet, + uint32_t executionSetWriteCount, + StructPointerDecoder* pExecutionSetWrites) override; + virtual void Process_vkCreateAccelerationStructureKHR( const ApiCallInfo& call_info, VkResult returnValue, diff --git a/framework/generated/generated_vulkan_replay_dump_resources.cpp b/framework/generated/generated_vulkan_replay_dump_resources.cpp index 364b95df07..b93e9a4f0a 100644 --- a/framework/generated/generated_vulkan_replay_dump_resources.cpp +++ b/framework/generated/generated_vulkan_replay_dump_resources.cpp @@ -5886,6 +5886,33 @@ void VulkanReplayDumpResources::Process_vkCmdBindShadersEXT( } } +void VulkanReplayDumpResources::Process_vkCmdSetDepthClampRangeEXT( + const ApiCallInfo& call_info, + PFN_vkCmdSetDepthClampRangeEXT func, + VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange) +{ + if (IsRecording(commandBuffer)) + { + CommandBufferIterator first, last; + bool found = GetDrawCallActiveCommandBuffers(commandBuffer, first, last); + if (found) + { + for (CommandBufferIterator it = first; it < last; ++it) + { + func(*it, depthClampMode, pDepthClampRange); + } + } + + VkCommandBuffer dispatch_rays_command_buffer = GetDispatchRaysCommandBuffer(commandBuffer); + if (dispatch_rays_command_buffer != VK_NULL_HANDLE) + { + func(dispatch_rays_command_buffer, depthClampMode, pDepthClampRange); + } + } +} + void VulkanReplayDumpResources::Process_vkCmdSetAttachmentFeedbackLoopEnableEXT( @@ -5914,6 +5941,60 @@ void VulkanReplayDumpResources::Process_vkCmdSetAttachmentFeedbackLoopEnableEXT( } } +void VulkanReplayDumpResources::Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + PFN_vkCmdPreprocessGeneratedCommandsEXT func, + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer) +{ + if (IsRecording(commandBuffer)) + { + CommandBufferIterator first, last; + bool found = GetDrawCallActiveCommandBuffers(commandBuffer, first, last); + if (found) + { + for (CommandBufferIterator it = first; it < last; ++it) + { + func(*it, pGeneratedCommandsInfo, stateCommandBuffer); + } + } + + VkCommandBuffer dispatch_rays_command_buffer = GetDispatchRaysCommandBuffer(commandBuffer); + if (dispatch_rays_command_buffer != VK_NULL_HANDLE) + { + func(dispatch_rays_command_buffer, pGeneratedCommandsInfo, stateCommandBuffer); + } + } +} + +void VulkanReplayDumpResources::Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + PFN_vkCmdExecuteGeneratedCommandsEXT func, + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) +{ + if (IsRecording(commandBuffer)) + { + CommandBufferIterator first, last; + bool found = GetDrawCallActiveCommandBuffers(commandBuffer, first, last); + if (found) + { + for (CommandBufferIterator it = first; it < last; ++it) + { + func(*it, isPreprocessed, pGeneratedCommandsInfo); + } + } + + VkCommandBuffer dispatch_rays_command_buffer = GetDispatchRaysCommandBuffer(commandBuffer); + if (dispatch_rays_command_buffer != VK_NULL_HANDLE) + { + func(dispatch_rays_command_buffer, isPreprocessed, pGeneratedCommandsInfo); + } + } +} + void VulkanReplayDumpResources::Process_vkCmdBuildAccelerationStructuresKHR( const ApiCallInfo& call_info, PFN_vkCmdBuildAccelerationStructuresKHR func, diff --git a/framework/generated/generated_vulkan_replay_dump_resources.h b/framework/generated/generated_vulkan_replay_dump_resources.h index eaf3a0fe82..0cf0089372 100644 --- a/framework/generated/generated_vulkan_replay_dump_resources.h +++ b/framework/generated/generated_vulkan_replay_dump_resources.h @@ -1869,6 +1869,13 @@ void Process_vkCmdBindShadersEXT( const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); +void Process_vkCmdSetDepthClampRangeEXT( + const ApiCallInfo& call_info, + PFN_vkCmdSetDepthClampRangeEXT func, + VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange); + @@ -1879,6 +1886,21 @@ void Process_vkCmdSetAttachmentFeedbackLoopEnableEXT( VkImageAspectFlags aspectMask); +void Process_vkCmdPreprocessGeneratedCommandsEXT( + const ApiCallInfo& call_info, + PFN_vkCmdPreprocessGeneratedCommandsEXT func, + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer); + +void Process_vkCmdExecuteGeneratedCommandsEXT( + const ApiCallInfo& call_info, + PFN_vkCmdExecuteGeneratedCommandsEXT func, + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); + + void Process_vkCmdBuildAccelerationStructuresKHR( const ApiCallInfo& call_info, PFN_vkCmdBuildAccelerationStructuresKHR func, diff --git a/framework/generated/generated_vulkan_state_table.h b/framework/generated/generated_vulkan_state_table.h index 39850b1604..6acf004146 100644 --- a/framework/generated/generated_vulkan_state_table.h +++ b/framework/generated/generated_vulkan_state_table.h @@ -64,7 +64,9 @@ class VulkanStateTable : VulkanStateTableBase bool InsertWrapper(format::HandleId id, vulkan_wrappers::FramebufferWrapper* wrapper) { return InsertEntry(id, wrapper, framebuffer_map_); } bool InsertWrapper(format::HandleId id, vulkan_wrappers::ImageWrapper* wrapper) { return InsertEntry(id, wrapper, image_map_); } bool InsertWrapper(format::HandleId id, vulkan_wrappers::ImageViewWrapper* wrapper) { return InsertEntry(id, wrapper, imageView_map_); } + bool InsertWrapper(format::HandleId id, vulkan_wrappers::IndirectCommandsLayoutEXTWrapper* wrapper) { return InsertEntry(id, wrapper, indirectCommandsLayoutEXT_map_); } bool InsertWrapper(format::HandleId id, vulkan_wrappers::IndirectCommandsLayoutNVWrapper* wrapper) { return InsertEntry(id, wrapper, indirectCommandsLayoutNV_map_); } + bool InsertWrapper(format::HandleId id, vulkan_wrappers::IndirectExecutionSetEXTWrapper* wrapper) { return InsertEntry(id, wrapper, indirectExecutionSetEXT_map_); } bool InsertWrapper(format::HandleId id, vulkan_wrappers::InstanceWrapper* wrapper) { return InsertEntry(id, wrapper, instance_map_); } bool InsertWrapper(format::HandleId id, vulkan_wrappers::MicromapEXTWrapper* wrapper) { return InsertEntry(id, wrapper, micromapEXT_map_); } bool InsertWrapper(format::HandleId id, vulkan_wrappers::OpticalFlowSessionNVWrapper* wrapper) { return InsertEntry(id, wrapper, opticalFlowSessionNV_map_); } @@ -111,7 +113,9 @@ class VulkanStateTable : VulkanStateTableBase bool RemoveWrapper(const vulkan_wrappers::FramebufferWrapper* wrapper) { return RemoveEntry(wrapper, framebuffer_map_); } bool RemoveWrapper(const vulkan_wrappers::ImageWrapper* wrapper) { return RemoveEntry(wrapper, image_map_); } bool RemoveWrapper(const vulkan_wrappers::ImageViewWrapper* wrapper) { return RemoveEntry(wrapper, imageView_map_); } + bool RemoveWrapper(const vulkan_wrappers::IndirectCommandsLayoutEXTWrapper* wrapper) { return RemoveEntry(wrapper, indirectCommandsLayoutEXT_map_); } bool RemoveWrapper(const vulkan_wrappers::IndirectCommandsLayoutNVWrapper* wrapper) { return RemoveEntry(wrapper, indirectCommandsLayoutNV_map_); } + bool RemoveWrapper(const vulkan_wrappers::IndirectExecutionSetEXTWrapper* wrapper) { return RemoveEntry(wrapper, indirectExecutionSetEXT_map_); } bool RemoveWrapper(const vulkan_wrappers::InstanceWrapper* wrapper) { return RemoveEntry(wrapper, instance_map_); } bool RemoveWrapper(const vulkan_wrappers::MicromapEXTWrapper* wrapper) { return RemoveEntry(wrapper, micromapEXT_map_); } bool RemoveWrapper(const vulkan_wrappers::OpticalFlowSessionNVWrapper* wrapper) { return RemoveEntry(wrapper, opticalFlowSessionNV_map_); } @@ -158,7 +162,9 @@ class VulkanStateTable : VulkanStateTableBase const vulkan_wrappers::FramebufferWrapper* GetFramebufferWrapper(format::HandleId id) const { return GetWrapper(id, framebuffer_map_); } const vulkan_wrappers::ImageWrapper* GetImageWrapper(format::HandleId id) const { return GetWrapper(id, image_map_); } const vulkan_wrappers::ImageViewWrapper* GetImageViewWrapper(format::HandleId id) const { return GetWrapper(id, imageView_map_); } + const vulkan_wrappers::IndirectCommandsLayoutEXTWrapper* GetIndirectCommandsLayoutEXTWrapper(format::HandleId id) const { return GetWrapper(id, indirectCommandsLayoutEXT_map_); } const vulkan_wrappers::IndirectCommandsLayoutNVWrapper* GetIndirectCommandsLayoutNVWrapper(format::HandleId id) const { return GetWrapper(id, indirectCommandsLayoutNV_map_); } + const vulkan_wrappers::IndirectExecutionSetEXTWrapper* GetIndirectExecutionSetEXTWrapper(format::HandleId id) const { return GetWrapper(id, indirectExecutionSetEXT_map_); } const vulkan_wrappers::InstanceWrapper* GetInstanceWrapper(format::HandleId id) const { return GetWrapper(id, instance_map_); } const vulkan_wrappers::MicromapEXTWrapper* GetMicromapEXTWrapper(format::HandleId id) const { return GetWrapper(id, micromapEXT_map_); } const vulkan_wrappers::OpticalFlowSessionNVWrapper* GetOpticalFlowSessionNVWrapper(format::HandleId id) const { return GetWrapper(id, opticalFlowSessionNV_map_); } @@ -205,7 +211,9 @@ class VulkanStateTable : VulkanStateTableBase vulkan_wrappers::FramebufferWrapper* GetFramebufferWrapper(format::HandleId id) { return GetWrapper(id, framebuffer_map_); } vulkan_wrappers::ImageWrapper* GetImageWrapper(format::HandleId id) { return GetWrapper(id, image_map_); } vulkan_wrappers::ImageViewWrapper* GetImageViewWrapper(format::HandleId id) { return GetWrapper(id, imageView_map_); } + vulkan_wrappers::IndirectCommandsLayoutEXTWrapper* GetIndirectCommandsLayoutEXTWrapper(format::HandleId id) { return GetWrapper(id, indirectCommandsLayoutEXT_map_); } vulkan_wrappers::IndirectCommandsLayoutNVWrapper* GetIndirectCommandsLayoutNVWrapper(format::HandleId id) { return GetWrapper(id, indirectCommandsLayoutNV_map_); } + vulkan_wrappers::IndirectExecutionSetEXTWrapper* GetIndirectExecutionSetEXTWrapper(format::HandleId id) { return GetWrapper(id, indirectExecutionSetEXT_map_); } vulkan_wrappers::InstanceWrapper* GetInstanceWrapper(format::HandleId id) { return GetWrapper(id, instance_map_); } vulkan_wrappers::MicromapEXTWrapper* GetMicromapEXTWrapper(format::HandleId id) { return GetWrapper(id, micromapEXT_map_); } vulkan_wrappers::OpticalFlowSessionNVWrapper* GetOpticalFlowSessionNVWrapper(format::HandleId id) { return GetWrapper(id, opticalFlowSessionNV_map_); } @@ -252,7 +260,9 @@ class VulkanStateTable : VulkanStateTableBase void VisitWrappers(std::function visitor) const { for (auto entry : framebuffer_map_) { visitor(entry.second); } } void VisitWrappers(std::function visitor) const { for (auto entry : image_map_) { visitor(entry.second); } } void VisitWrappers(std::function visitor) const { for (auto entry : imageView_map_) { visitor(entry.second); } } + void VisitWrappers(std::function visitor) const { for (auto entry : indirectCommandsLayoutEXT_map_) { visitor(entry.second); } } void VisitWrappers(std::function visitor) const { for (auto entry : indirectCommandsLayoutNV_map_) { visitor(entry.second); } } + void VisitWrappers(std::function visitor) const { for (auto entry : indirectExecutionSetEXT_map_) { visitor(entry.second); } } void VisitWrappers(std::function visitor) const { for (auto entry : instance_map_) { visitor(entry.second); } } void VisitWrappers(std::function visitor) const { for (auto entry : micromapEXT_map_) { visitor(entry.second); } } void VisitWrappers(std::function visitor) const { for (auto entry : opticalFlowSessionNV_map_) { visitor(entry.second); } } @@ -300,7 +310,9 @@ class VulkanStateTable : VulkanStateTableBase std::map framebuffer_map_; std::map image_map_; std::map imageView_map_; + std::map indirectCommandsLayoutEXT_map_; std::map indirectCommandsLayoutNV_map_; + std::map indirectExecutionSetEXT_map_; std::map instance_map_; std::map micromapEXT_map_; std::map opticalFlowSessionNV_map_; @@ -354,7 +366,9 @@ class VulkanStateHandleTable : VulkanStateTableBase bool InsertWrapper(vulkan_wrappers::FramebufferWrapper* wrapper) { return InsertEntry(wrapper->handle, wrapper, framebuffer_map_); } bool InsertWrapper(vulkan_wrappers::ImageWrapper* wrapper) { return InsertEntry(wrapper->handle, wrapper, image_map_); } bool InsertWrapper(vulkan_wrappers::ImageViewWrapper* wrapper) { return InsertEntry(wrapper->handle, wrapper, imageView_map_); } + bool InsertWrapper(vulkan_wrappers::IndirectCommandsLayoutEXTWrapper* wrapper) { return InsertEntry(wrapper->handle, wrapper, indirectCommandsLayoutEXT_map_); } bool InsertWrapper(vulkan_wrappers::IndirectCommandsLayoutNVWrapper* wrapper) { return InsertEntry(wrapper->handle, wrapper, indirectCommandsLayoutNV_map_); } + bool InsertWrapper(vulkan_wrappers::IndirectExecutionSetEXTWrapper* wrapper) { return InsertEntry(wrapper->handle, wrapper, indirectExecutionSetEXT_map_); } bool InsertWrapper(vulkan_wrappers::InstanceWrapper* wrapper) { return InsertEntry(wrapper->handle, wrapper, instance_map_); } bool InsertWrapper(vulkan_wrappers::MicromapEXTWrapper* wrapper) { return InsertEntry(wrapper->handle, wrapper, micromapEXT_map_); } bool InsertWrapper(vulkan_wrappers::OpticalFlowSessionNVWrapper* wrapper) { return InsertEntry(wrapper->handle, wrapper, opticalFlowSessionNV_map_); } @@ -467,10 +481,18 @@ class VulkanStateHandleTable : VulkanStateTableBase if (wrapper == nullptr) return false; return RemoveEntry(wrapper->handle, imageView_map_); } + bool RemoveWrapper(const vulkan_wrappers::IndirectCommandsLayoutEXTWrapper* wrapper) { + if (wrapper == nullptr) return false; + return RemoveEntry(wrapper->handle, indirectCommandsLayoutEXT_map_); + } bool RemoveWrapper(const vulkan_wrappers::IndirectCommandsLayoutNVWrapper* wrapper) { if (wrapper == nullptr) return false; return RemoveEntry(wrapper->handle, indirectCommandsLayoutNV_map_); } + bool RemoveWrapper(const vulkan_wrappers::IndirectExecutionSetEXTWrapper* wrapper) { + if (wrapper == nullptr) return false; + return RemoveEntry(wrapper->handle, indirectExecutionSetEXT_map_); + } bool RemoveWrapper(const vulkan_wrappers::InstanceWrapper* wrapper) { if (wrapper == nullptr) return false; return RemoveEntry(wrapper->handle, instance_map_); @@ -591,7 +613,9 @@ class VulkanStateHandleTable : VulkanStateTableBase std::unordered_map framebuffer_map_; std::unordered_map image_map_; std::unordered_map imageView_map_; + std::unordered_map indirectCommandsLayoutEXT_map_; std::unordered_map indirectCommandsLayoutNV_map_; + std::unordered_map indirectExecutionSetEXT_map_; std::unordered_map instance_map_; std::unordered_map micromapEXT_map_; std::unordered_map opticalFlowSessionNV_map_; @@ -639,7 +663,9 @@ template<> inline const vulkan_wrappers::FenceWrapper* VulkanStateHandleTable::G template<> inline const vulkan_wrappers::FramebufferWrapper* VulkanStateHandleTable::GetWrapper(VkFramebuffer handle) const { return VulkanStateTableBase::GetWrapper(handle, framebuffer_map_); } template<> inline const vulkan_wrappers::ImageWrapper* VulkanStateHandleTable::GetWrapper(VkImage handle) const { return VulkanStateTableBase::GetWrapper(handle, image_map_); } template<> inline const vulkan_wrappers::ImageViewWrapper* VulkanStateHandleTable::GetWrapper(VkImageView handle) const { return VulkanStateTableBase::GetWrapper(handle, imageView_map_); } +template<> inline const vulkan_wrappers::IndirectCommandsLayoutEXTWrapper* VulkanStateHandleTable::GetWrapper(VkIndirectCommandsLayoutEXT handle) const { return VulkanStateTableBase::GetWrapper(handle, indirectCommandsLayoutEXT_map_); } template<> inline const vulkan_wrappers::IndirectCommandsLayoutNVWrapper* VulkanStateHandleTable::GetWrapper(VkIndirectCommandsLayoutNV handle) const { return VulkanStateTableBase::GetWrapper(handle, indirectCommandsLayoutNV_map_); } +template<> inline const vulkan_wrappers::IndirectExecutionSetEXTWrapper* VulkanStateHandleTable::GetWrapper(VkIndirectExecutionSetEXT handle) const { return VulkanStateTableBase::GetWrapper(handle, indirectExecutionSetEXT_map_); } template<> inline const vulkan_wrappers::InstanceWrapper* VulkanStateHandleTable::GetWrapper(VkInstance handle) const { return VulkanStateTableBase::GetWrapper(handle, instance_map_); } template<> inline const vulkan_wrappers::MicromapEXTWrapper* VulkanStateHandleTable::GetWrapper(VkMicromapEXT handle) const { return VulkanStateTableBase::GetWrapper(handle, micromapEXT_map_); } template<> inline const vulkan_wrappers::OpticalFlowSessionNVWrapper* VulkanStateHandleTable::GetWrapper(VkOpticalFlowSessionNV handle) const { return VulkanStateTableBase::GetWrapper(handle, opticalFlowSessionNV_map_); } @@ -686,7 +712,9 @@ template<> inline vulkan_wrappers::FenceWrapper* VulkanStateHandleTable::GetWrap template<> inline vulkan_wrappers::FramebufferWrapper* VulkanStateHandleTable::GetWrapper(VkFramebuffer handle) { return VulkanStateTableBase::GetWrapper(handle, framebuffer_map_); } template<> inline vulkan_wrappers::ImageWrapper* VulkanStateHandleTable::GetWrapper(VkImage handle) { return VulkanStateTableBase::GetWrapper(handle, image_map_); } template<> inline vulkan_wrappers::ImageViewWrapper* VulkanStateHandleTable::GetWrapper(VkImageView handle) { return VulkanStateTableBase::GetWrapper(handle, imageView_map_); } +template<> inline vulkan_wrappers::IndirectCommandsLayoutEXTWrapper* VulkanStateHandleTable::GetWrapper(VkIndirectCommandsLayoutEXT handle) { return VulkanStateTableBase::GetWrapper(handle, indirectCommandsLayoutEXT_map_); } template<> inline vulkan_wrappers::IndirectCommandsLayoutNVWrapper* VulkanStateHandleTable::GetWrapper(VkIndirectCommandsLayoutNV handle) { return VulkanStateTableBase::GetWrapper(handle, indirectCommandsLayoutNV_map_); } +template<> inline vulkan_wrappers::IndirectExecutionSetEXTWrapper* VulkanStateHandleTable::GetWrapper(VkIndirectExecutionSetEXT handle) { return VulkanStateTableBase::GetWrapper(handle, indirectExecutionSetEXT_map_); } template<> inline vulkan_wrappers::InstanceWrapper* VulkanStateHandleTable::GetWrapper(VkInstance handle) { return VulkanStateTableBase::GetWrapper(handle, instance_map_); } template<> inline vulkan_wrappers::MicromapEXTWrapper* VulkanStateHandleTable::GetWrapper(VkMicromapEXT handle) { return VulkanStateTableBase::GetWrapper(handle, micromapEXT_map_); } template<> inline vulkan_wrappers::OpticalFlowSessionNVWrapper* VulkanStateHandleTable::GetWrapper(VkOpticalFlowSessionNV handle) { return VulkanStateTableBase::GetWrapper(handle, opticalFlowSessionNV_map_); } diff --git a/framework/generated/generated_vulkan_struct_decoders.cpp b/framework/generated/generated_vulkan_struct_decoders.cpp index a5a405b7c0..d76e16ad8f 100644 --- a/framework/generated/generated_vulkan_struct_decoders.cpp +++ b/framework/generated/generated_vulkan_struct_decoders.cpp @@ -19177,6 +19177,19 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkShaderC return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDepthClampRangeEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDepthClampRangeEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->minDepthClamp)); + bytes_read += ValueDecoder::DecodeFloatValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDepthClamp)); + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19920,6 +19933,336 @@ 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_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedCommands)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->dynamicGeneratedPipelineLayout)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectPipelineCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectShaderObjectCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectSequenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsTokenCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsTokenOffset)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxIndirectCommandsIndirectStride)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedIndirectCommandsInputModes)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedIndirectCommandsShaderStages)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedIndirectCommandsShaderStagesPipelineBinding)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->supportedIndirectCommandsShaderStagesShaderBinding)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedCommandsTransformFeedback)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->deviceGeneratedCommandsMultiDrawIndirectCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkGeneratedCommandsMemoryRequirementsInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectExecutionSet)); + value->indirectExecutionSet = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectCommandsLayout)); + value->indirectCommandsLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSequenceCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDrawCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectExecutionSetPipelineInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectExecutionSetPipelineInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->initialPipeline)); + value->initialPipeline = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxPipelineCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectExecutionSetShaderLayoutInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->setLayoutCount)); + bytes_read += wrapper->pSetLayouts.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSetLayouts = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectExecutionSetShaderInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectExecutionSetShaderInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCount)); + bytes_read += wrapper->pInitialShaders.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pInitialShaders = nullptr; + wrapper->pSetLayoutInfos = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pSetLayoutInfos->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pSetLayoutInfos = wrapper->pSetLayoutInfos->GetPointer(); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxShaderCount)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->pushConstantRangeCount)); + wrapper->pPushConstantRanges = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pPushConstantRanges->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pPushConstantRanges = wrapper->pPushConstantRanges->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeneratedCommandsInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkGeneratedCommandsInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStages)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectExecutionSet)); + value->indirectExecutionSet = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->indirectCommandsLayout)); + value->indirectCommandsLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indirectAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indirectAddressSize)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preprocessAddress)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->preprocessSize)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxSequenceCount)); + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->sequenceCountAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->maxDrawCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteIndirectExecutionSetPipelineEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWriteIndirectExecutionSetPipelineEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->index)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); + value->pipeline = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsPushConstantTokenEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectCommandsPushConstantTokenEXT* value = wrapper->decoded_value; + + wrapper->updateRange = DecodeAllocator::Allocate(); + wrapper->updateRange->decoded_value = &(value->updateRange); + bytes_read += DecodeStruct((buffer + bytes_read), (buffer_size - bytes_read), wrapper->updateRange); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsVertexBufferTokenEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectCommandsVertexBufferTokenEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->vertexBindingUnit)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsIndexBufferTokenEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectCommandsIndexBufferTokenEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->mode)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsExecutionSetTokenEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectCommandsExecutionSetTokenEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->type)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStages)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutCreateInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkIndirectCommandsLayoutCreateInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->flags)); + bytes_read += ValueDecoder::DecodeFlagsValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderStages)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->indirectStride)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipelineLayout)); + value->pipelineLayout = VK_NULL_HANDLE; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->tokenCount)); + wrapper->pTokens = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pTokens->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pTokens = wrapper->pTokens->GetPointer(); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkDrawIndirectCountIndirectCommandEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkDrawIndirectCountIndirectCommandEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->commandCount)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindVertexBufferIndirectCommandEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindVertexBufferIndirectCommandEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->stride)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkBindIndexBufferIndirectCommandEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkBindIndexBufferIndirectCommandEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeUInt64Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->bufferAddress)); + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->size)); + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->indexType)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeneratedCommandsPipelineInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkGeneratedCommandsPipelineInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pipeline)); + value->pipeline = VK_NULL_HANDLE; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkGeneratedCommandsShaderInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkGeneratedCommandsShaderInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->shaderCount)); + bytes_read += wrapper->pShaders.Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pShaders = nullptr; + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkWriteIndirectExecutionSetShaderEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkWriteIndirectExecutionSetShaderEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->index)); + bytes_read += ValueDecoder::DecodeHandleIdValue((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->shader)); + value->shader = VK_NULL_HANDLE; + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* wrapper) { assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); @@ -19965,6 +20308,39 @@ size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkImageAl return bytes_read; } +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClampControlFeaturesEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPhysicalDeviceDepthClampControlFeaturesEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->sType)); + bytes_read += DecodePNextStruct((buffer + bytes_read), (buffer_size - bytes_read), &(wrapper->pNext)); + value->pNext = wrapper->pNext ? wrapper->pNext->GetPointer() : nullptr; + bytes_read += ValueDecoder::DecodeUInt32Value((buffer + bytes_read), (buffer_size - bytes_read), &(value->depthClampControl)); + + return bytes_read; +} + +size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkPipelineViewportDepthClampControlCreateInfoEXT* wrapper) +{ + assert((wrapper != nullptr) && (wrapper->decoded_value != nullptr)); + + size_t bytes_read = 0; + VkPipelineViewportDepthClampControlCreateInfoEXT* value = wrapper->decoded_value; + + bytes_read += ValueDecoder::DecodeEnumValue((buffer + bytes_read), (buffer_size - bytes_read), &(value->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->depthClampMode)); + wrapper->pDepthClampRange = DecodeAllocator::Allocate>(); + bytes_read += wrapper->pDepthClampRange->Decode((buffer + bytes_read), (buffer_size - bytes_read)); + value->pDepthClampRange = wrapper->pDepthClampRange->GetPointer(); + + return bytes_read; +} + size_t DecodeStruct(const uint8_t* buffer, size_t buffer_size, Decoded_VkAccelerationStructureBuildRangeInfoKHR* 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 fed1b4b950..eaea7ea173 100644 --- a/framework/generated/generated_vulkan_struct_decoders.h +++ b/framework/generated/generated_vulkan_struct_decoders.h @@ -9950,6 +9950,13 @@ struct Decoded_VkShaderCreateInfoEXT StructPointerDecoder* pSpecializationInfo{ nullptr }; }; +struct Decoded_VkDepthClampRangeEXT +{ + using struct_type = VkDepthClampRangeEXT; + + VkDepthClampRangeEXT* decoded_value{ nullptr }; +}; + typedef Decoded_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo Decoded_VkShaderRequiredSubgroupSizeCreateInfoEXT; struct Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM @@ -10378,6 +10385,180 @@ struct Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV PNextNode* pNext{ nullptr }; }; +struct Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT +{ + using struct_type = VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT +{ + using struct_type = VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT +{ + using struct_type = VkGeneratedCommandsMemoryRequirementsInfoEXT; + + VkGeneratedCommandsMemoryRequirementsInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + format::HandleId indirectExecutionSet{ format::kNullHandleId }; + format::HandleId indirectCommandsLayout{ format::kNullHandleId }; +}; + +struct Decoded_VkIndirectExecutionSetPipelineInfoEXT +{ + using struct_type = VkIndirectExecutionSetPipelineInfoEXT; + + VkIndirectExecutionSetPipelineInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + format::HandleId initialPipeline{ format::kNullHandleId }; +}; + +struct Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT +{ + using struct_type = VkIndirectExecutionSetShaderLayoutInfoEXT; + + VkIndirectExecutionSetShaderLayoutInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + HandlePointerDecoder pSetLayouts; +}; + +struct Decoded_VkIndirectExecutionSetShaderInfoEXT +{ + using struct_type = VkIndirectExecutionSetShaderInfoEXT; + + VkIndirectExecutionSetShaderInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + HandlePointerDecoder pInitialShaders; + StructPointerDecoder* pSetLayoutInfos{ nullptr }; + StructPointerDecoder* pPushConstantRanges{ nullptr }; +}; + +struct Decoded_VkGeneratedCommandsInfoEXT +{ + using struct_type = VkGeneratedCommandsInfoEXT; + + VkGeneratedCommandsInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + format::HandleId indirectExecutionSet{ format::kNullHandleId }; + format::HandleId indirectCommandsLayout{ format::kNullHandleId }; +}; + +struct Decoded_VkWriteIndirectExecutionSetPipelineEXT +{ + using struct_type = VkWriteIndirectExecutionSetPipelineEXT; + + VkWriteIndirectExecutionSetPipelineEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + format::HandleId pipeline{ format::kNullHandleId }; +}; + +struct Decoded_VkIndirectCommandsPushConstantTokenEXT +{ + using struct_type = VkIndirectCommandsPushConstantTokenEXT; + + VkIndirectCommandsPushConstantTokenEXT* decoded_value{ nullptr }; + + Decoded_VkPushConstantRange* updateRange{ nullptr }; +}; + +struct Decoded_VkIndirectCommandsVertexBufferTokenEXT +{ + using struct_type = VkIndirectCommandsVertexBufferTokenEXT; + + VkIndirectCommandsVertexBufferTokenEXT* decoded_value{ nullptr }; +}; + +struct Decoded_VkIndirectCommandsIndexBufferTokenEXT +{ + using struct_type = VkIndirectCommandsIndexBufferTokenEXT; + + VkIndirectCommandsIndexBufferTokenEXT* decoded_value{ nullptr }; +}; + +struct Decoded_VkIndirectCommandsExecutionSetTokenEXT +{ + using struct_type = VkIndirectCommandsExecutionSetTokenEXT; + + VkIndirectCommandsExecutionSetTokenEXT* decoded_value{ nullptr }; +}; + +struct Decoded_VkIndirectCommandsLayoutCreateInfoEXT +{ + using struct_type = VkIndirectCommandsLayoutCreateInfoEXT; + + VkIndirectCommandsLayoutCreateInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + format::HandleId pipelineLayout{ format::kNullHandleId }; + StructPointerDecoder* pTokens{ nullptr }; +}; + +struct Decoded_VkDrawIndirectCountIndirectCommandEXT +{ + using struct_type = VkDrawIndirectCountIndirectCommandEXT; + + VkDrawIndirectCountIndirectCommandEXT* decoded_value{ nullptr }; +}; + +struct Decoded_VkBindVertexBufferIndirectCommandEXT +{ + using struct_type = VkBindVertexBufferIndirectCommandEXT; + + VkBindVertexBufferIndirectCommandEXT* decoded_value{ nullptr }; +}; + +struct Decoded_VkBindIndexBufferIndirectCommandEXT +{ + using struct_type = VkBindIndexBufferIndirectCommandEXT; + + VkBindIndexBufferIndirectCommandEXT* decoded_value{ nullptr }; +}; + +struct Decoded_VkGeneratedCommandsPipelineInfoEXT +{ + using struct_type = VkGeneratedCommandsPipelineInfoEXT; + + VkGeneratedCommandsPipelineInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + format::HandleId pipeline{ format::kNullHandleId }; +}; + +struct Decoded_VkGeneratedCommandsShaderInfoEXT +{ + using struct_type = VkGeneratedCommandsShaderInfoEXT; + + VkGeneratedCommandsShaderInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + HandlePointerDecoder pShaders; +}; + +struct Decoded_VkWriteIndirectExecutionSetShaderEXT +{ + using struct_type = VkWriteIndirectExecutionSetShaderEXT; + + VkWriteIndirectExecutionSetShaderEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + format::HandleId shader{ format::kNullHandleId }; +}; + struct Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA { using struct_type = VkPhysicalDeviceImageAlignmentControlFeaturesMESA; @@ -10405,6 +10586,25 @@ struct Decoded_VkImageAlignmentControlCreateInfoMESA PNextNode* pNext{ nullptr }; }; +struct Decoded_VkPhysicalDeviceDepthClampControlFeaturesEXT +{ + using struct_type = VkPhysicalDeviceDepthClampControlFeaturesEXT; + + VkPhysicalDeviceDepthClampControlFeaturesEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; +}; + +struct Decoded_VkPipelineViewportDepthClampControlCreateInfoEXT +{ + using struct_type = VkPipelineViewportDepthClampControlCreateInfoEXT; + + VkPipelineViewportDepthClampControlCreateInfoEXT* decoded_value{ nullptr }; + + PNextNode* pNext{ nullptr }; + StructPointerDecoder* pDepthClampRange{ nullptr }; +}; + struct Decoded_VkAccelerationStructureBuildRangeInfoKHR { using struct_type = VkAccelerationStructureBuildRangeInfoKHR; diff --git a/framework/generated/generated_vulkan_struct_decoders_forward.h b/framework/generated/generated_vulkan_struct_decoders_forward.h index 8a16de4662..37dcf00e1e 100644 --- a/framework/generated/generated_vulkan_struct_decoders_forward.h +++ b/framework/generated/generated_vulkan_struct_decoders_forward.h @@ -2469,10 +2469,12 @@ size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded struct Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT; struct Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT; struct Decoded_VkShaderCreateInfoEXT; +struct Decoded_VkDepthClampRangeEXT; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkShaderCreateInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDepthClampRangeEXT* wrapper); struct Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM; struct Decoded_VkTilePropertiesQCOM; @@ -2616,6 +2618,46 @@ struct Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV; size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV* wrapper); +struct Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; +struct Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; +struct Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT; +struct Decoded_VkIndirectExecutionSetPipelineInfoEXT; +struct Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT; +struct Decoded_VkIndirectExecutionSetShaderInfoEXT; +struct Decoded_VkGeneratedCommandsInfoEXT; +struct Decoded_VkWriteIndirectExecutionSetPipelineEXT; +struct Decoded_VkIndirectCommandsPushConstantTokenEXT; +struct Decoded_VkIndirectCommandsVertexBufferTokenEXT; +struct Decoded_VkIndirectCommandsIndexBufferTokenEXT; +struct Decoded_VkIndirectCommandsExecutionSetTokenEXT; +struct Decoded_VkIndirectCommandsLayoutCreateInfoEXT; +struct Decoded_VkDrawIndirectCountIndirectCommandEXT; +struct Decoded_VkBindVertexBufferIndirectCommandEXT; +struct Decoded_VkBindIndexBufferIndirectCommandEXT; +struct Decoded_VkGeneratedCommandsPipelineInfoEXT; +struct Decoded_VkGeneratedCommandsShaderInfoEXT; +struct Decoded_VkWriteIndirectExecutionSetShaderEXT; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectExecutionSetPipelineInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectExecutionSetShaderInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeneratedCommandsInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWriteIndirectExecutionSetPipelineEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectCommandsPushConstantTokenEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectCommandsVertexBufferTokenEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectCommandsIndexBufferTokenEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectCommandsExecutionSetTokenEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkIndirectCommandsLayoutCreateInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkDrawIndirectCountIndirectCommandEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindVertexBufferIndirectCommandEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkBindIndexBufferIndirectCommandEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeneratedCommandsPipelineInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkGeneratedCommandsShaderInfoEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkWriteIndirectExecutionSetShaderEXT* wrapper); + struct Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA; struct Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA; struct Decoded_VkImageAlignmentControlCreateInfoMESA; @@ -2624,6 +2666,12 @@ size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* wrapper); size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkImageAlignmentControlCreateInfoMESA* wrapper); +struct Decoded_VkPhysicalDeviceDepthClampControlFeaturesEXT; +struct Decoded_VkPipelineViewportDepthClampControlCreateInfoEXT; + +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPhysicalDeviceDepthClampControlFeaturesEXT* wrapper); +size_t DecodeStruct(const uint8_t* parameter_buffer, size_t buffer_size, Decoded_VkPipelineViewportDepthClampControlCreateInfoEXT* wrapper); + struct Decoded_VkAccelerationStructureBuildRangeInfoKHR; struct Decoded_VkAccelerationStructureGeometryTrianglesDataKHR; struct Decoded_VkAccelerationStructureGeometryAabbsDataKHR; diff --git a/framework/generated/generated_vulkan_struct_deep_copy.cpp b/framework/generated/generated_vulkan_struct_deep_copy.cpp index 43df760fe4..5e5c1d1208 100644 --- a/framework/generated/generated_vulkan_struct_deep_copy.cpp +++ b/framework/generated/generated_vulkan_struct_deep_copy.cpp @@ -21405,6 +21405,362 @@ size_t vulkan_struct_deep_copy(const VkPhysicalDeviceRayTracingValidationFeature return offset; } +template <> +size_t vulkan_struct_deep_copy(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkGeneratedCommandsMemoryRequirementsInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkIndirectExecutionSetPipelineInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkIndirectExecutionSetShaderLayoutInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + handle_pointer(base_struct, base_struct.pSetLayouts, base_struct.setLayoutCount, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkIndirectExecutionSetShaderInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + handle_pointer(base_struct, base_struct.pInitialShaders, base_struct.shaderCount, i, offset, out_data); + handle_pointer(base_struct, base_struct.pSetLayoutInfos, base_struct.shaderCount, i, offset, out_data); + handle_pointer(base_struct, base_struct.pPushConstantRanges, base_struct.pushConstantRangeCount, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkIndirectExecutionSetCreateInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkGeneratedCommandsInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkWriteIndirectExecutionSetPipelineEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkIndirectCommandsLayoutTokenEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkIndirectCommandsLayoutCreateInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + handle_pointer(base_struct, base_struct.pTokens, base_struct.tokenCount, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkGeneratedCommandsPipelineInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkGeneratedCommandsShaderInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + handle_pointer(base_struct, base_struct.pShaders, base_struct.shaderCount, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkWriteIndirectExecutionSetShaderEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + template <> size_t vulkan_struct_deep_copy(const VkPhysicalDeviceImageAlignmentControlFeaturesMESA* structs, uint32_t count, uint8_t* out_data) { @@ -21480,6 +21836,57 @@ size_t vulkan_struct_deep_copy(const VkImageAlignmentControlCreateInfoMESA* stru return offset; } +template <> +size_t vulkan_struct_deep_copy(const VkPhysicalDeviceDepthClampControlFeaturesEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + } + return offset; +} + +template <> +size_t vulkan_struct_deep_copy(const VkPipelineViewportDepthClampControlCreateInfoEXT* structs, uint32_t count, uint8_t* out_data) +{ + using struct_type = std::decay_t; + constexpr uint32_t struct_size = sizeof(struct_type); + + if (structs == nullptr || count == 0) + { + return 0; + } + uint64_t offset = struct_size * count; + + for (uint32_t i = 0; i < count; ++i) + { + const auto& base_struct = structs[i]; + if (out_data != nullptr) + { + auto out_structures = reinterpret_cast(out_data); + out_structures[i] = base_struct; + } + handle_pnext(base_struct, i, offset, out_data); + handle_pointer(base_struct, base_struct.pDepthClampRange, 1, i, offset, out_data); + } + return offset; +} + template <> size_t vulkan_struct_deep_copy(const VkAccelerationStructureGeometryTrianglesDataKHR* structs, uint32_t count, uint8_t* out_data) { diff --git a/framework/generated/generated_vulkan_struct_deep_copy_stype.cpp b/framework/generated/generated_vulkan_struct_deep_copy_stype.cpp index a0d927ddba..a7d7908673 100644 --- a/framework/generated/generated_vulkan_struct_deep_copy_stype.cpp +++ b/framework/generated/generated_vulkan_struct_deep_copy_stype.cpp @@ -3337,6 +3337,62 @@ size_t vulkan_struct_deep_copy_stype(const void* pNext, uint8_t* out_data) offset += vulkan_struct_deep_copy( reinterpret_cast(pNext), 1, out_ptr); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: offset += vulkan_struct_deep_copy( reinterpret_cast(pNext), 1, out_ptr); @@ -3349,6 +3405,14 @@ size_t vulkan_struct_deep_copy_stype(const void* pNext, uint8_t* out_data) offset += vulkan_struct_deep_copy( reinterpret_cast(pNext), 1, out_ptr); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + offset += vulkan_struct_deep_copy( + reinterpret_cast(pNext), 1, out_ptr); + break; case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: offset += vulkan_struct_deep_copy( reinterpret_cast(pNext), 1, out_ptr); diff --git a/framework/generated/generated_vulkan_struct_encoders.cpp b/framework/generated/generated_vulkan_struct_encoders.cpp index 74a3556393..5c2979eecc 100644 --- a/framework/generated/generated_vulkan_struct_encoders.cpp +++ b/framework/generated/generated_vulkan_struct_encoders.cpp @@ -9556,6 +9556,12 @@ void EncodeStruct(ParameterEncoder* encoder, const VkShaderCreateInfoEXT& value) EncodeStructPtr(encoder, value.pSpecializationInfo); } +void EncodeStruct(ParameterEncoder* encoder, const VkDepthClampRangeEXT& value) +{ + encoder->EncodeFloatValue(value.minDepthClamp); + encoder->EncodeFloatValue(value.maxDepthClamp); +} + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceTilePropertiesFeaturesQCOM& value) { encoder->EncodeEnumValue(value.sType); @@ -9911,6 +9917,171 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRayTracingVal encoder->EncodeUInt32Value(value.rayTracingValidation); } +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.deviceGeneratedCommands); + encoder->EncodeUInt32Value(value.dynamicGeneratedPipelineLayout); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.maxIndirectPipelineCount); + encoder->EncodeUInt32Value(value.maxIndirectShaderObjectCount); + encoder->EncodeUInt32Value(value.maxIndirectSequenceCount); + encoder->EncodeUInt32Value(value.maxIndirectCommandsTokenCount); + encoder->EncodeUInt32Value(value.maxIndirectCommandsTokenOffset); + encoder->EncodeUInt32Value(value.maxIndirectCommandsIndirectStride); + encoder->EncodeFlagsValue(value.supportedIndirectCommandsInputModes); + encoder->EncodeFlagsValue(value.supportedIndirectCommandsShaderStages); + encoder->EncodeFlagsValue(value.supportedIndirectCommandsShaderStagesPipelineBinding); + encoder->EncodeFlagsValue(value.supportedIndirectCommandsShaderStagesShaderBinding); + encoder->EncodeUInt32Value(value.deviceGeneratedCommandsTransformFeedback); + encoder->EncodeUInt32Value(value.deviceGeneratedCommandsMultiDrawIndirectCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkGeneratedCommandsMemoryRequirementsInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVulkanHandleValue(value.indirectExecutionSet); + encoder->EncodeVulkanHandleValue(value.indirectCommandsLayout); + encoder->EncodeUInt32Value(value.maxSequenceCount); + encoder->EncodeUInt32Value(value.maxDrawCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectExecutionSetPipelineInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVulkanHandleValue(value.initialPipeline); + encoder->EncodeUInt32Value(value.maxPipelineCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectExecutionSetShaderLayoutInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.setLayoutCount); + encoder->EncodeVulkanHandleArray(value.pSetLayouts, value.setLayoutCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectExecutionSetShaderInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.shaderCount); + encoder->EncodeVulkanHandleArray(value.pInitialShaders, value.shaderCount); + EncodeStructArray(encoder, value.pSetLayoutInfos, value.shaderCount); + encoder->EncodeUInt32Value(value.maxShaderCount); + encoder->EncodeUInt32Value(value.pushConstantRangeCount); + EncodeStructArray(encoder, value.pPushConstantRanges, value.pushConstantRangeCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkGeneratedCommandsInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.shaderStages); + encoder->EncodeVulkanHandleValue(value.indirectExecutionSet); + encoder->EncodeVulkanHandleValue(value.indirectCommandsLayout); + encoder->EncodeUInt64Value(value.indirectAddress); + encoder->EncodeUInt64Value(value.indirectAddressSize); + encoder->EncodeUInt64Value(value.preprocessAddress); + encoder->EncodeUInt64Value(value.preprocessSize); + encoder->EncodeUInt32Value(value.maxSequenceCount); + encoder->EncodeUInt64Value(value.sequenceCountAddress); + encoder->EncodeUInt32Value(value.maxDrawCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkWriteIndirectExecutionSetPipelineEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.index); + encoder->EncodeVulkanHandleValue(value.pipeline); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsPushConstantTokenEXT& value) +{ + EncodeStruct(encoder, value.updateRange); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsVertexBufferTokenEXT& value) +{ + encoder->EncodeUInt32Value(value.vertexBindingUnit); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsIndexBufferTokenEXT& value) +{ + encoder->EncodeEnumValue(value.mode); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsExecutionSetTokenEXT& value) +{ + encoder->EncodeEnumValue(value.type); + encoder->EncodeFlagsValue(value.shaderStages); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsLayoutCreateInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeFlagsValue(value.flags); + encoder->EncodeFlagsValue(value.shaderStages); + encoder->EncodeUInt32Value(value.indirectStride); + encoder->EncodeVulkanHandleValue(value.pipelineLayout); + encoder->EncodeUInt32Value(value.tokenCount); + EncodeStructArray(encoder, value.pTokens, value.tokenCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkDrawIndirectCountIndirectCommandEXT& value) +{ + encoder->EncodeUInt64Value(value.bufferAddress); + encoder->EncodeUInt32Value(value.stride); + encoder->EncodeUInt32Value(value.commandCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkBindVertexBufferIndirectCommandEXT& value) +{ + encoder->EncodeUInt64Value(value.bufferAddress); + encoder->EncodeUInt32Value(value.size); + encoder->EncodeUInt32Value(value.stride); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkBindIndexBufferIndirectCommandEXT& value) +{ + encoder->EncodeUInt64Value(value.bufferAddress); + encoder->EncodeUInt32Value(value.size); + encoder->EncodeEnumValue(value.indexType); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkGeneratedCommandsPipelineInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeVulkanHandleValue(value.pipeline); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkGeneratedCommandsShaderInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.shaderCount); + encoder->EncodeVulkanHandleArray(value.pShaders, value.shaderCount); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkWriteIndirectExecutionSetShaderEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.index); + encoder->EncodeVulkanHandleValue(value.shader); +} + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceImageAlignmentControlFeaturesMESA& value) { encoder->EncodeEnumValue(value.sType); @@ -9932,6 +10103,21 @@ void EncodeStruct(ParameterEncoder* encoder, const VkImageAlignmentControlCreate encoder->EncodeUInt32Value(value.maximumRequestedAlignment); } +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceDepthClampControlFeaturesEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeUInt32Value(value.depthClampControl); +} + +void EncodeStruct(ParameterEncoder* encoder, const VkPipelineViewportDepthClampControlCreateInfoEXT& value) +{ + encoder->EncodeEnumValue(value.sType); + EncodePNextStruct(encoder, value.pNext); + encoder->EncodeEnumValue(value.depthClampMode); + EncodeStructPtr(encoder, value.pDepthClampRange); +} + void EncodeStruct(ParameterEncoder* encoder, const VkAccelerationStructureBuildRangeInfoKHR& value) { encoder->EncodeUInt32Value(value.primitiveCount); diff --git a/framework/generated/generated_vulkan_struct_encoders.h b/framework/generated/generated_vulkan_struct_encoders.h index cb21397798..0813d3a63e 100644 --- a/framework/generated/generated_vulkan_struct_encoders.h +++ b/framework/generated/generated_vulkan_struct_encoders.h @@ -1263,6 +1263,7 @@ void EncodeStruct(ParameterEncoder* encoder, const VkAntiLagDataAMD& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderObjectFeaturesEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderObjectPropertiesEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkShaderCreateInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkDepthClampRangeEXT& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceTilePropertiesFeaturesQCOM& value); void EncodeStruct(ParameterEncoder* encoder, const VkTilePropertiesQCOM& value); @@ -1335,10 +1336,33 @@ void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceShaderReplica void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceRayTracingValidationFeaturesNV& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkGeneratedCommandsMemoryRequirementsInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectExecutionSetPipelineInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectExecutionSetShaderLayoutInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectExecutionSetShaderInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkGeneratedCommandsInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkWriteIndirectExecutionSetPipelineEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsPushConstantTokenEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsVertexBufferTokenEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsIndexBufferTokenEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsExecutionSetTokenEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkIndirectCommandsLayoutCreateInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkDrawIndirectCountIndirectCommandEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkBindVertexBufferIndirectCommandEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkBindIndexBufferIndirectCommandEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkGeneratedCommandsPipelineInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkGeneratedCommandsShaderInfoEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkWriteIndirectExecutionSetShaderEXT& value); + void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceImageAlignmentControlFeaturesMESA& value); void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceImageAlignmentControlPropertiesMESA& value); void EncodeStruct(ParameterEncoder* encoder, const VkImageAlignmentControlCreateInfoMESA& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPhysicalDeviceDepthClampControlFeaturesEXT& value); +void EncodeStruct(ParameterEncoder* encoder, const VkPipelineViewportDepthClampControlCreateInfoEXT& value); + void EncodeStruct(ParameterEncoder* encoder, const VkAccelerationStructureBuildRangeInfoKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkAccelerationStructureGeometryTrianglesDataKHR& value); void EncodeStruct(ParameterEncoder* encoder, const VkAccelerationStructureGeometryAabbsDataKHR& value); diff --git a/framework/generated/generated_vulkan_struct_handle_mappers.cpp b/framework/generated/generated_vulkan_struct_handle_mappers.cpp index 286d4721cf..c7c30f3c81 100644 --- a/framework/generated/generated_vulkan_struct_handle_mappers.cpp +++ b/framework/generated/generated_vulkan_struct_handle_mappers.cpp @@ -1867,6 +1867,127 @@ void MapStructHandles(Decoded_VkLatencySleepInfoNV* wrapper, const VulkanObjectI } } +void MapStructHandles(Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkGeneratedCommandsMemoryRequirementsInfoEXT* value = wrapper->decoded_value; + + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + + value->indirectExecutionSet = handle_mapping::MapHandle(wrapper->indirectExecutionSet, object_info_table, &VulkanObjectInfoTable::GetIndirectExecutionSetEXTInfo); + + value->indirectCommandsLayout = handle_mapping::MapHandle(wrapper->indirectCommandsLayout, object_info_table, &VulkanObjectInfoTable::GetIndirectCommandsLayoutEXTInfo); + } +} + +void MapStructHandles(Decoded_VkIndirectExecutionSetPipelineInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkIndirectExecutionSetPipelineInfoEXT* value = wrapper->decoded_value; + + value->initialPipeline = handle_mapping::MapHandle(wrapper->initialPipeline, object_info_table, &VulkanObjectInfoTable::GetPipelineInfo); + } +} + +void MapStructHandles(Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkIndirectExecutionSetShaderLayoutInfoEXT* value = wrapper->decoded_value; + + value->pSetLayouts = handle_mapping::MapHandleArray(&wrapper->pSetLayouts, object_info_table, &VulkanObjectInfoTable::GetDescriptorSetLayoutInfo); + } +} + +void MapStructHandles(Decoded_VkIndirectExecutionSetShaderInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkIndirectExecutionSetShaderInfoEXT* value = wrapper->decoded_value; + + value->pInitialShaders = handle_mapping::MapHandleArray(&wrapper->pInitialShaders, object_info_table, &VulkanObjectInfoTable::GetShaderEXTInfo); + + MapStructArrayHandles(wrapper->pSetLayoutInfos->GetMetaStructPointer(), wrapper->pSetLayoutInfos->GetLength(), object_info_table); + } +} + +void MapStructHandles(Decoded_VkGeneratedCommandsInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkGeneratedCommandsInfoEXT* value = wrapper->decoded_value; + + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + + value->indirectExecutionSet = handle_mapping::MapHandle(wrapper->indirectExecutionSet, object_info_table, &VulkanObjectInfoTable::GetIndirectExecutionSetEXTInfo); + + value->indirectCommandsLayout = handle_mapping::MapHandle(wrapper->indirectCommandsLayout, object_info_table, &VulkanObjectInfoTable::GetIndirectCommandsLayoutEXTInfo); + } +} + +void MapStructHandles(Decoded_VkWriteIndirectExecutionSetPipelineEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkWriteIndirectExecutionSetPipelineEXT* value = wrapper->decoded_value; + + value->pipeline = handle_mapping::MapHandle(wrapper->pipeline, object_info_table, &VulkanObjectInfoTable::GetPipelineInfo); + } +} + +void MapStructHandles(Decoded_VkIndirectCommandsLayoutCreateInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkIndirectCommandsLayoutCreateInfoEXT* value = wrapper->decoded_value; + + if (wrapper->pNext) + { + MapPNextStructHandles(wrapper->pNext->GetPointer(), wrapper->pNext->GetMetaStructPointer(), object_info_table); + } + + value->pipelineLayout = handle_mapping::MapHandle(wrapper->pipelineLayout, object_info_table, &VulkanObjectInfoTable::GetPipelineLayoutInfo); + } +} + +void MapStructHandles(Decoded_VkGeneratedCommandsPipelineInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkGeneratedCommandsPipelineInfoEXT* value = wrapper->decoded_value; + + value->pipeline = handle_mapping::MapHandle(wrapper->pipeline, object_info_table, &VulkanObjectInfoTable::GetPipelineInfo); + } +} + +void MapStructHandles(Decoded_VkGeneratedCommandsShaderInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkGeneratedCommandsShaderInfoEXT* value = wrapper->decoded_value; + + value->pShaders = handle_mapping::MapHandleArray(&wrapper->pShaders, object_info_table, &VulkanObjectInfoTable::GetShaderEXTInfo); + } +} + +void MapStructHandles(Decoded_VkWriteIndirectExecutionSetShaderEXT* wrapper, const VulkanObjectInfoTable& object_info_table) +{ + if ((wrapper != nullptr) && (wrapper->decoded_value != nullptr)) + { + VkWriteIndirectExecutionSetShaderEXT* value = wrapper->decoded_value; + + value->shader = handle_mapping::MapHandle(wrapper->shader, object_info_table, &VulkanObjectInfoTable::GetShaderEXTInfo); + } +} + void MapStructHandles(Decoded_VkAccelerationStructureGeometryTrianglesDataKHR* wrapper, const VulkanObjectInfoTable& object_info_table) { if (wrapper != nullptr) @@ -2044,6 +2165,12 @@ void MapPNextStructHandles(const void* value, void* wrapper, const VulkanObjectI case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: MapStructHandles(reinterpret_cast(wrapper), object_info_table); break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + MapStructHandles(reinterpret_cast(wrapper), object_info_table); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + 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 0ab3370d43..7db653c6f6 100644 --- a/framework/generated/generated_vulkan_struct_handle_mappers.h +++ b/framework/generated/generated_vulkan_struct_handle_mappers.h @@ -375,6 +375,26 @@ void MapStructHandles(Decoded_VkShaderCreateInfoEXT* wrapper, const VulkanObject void MapStructHandles(Decoded_VkLatencySleepInfoNV* wrapper, const VulkanObjectInfoTable& object_info_table); +void MapStructHandles(Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkIndirectExecutionSetPipelineInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkIndirectExecutionSetShaderInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkGeneratedCommandsInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkWriteIndirectExecutionSetPipelineEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkIndirectCommandsLayoutCreateInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkGeneratedCommandsPipelineInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkGeneratedCommandsShaderInfoEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + +void MapStructHandles(Decoded_VkWriteIndirectExecutionSetShaderEXT* wrapper, const VulkanObjectInfoTable& object_info_table); + void MapStructHandles(Decoded_VkAccelerationStructureGeometryTrianglesDataKHR* wrapper, const VulkanObjectInfoTable& object_info_table); void MapStructHandles(Decoded_VkAccelerationStructureCreateInfoKHR* 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 af6ad48735..d3a9646355 100644 --- a/framework/generated/generated_vulkan_struct_handle_wrappers.cpp +++ b/framework/generated/generated_vulkan_struct_handle_wrappers.cpp @@ -1311,6 +1311,89 @@ void UnwrapStructHandles(VkLatencySleepInfoNV* value, HandleUnwrapMemory* unwrap } } +void UnwrapStructHandles(VkGeneratedCommandsMemoryRequirementsInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + if (value->pNext != nullptr) + { + value->pNext = const_cast(UnwrapPNextStructHandles(value->pNext, unwrap_memory)); + } + } +} + +void UnwrapStructHandles(VkIndirectExecutionSetPipelineInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + } +} + +void UnwrapStructHandles(VkIndirectExecutionSetShaderLayoutInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + } +} + +void UnwrapStructHandles(VkIndirectExecutionSetShaderInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + value->pSetLayoutInfos = UnwrapStructArrayHandles(value->pSetLayoutInfos, value->shaderCount, unwrap_memory); + } +} + +void UnwrapStructHandles(VkGeneratedCommandsInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } + } +} + +void UnwrapStructHandles(VkWriteIndirectExecutionSetPipelineEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + } +} + +void UnwrapStructHandles(VkIndirectCommandsLayoutCreateInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + if (value->pNext != nullptr) + { + value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory); + } + } +} + +void UnwrapStructHandles(VkGeneratedCommandsPipelineInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + } +} + +void UnwrapStructHandles(VkGeneratedCommandsShaderInfoEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + } +} + +void UnwrapStructHandles(VkWriteIndirectExecutionSetShaderEXT* value, HandleUnwrapMemory* unwrap_memory) +{ + if (value != nullptr) + { + } +} + void UnwrapStructHandles(VkAccelerationStructureGeometryTrianglesDataKHR* value, HandleUnwrapMemory* unwrap_memory) { if (value != nullptr) @@ -3031,6 +3114,18 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -3040,6 +3135,12 @@ VkBaseInStructure* CopyPNextStruct(const VkBaseInStructure* base, HandleUnwrapMe case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); + break; case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: copy = reinterpret_cast(MakeUnwrapStructs(reinterpret_cast(base), 1, unwrap_memory)); break; @@ -3135,6 +3236,10 @@ const void* UnwrapPNextStructHandles(const void* value, HandleUnwrapMemory* unwr 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_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + return UnwrapStructPtrHandles(reinterpret_cast(base), unwrap_memory); + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + 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 a50560324d..6a6e1cb27e 100644 --- a/framework/generated/generated_vulkan_struct_handle_wrappers.h +++ b/framework/generated/generated_vulkan_struct_handle_wrappers.h @@ -375,6 +375,26 @@ void UnwrapStructHandles(VkShaderCreateInfoEXT* value, HandleUnwrapMemory* unwra void UnwrapStructHandles(VkLatencySleepInfoNV* value, HandleUnwrapMemory* unwrap_memory); +void UnwrapStructHandles(VkGeneratedCommandsMemoryRequirementsInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkIndirectExecutionSetPipelineInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkIndirectExecutionSetShaderLayoutInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkIndirectExecutionSetShaderInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkGeneratedCommandsInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkWriteIndirectExecutionSetPipelineEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkIndirectCommandsLayoutCreateInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkGeneratedCommandsPipelineInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkGeneratedCommandsShaderInfoEXT* value, HandleUnwrapMemory* unwrap_memory); + +void UnwrapStructHandles(VkWriteIndirectExecutionSetShaderEXT* value, HandleUnwrapMemory* unwrap_memory); + void UnwrapStructHandles(VkAccelerationStructureGeometryTrianglesDataKHR* value, HandleUnwrapMemory* unwrap_memory); void UnwrapStructHandles(VkAccelerationStructureCreateInfoKHR* 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 047057cbf1..df8372d10d 100644 --- a/framework/generated/generated_vulkan_struct_to_json.cpp +++ b/framework/generated/generated_vulkan_struct_to_json.cpp @@ -15424,6 +15424,18 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkShaderCreateInfo } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDepthClampRangeEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkDepthClampRangeEXT& decoded_value = *data->decoded_value; + const Decoded_VkDepthClampRangeEXT& meta_struct = *data; + + FieldToJson(jdata["minDepthClamp"], decoded_value.minDepthClamp, options); + FieldToJson(jdata["maxDepthClamp"], decoded_value.maxDepthClamp, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -16055,6 +16067,285 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRa } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["deviceGeneratedCommands"] = static_cast(decoded_value.deviceGeneratedCommands); + jdata["dynamicGeneratedPipelineLayout"] = static_cast(decoded_value.dynamicGeneratedPipelineLayout); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["maxIndirectPipelineCount"], decoded_value.maxIndirectPipelineCount, options); + FieldToJson(jdata["maxIndirectShaderObjectCount"], decoded_value.maxIndirectShaderObjectCount, options); + FieldToJson(jdata["maxIndirectSequenceCount"], decoded_value.maxIndirectSequenceCount, options); + FieldToJson(jdata["maxIndirectCommandsTokenCount"], decoded_value.maxIndirectCommandsTokenCount, options); + FieldToJson(jdata["maxIndirectCommandsTokenOffset"], decoded_value.maxIndirectCommandsTokenOffset, options); + FieldToJson(jdata["maxIndirectCommandsIndirectStride"], decoded_value.maxIndirectCommandsIndirectStride, options); + FieldToJson(VkIndirectCommandsInputModeFlagsEXT_t(),jdata["supportedIndirectCommandsInputModes"], decoded_value.supportedIndirectCommandsInputModes, options); + FieldToJson(VkShaderStageFlags_t(),jdata["supportedIndirectCommandsShaderStages"], decoded_value.supportedIndirectCommandsShaderStages, options); + FieldToJson(VkShaderStageFlags_t(),jdata["supportedIndirectCommandsShaderStagesPipelineBinding"], decoded_value.supportedIndirectCommandsShaderStagesPipelineBinding, options); + FieldToJson(VkShaderStageFlags_t(),jdata["supportedIndirectCommandsShaderStagesShaderBinding"], decoded_value.supportedIndirectCommandsShaderStagesShaderBinding, options); + jdata["deviceGeneratedCommandsTransformFeedback"] = static_cast(decoded_value.deviceGeneratedCommandsTransformFeedback); + jdata["deviceGeneratedCommandsMultiDrawIndirectCount"] = static_cast(decoded_value.deviceGeneratedCommandsMultiDrawIndirectCount); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkGeneratedCommandsMemoryRequirementsInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + HandleToJson(jdata["indirectExecutionSet"], meta_struct.indirectExecutionSet, options); + HandleToJson(jdata["indirectCommandsLayout"], meta_struct.indirectCommandsLayout, options); + FieldToJson(jdata["maxSequenceCount"], decoded_value.maxSequenceCount, options); + FieldToJson(jdata["maxDrawCount"], decoded_value.maxDrawCount, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectExecutionSetPipelineInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkIndirectExecutionSetPipelineInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkIndirectExecutionSetPipelineInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + HandleToJson(jdata["initialPipeline"], meta_struct.initialPipeline, options); + FieldToJson(jdata["maxPipelineCount"], decoded_value.maxPipelineCount, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkIndirectExecutionSetShaderLayoutInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["setLayoutCount"], decoded_value.setLayoutCount, options); + HandleToJson(jdata["pSetLayouts"], &meta_struct.pSetLayouts, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectExecutionSetShaderInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkIndirectExecutionSetShaderInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkIndirectExecutionSetShaderInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["shaderCount"], decoded_value.shaderCount, options); + HandleToJson(jdata["pInitialShaders"], &meta_struct.pInitialShaders, options); + FieldToJson(jdata["pSetLayoutInfos"], meta_struct.pSetLayoutInfos, options); + FieldToJson(jdata["maxShaderCount"], decoded_value.maxShaderCount, options); + FieldToJson(jdata["pushConstantRangeCount"], decoded_value.pushConstantRangeCount, options); + FieldToJson(jdata["pPushConstantRanges"], meta_struct.pPushConstantRanges, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkGeneratedCommandsInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkGeneratedCommandsInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkGeneratedCommandsInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkShaderStageFlags_t(),jdata["shaderStages"], decoded_value.shaderStages, options); + HandleToJson(jdata["indirectExecutionSet"], meta_struct.indirectExecutionSet, options); + HandleToJson(jdata["indirectCommandsLayout"], meta_struct.indirectCommandsLayout, options); + FieldToJson(jdata["indirectAddress"], to_hex_variable_width(decoded_value.indirectAddress), options); + FieldToJson(jdata["indirectAddressSize"], decoded_value.indirectAddressSize, options); + FieldToJson(jdata["preprocessAddress"], to_hex_variable_width(decoded_value.preprocessAddress), options); + FieldToJson(jdata["preprocessSize"], decoded_value.preprocessSize, options); + FieldToJson(jdata["maxSequenceCount"], decoded_value.maxSequenceCount, options); + FieldToJson(jdata["sequenceCountAddress"], to_hex_variable_width(decoded_value.sequenceCountAddress), options); + FieldToJson(jdata["maxDrawCount"], decoded_value.maxDrawCount, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkWriteIndirectExecutionSetPipelineEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkWriteIndirectExecutionSetPipelineEXT& decoded_value = *data->decoded_value; + const Decoded_VkWriteIndirectExecutionSetPipelineEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["index"], decoded_value.index, options); + HandleToJson(jdata["pipeline"], meta_struct.pipeline, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsPushConstantTokenEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkIndirectCommandsPushConstantTokenEXT& decoded_value = *data->decoded_value; + const Decoded_VkIndirectCommandsPushConstantTokenEXT& meta_struct = *data; + + FieldToJson(jdata["updateRange"], meta_struct.updateRange, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsVertexBufferTokenEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkIndirectCommandsVertexBufferTokenEXT& decoded_value = *data->decoded_value; + const Decoded_VkIndirectCommandsVertexBufferTokenEXT& meta_struct = *data; + + FieldToJson(jdata["vertexBindingUnit"], decoded_value.vertexBindingUnit, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsIndexBufferTokenEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkIndirectCommandsIndexBufferTokenEXT& decoded_value = *data->decoded_value; + const Decoded_VkIndirectCommandsIndexBufferTokenEXT& meta_struct = *data; + + FieldToJson(jdata["mode"], decoded_value.mode, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsExecutionSetTokenEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkIndirectCommandsExecutionSetTokenEXT& decoded_value = *data->decoded_value; + const Decoded_VkIndirectCommandsExecutionSetTokenEXT& meta_struct = *data; + + FieldToJson(jdata["type"], decoded_value.type, options); + FieldToJson(VkShaderStageFlags_t(),jdata["shaderStages"], decoded_value.shaderStages, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsLayoutCreateInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkIndirectCommandsLayoutCreateInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkIndirectCommandsLayoutCreateInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(VkIndirectCommandsLayoutUsageFlagsEXT_t(),jdata["flags"], decoded_value.flags, options); + FieldToJson(VkShaderStageFlags_t(),jdata["shaderStages"], decoded_value.shaderStages, options); + FieldToJson(jdata["indirectStride"], decoded_value.indirectStride, options); + HandleToJson(jdata["pipelineLayout"], meta_struct.pipelineLayout, options); + FieldToJson(jdata["tokenCount"], decoded_value.tokenCount, options); + FieldToJson(jdata["pTokens"], meta_struct.pTokens, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDrawIndirectCountIndirectCommandEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkDrawIndirectCountIndirectCommandEXT& decoded_value = *data->decoded_value; + const Decoded_VkDrawIndirectCountIndirectCommandEXT& meta_struct = *data; + + FieldToJson(jdata["bufferAddress"], to_hex_variable_width(decoded_value.bufferAddress), options); + FieldToJson(jdata["stride"], decoded_value.stride, options); + FieldToJson(jdata["commandCount"], decoded_value.commandCount, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindVertexBufferIndirectCommandEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkBindVertexBufferIndirectCommandEXT& decoded_value = *data->decoded_value; + const Decoded_VkBindVertexBufferIndirectCommandEXT& meta_struct = *data; + + FieldToJson(jdata["bufferAddress"], to_hex_variable_width(decoded_value.bufferAddress), options); + FieldToJson(jdata["size"], decoded_value.size, options); + FieldToJson(jdata["stride"], decoded_value.stride, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindIndexBufferIndirectCommandEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkBindIndexBufferIndirectCommandEXT& decoded_value = *data->decoded_value; + const Decoded_VkBindIndexBufferIndirectCommandEXT& meta_struct = *data; + + FieldToJson(jdata["bufferAddress"], to_hex_variable_width(decoded_value.bufferAddress), options); + FieldToJson(jdata["size"], decoded_value.size, options); + FieldToJson(jdata["indexType"], decoded_value.indexType, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkGeneratedCommandsPipelineInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkGeneratedCommandsPipelineInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkGeneratedCommandsPipelineInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + HandleToJson(jdata["pipeline"], meta_struct.pipeline, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkGeneratedCommandsShaderInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkGeneratedCommandsShaderInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkGeneratedCommandsShaderInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["shaderCount"], decoded_value.shaderCount, options); + HandleToJson(jdata["pShaders"], &meta_struct.pShaders, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkWriteIndirectExecutionSetShaderEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkWriteIndirectExecutionSetShaderEXT& decoded_value = *data->decoded_value; + const Decoded_VkWriteIndirectExecutionSetShaderEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["index"], decoded_value.index, options); + HandleToJson(jdata["shader"], meta_struct.shader, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -16094,6 +16385,33 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageAlignmentCo } } +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDepthClampControlFeaturesEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPhysicalDeviceDepthClampControlFeaturesEXT& decoded_value = *data->decoded_value; + const Decoded_VkPhysicalDeviceDepthClampControlFeaturesEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + jdata["depthClampControl"] = static_cast(decoded_value.depthClampControl); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineViewportDepthClampControlCreateInfoEXT* data, const JsonOptions& options) +{ + if (data && data->decoded_value) + { + const VkPipelineViewportDepthClampControlCreateInfoEXT& decoded_value = *data->decoded_value; + const Decoded_VkPipelineViewportDepthClampControlCreateInfoEXT& meta_struct = *data; + + FieldToJson(jdata["sType"], decoded_value.sType, options); + FieldToJson(jdata["depthClampMode"], decoded_value.depthClampMode, options); + FieldToJson(jdata["pDepthClampRange"], meta_struct.pDepthClampRange, options); + FieldToJson(jdata["pNext"], meta_struct.pNext, options); + } +} + void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAccelerationStructureBuildRangeInfoKHR* data, const JsonOptions& options) { if (data && data->decoded_value) @@ -20362,6 +20680,34 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); @@ -20383,6 +20729,20 @@ void FieldToJson(nlohmann::ordered_json& jdata, const PNextNode* data, const Jso break; } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + { + const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); + FieldToJson(jdata, pnext, options); + break; + } + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: { const auto* pnext = reinterpret_cast(data->GetMetaStructPointer()); diff --git a/framework/generated/generated_vulkan_struct_to_json.h b/framework/generated/generated_vulkan_struct_to_json.h index 901ff95943..a7cc1bddcc 100644 --- a/framework/generated/generated_vulkan_struct_to_json.h +++ b/framework/generated/generated_vulkan_struct_to_json.h @@ -1019,6 +1019,7 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAntiLagDataAMD* void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderObjectFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderObjectPropertiesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkShaderCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDepthClampRangeEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceTilePropertiesFeaturesQCOM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkTilePropertiesQCOM* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceAmigoProfilingFeaturesSEC* data, const util::JsonOptions& options = util::JsonOptions()); @@ -1065,9 +1066,30 @@ void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceCo void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceRayTracingValidationFeaturesNV* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkGeneratedCommandsMemoryRequirementsInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectExecutionSetPipelineInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectExecutionSetShaderLayoutInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectExecutionSetShaderInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkGeneratedCommandsInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkWriteIndirectExecutionSetPipelineEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsPushConstantTokenEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsVertexBufferTokenEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsIndexBufferTokenEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsExecutionSetTokenEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkIndirectCommandsLayoutCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkDrawIndirectCountIndirectCommandEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindVertexBufferIndirectCommandEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkBindIndexBufferIndirectCommandEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkGeneratedCommandsPipelineInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkGeneratedCommandsShaderInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkWriteIndirectExecutionSetShaderEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceImageAlignmentControlFeaturesMESA* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceImageAlignmentControlPropertiesMESA* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkImageAlignmentControlCreateInfoMESA* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPhysicalDeviceDepthClampControlFeaturesEXT* data, const util::JsonOptions& options = util::JsonOptions()); +void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkPipelineViewportDepthClampControlCreateInfoEXT* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAccelerationStructureBuildRangeInfoKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAccelerationStructureGeometryTrianglesDataKHR* data, const util::JsonOptions& options = util::JsonOptions()); void FieldToJson(nlohmann::ordered_json& jdata, const Decoded_VkAccelerationStructureGeometryAabbsDataKHR* data, const util::JsonOptions& options = util::JsonOptions()); diff --git a/framework/generated/generated_vulkan_stype_util.h b/framework/generated/generated_vulkan_stype_util.h index 6288f27089..4e2a0d4284 100644 --- a/framework/generated/generated_vulkan_stype_util.h +++ b/framework/generated/generated_vulkan_stype_util.h @@ -881,9 +881,25 @@ template <> constexpr VkStructureType GetSType constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; } template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; } template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT; } template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; } template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; } template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; } +template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; } template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR; } template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR; } template <> constexpr VkStructureType GetSType(){ return VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR; } diff --git a/framework/generated/vulkan_generators/blacklists.json b/framework/generated/vulkan_generators/blacklists.json index b3fc6dc97e..75fe354d31 100644 --- a/framework/generated/vulkan_generators/blacklists.json +++ b/framework/generated/vulkan_generators/blacklists.json @@ -32,6 +32,10 @@ "VkPerformanceValueINTEL", "VkPushDescriptorSetWithTemplateInfoKHR", "VkAccelerationStructureGeometryKHR", - "VkAccelerationStructureMotionInstanceNV" + "VkAccelerationStructureMotionInstanceNV", + "VkIndirectExecutionSetInfoEXT", + "VkIndirectExecutionSetCreateInfoEXT", + "VkIndirectCommandsTokenDataEXT", + "VkIndirectCommandsLayoutTokenEXT" ] } diff --git a/framework/generated/vulkan_generators/vulkan_struct_handle_wrappers_body_generator.py b/framework/generated/vulkan_generators/vulkan_struct_handle_wrappers_body_generator.py index 3ec45f536e..f149bd5e07 100644 --- a/framework/generated/vulkan_generators/vulkan_struct_handle_wrappers_body_generator.py +++ b/framework/generated/vulkan_generators/vulkan_struct_handle_wrappers_body_generator.py @@ -277,7 +277,11 @@ def make_struct_handle_unwrappings( if 'pNext' in member.name: body += ' if (value->pNext != nullptr)\n' body += ' {\n' - body += ' value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory);\n' + # Workaround for spec missing const in VkGeneratedCommandsMemoryRequirementsInfoEXT::pNext, should be removed next header update + if (name == 'VkGeneratedCommandsMemoryRequirementsInfoEXT'): + body += ' value->pNext = const_cast(UnwrapPNextStructHandles(value->pNext, unwrap_memory));\n' + else: + body += ' value->pNext = UnwrapPNextStructHandles(value->pNext, unwrap_memory);\n' body += ' }\n' elif self.is_struct(member.base_type): # This is a struct that includes handles.