From 467f61cd34b30a817d3b9c8fddecd661dc86e1fe Mon Sep 17 00:00:00 2001 From: Mike Schuchardt Date: Thu, 29 Sep 2022 11:32:12 -0700 Subject: [PATCH] build: Update to header 1.3.230 - Update known-good - Generate source --- build-android/vulkan-headers_revision_android | 2 +- common/vulkan_wrapper.cpp | 51 ++++ icd/generated/mock_icd.cpp | 419 ++++++++++++++++++++++++++ icd/generated/mock_icd.h | 314 ++++++++++++++++++- icd/generated/vk_typemap_helper.h | 252 ++++++++++++++++ scripts/generate_vulkan_wrapper.py | 81 ++++- scripts/known_good.json | 4 +- vulkaninfo/generated/vulkaninfo.hpp | 141 +++++++++ 8 files changed, 1259 insertions(+), 5 deletions(-) diff --git a/build-android/vulkan-headers_revision_android b/build-android/vulkan-headers_revision_android index cf4cb61..953c139 100644 --- a/build-android/vulkan-headers_revision_android +++ b/build-android/vulkan-headers_revision_android @@ -1 +1 @@ -v1.3.229 +v1.3.230 diff --git a/common/vulkan_wrapper.cpp b/common/vulkan_wrapper.cpp index aca5cac..76a15b9 100644 --- a/common/vulkan_wrapper.cpp +++ b/common/vulkan_wrapper.cpp @@ -1040,6 +1040,7 @@ PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT; PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT; PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV; PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT; +PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT; PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV; PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV; PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT; @@ -1056,11 +1057,61 @@ PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT; PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT; PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT; PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT; +PFN_vkCreateMicromapEXT vkCreateMicromapEXT; +PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT; +PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT; +PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT; +PFN_vkCopyMicromapEXT vkCopyMicromapEXT; +PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT; +PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT; +PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT; +PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT; +PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT; +PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT; +PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT; +PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT; +PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT; PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT; PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE; PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE; +PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT; +PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT; +PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT; +PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT; +PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT; +PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT; +PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT; +PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT; +PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT; +PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT; +PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT; +PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT; +PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT; +PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT; +PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT; +PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT; +PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT; +PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT; +PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT; +PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT; +PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT; +PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV; +PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV; +PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV; +PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV; +PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV; +PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV; +PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV; +PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV; +PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV; +PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV; PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT; PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT; +PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV; +PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV; +PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV; +PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV; +PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV; PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM; PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM; PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR; diff --git a/icd/generated/mock_icd.cpp b/icd/generated/mock_icd.cpp index a8dcf25..df781e3 100644 --- a/icd/generated/mock_icd.cpp +++ b/icd/generated/mock_icd.cpp @@ -5315,6 +5315,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT( + static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, @@ -5397,6 +5398,16 @@ static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + #ifdef VK_USE_PLATFORM_WIN32_KHR @@ -5456,6 +5467,7 @@ static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT( + #ifdef VK_USE_PLATFORM_FUCHSIA static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( @@ -5690,6 +5702,133 @@ static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT( +static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( + VkDevice device, + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap) +{ + unique_lock_t lock(global_lock); + *pMicromap = (VkMicromapEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( + VkDevice device, + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT( + VkDevice device, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( + VkDevice device, + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo) +{ +//Not a CREATE or DESTROY function +} + + static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( @@ -5725,6 +5864,236 @@ static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( +static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClampEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( + VkCommandBuffer commandBuffer, + VkPolygonMode polygonMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode) +{ +//Not a CREATE or DESTROY function +} + + static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( VkDevice device, @@ -5744,6 +6113,56 @@ static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession) +{ + unique_lock_t lock(global_lock); + *pSession = (VkOpticalFlowSessionNV)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo) +{ +//Not a CREATE or DESTROY function +} + + + static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( VkDevice device, diff --git a/icd/generated/mock_icd.h b/icd/generated/mock_icd.h index acc780d..db2e846 100644 --- a/icd/generated/mock_icd.h +++ b/icd/generated/mock_icd.h @@ -99,7 +99,7 @@ static const std::unordered_map device_extension_map = { {"VK_AMD_shader_trinary_minmax", 1}, {"VK_AMD_shader_explicit_vertex_parameter", 1}, {"VK_EXT_debug_marker", 4}, - {"VK_KHR_video_queue", 6}, + {"VK_KHR_video_queue", 7}, {"VK_KHR_video_decode_queue", 6}, {"VK_AMD_gcn_shader", 1}, {"VK_NV_dedicated_allocation", 1}, @@ -280,6 +280,7 @@ static const std::unordered_map device_extension_map = { {"VK_EXT_custom_border_color", 12}, {"VK_GOOGLE_user_type", 1}, {"VK_KHR_pipeline_library", 1}, + {"VK_NV_present_barrier", 1}, {"VK_KHR_shader_non_semantic_info", 1}, {"VK_KHR_present_id", 1}, {"VK_EXT_private_data", 1}, @@ -306,12 +307,14 @@ static const std::unordered_map device_extension_map = { {"VK_EXT_image_compression_control", 1}, {"VK_EXT_attachment_feedback_loop_layout", 2}, {"VK_EXT_4444_formats", 1}, + {"VK_EXT_device_fault", 1}, {"VK_ARM_rasterization_order_attachment_access", 1}, {"VK_EXT_rgba10x6_formats", 1}, {"VK_NV_acquire_winrt_display", 1}, {"VK_VALVE_mutable_descriptor_type", 1}, {"VK_EXT_vertex_input_dynamic_state", 2}, {"VK_EXT_physical_device_drm", 1}, + {"VK_EXT_device_address_binding_report", 1}, {"VK_EXT_depth_clip_control", 1}, {"VK_EXT_primitive_topology_list_restart", 1}, {"VK_KHR_format_feature_flags2", 2}, @@ -331,6 +334,7 @@ static const std::unordered_map device_extension_map = { {"VK_EXT_image_view_min_lod", 1}, {"VK_EXT_multi_draw", 1}, {"VK_EXT_image_2d_view_of_3d", 1}, + {"VK_EXT_opacity_micromap", 2}, {"VK_EXT_load_store_op_none", 1}, {"VK_EXT_border_color_swizzle", 1}, {"VK_EXT_pageable_device_local_memory", 1}, @@ -342,10 +346,13 @@ static const std::unordered_map device_extension_map = { {"VK_NV_linear_color_attachment", 1}, {"VK_EXT_image_compression_control_swapchain", 1}, {"VK_QCOM_image_processing", 1}, + {"VK_EXT_extended_dynamic_state3", 2}, {"VK_EXT_subpass_merge_feedback", 2}, {"VK_EXT_shader_module_identifier", 1}, {"VK_EXT_rasterization_order_attachment_access", 1}, + {"VK_NV_optical_flow", 1}, {"VK_EXT_legacy_dithering", 1}, + {"VK_EXT_pipeline_protected_access", 1}, {"VK_QCOM_tile_properties", 1}, {"VK_SEC_amigo_profiling", 1}, {"VK_EXT_mutable_descriptor_type", 1}, @@ -3312,6 +3319,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT( + static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, @@ -3370,6 +3378,12 @@ static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo); + + #ifdef VK_USE_PLATFORM_WIN32_KHR @@ -3409,6 +3423,7 @@ static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT( + #ifdef VK_USE_PLATFORM_FUCHSIA static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( @@ -3556,6 +3571,84 @@ static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT( +static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( + VkDevice device, + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap); + +static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( + VkDevice device, + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT( + VkDevice device, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( + VkDevice device, + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); + +static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo); + + static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( @@ -3582,6 +3675,143 @@ static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( +static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClampEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( + VkCommandBuffer commandBuffer, + VkPolygonMode polygonMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples); + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask); + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream); + +static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced); + +static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode); + + static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( VkDevice device, @@ -3595,6 +3825,37 @@ static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession); + +static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout); + +static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo); + + + static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( VkDevice device, @@ -4359,6 +4620,7 @@ static const std::unordered_map name_to_funcptr_map = { #endif {"vkCmdSetFragmentShadingRateEnumNV", (void*)CmdSetFragmentShadingRateEnumNV}, {"vkGetImageSubresourceLayout2EXT", (void*)GetImageSubresourceLayout2EXT}, + {"vkGetDeviceFaultInfoEXT", (void*)GetDeviceFaultInfoEXT}, #ifdef VK_USE_PLATFORM_WIN32_KHR {"vkAcquireWinrtDisplayNV", (void*)AcquireWinrtDisplayNV}, #endif @@ -4418,11 +4680,61 @@ static const std::unordered_map name_to_funcptr_map = { {"vkCmdSetColorWriteEnableEXT", (void*)CmdSetColorWriteEnableEXT}, {"vkCmdDrawMultiEXT", (void*)CmdDrawMultiEXT}, {"vkCmdDrawMultiIndexedEXT", (void*)CmdDrawMultiIndexedEXT}, + {"vkCreateMicromapEXT", (void*)CreateMicromapEXT}, + {"vkDestroyMicromapEXT", (void*)DestroyMicromapEXT}, + {"vkCmdBuildMicromapsEXT", (void*)CmdBuildMicromapsEXT}, + {"vkBuildMicromapsEXT", (void*)BuildMicromapsEXT}, + {"vkCopyMicromapEXT", (void*)CopyMicromapEXT}, + {"vkCopyMicromapToMemoryEXT", (void*)CopyMicromapToMemoryEXT}, + {"vkCopyMemoryToMicromapEXT", (void*)CopyMemoryToMicromapEXT}, + {"vkWriteMicromapsPropertiesEXT", (void*)WriteMicromapsPropertiesEXT}, + {"vkCmdCopyMicromapEXT", (void*)CmdCopyMicromapEXT}, + {"vkCmdCopyMicromapToMemoryEXT", (void*)CmdCopyMicromapToMemoryEXT}, + {"vkCmdCopyMemoryToMicromapEXT", (void*)CmdCopyMemoryToMicromapEXT}, + {"vkCmdWriteMicromapsPropertiesEXT", (void*)CmdWriteMicromapsPropertiesEXT}, + {"vkGetDeviceMicromapCompatibilityEXT", (void*)GetDeviceMicromapCompatibilityEXT}, + {"vkGetMicromapBuildSizesEXT", (void*)GetMicromapBuildSizesEXT}, {"vkSetDeviceMemoryPriorityEXT", (void*)SetDeviceMemoryPriorityEXT}, {"vkGetDescriptorSetLayoutHostMappingInfoVALVE", (void*)GetDescriptorSetLayoutHostMappingInfoVALVE}, {"vkGetDescriptorSetHostMappingVALVE", (void*)GetDescriptorSetHostMappingVALVE}, + {"vkCmdSetTessellationDomainOriginEXT", (void*)CmdSetTessellationDomainOriginEXT}, + {"vkCmdSetDepthClampEnableEXT", (void*)CmdSetDepthClampEnableEXT}, + {"vkCmdSetPolygonModeEXT", (void*)CmdSetPolygonModeEXT}, + {"vkCmdSetRasterizationSamplesEXT", (void*)CmdSetRasterizationSamplesEXT}, + {"vkCmdSetSampleMaskEXT", (void*)CmdSetSampleMaskEXT}, + {"vkCmdSetAlphaToCoverageEnableEXT", (void*)CmdSetAlphaToCoverageEnableEXT}, + {"vkCmdSetAlphaToOneEnableEXT", (void*)CmdSetAlphaToOneEnableEXT}, + {"vkCmdSetLogicOpEnableEXT", (void*)CmdSetLogicOpEnableEXT}, + {"vkCmdSetColorBlendEnableEXT", (void*)CmdSetColorBlendEnableEXT}, + {"vkCmdSetColorBlendEquationEXT", (void*)CmdSetColorBlendEquationEXT}, + {"vkCmdSetColorWriteMaskEXT", (void*)CmdSetColorWriteMaskEXT}, + {"vkCmdSetRasterizationStreamEXT", (void*)CmdSetRasterizationStreamEXT}, + {"vkCmdSetConservativeRasterizationModeEXT", (void*)CmdSetConservativeRasterizationModeEXT}, + {"vkCmdSetExtraPrimitiveOverestimationSizeEXT", (void*)CmdSetExtraPrimitiveOverestimationSizeEXT}, + {"vkCmdSetDepthClipEnableEXT", (void*)CmdSetDepthClipEnableEXT}, + {"vkCmdSetSampleLocationsEnableEXT", (void*)CmdSetSampleLocationsEnableEXT}, + {"vkCmdSetColorBlendAdvancedEXT", (void*)CmdSetColorBlendAdvancedEXT}, + {"vkCmdSetProvokingVertexModeEXT", (void*)CmdSetProvokingVertexModeEXT}, + {"vkCmdSetLineRasterizationModeEXT", (void*)CmdSetLineRasterizationModeEXT}, + {"vkCmdSetLineStippleEnableEXT", (void*)CmdSetLineStippleEnableEXT}, + {"vkCmdSetDepthClipNegativeOneToOneEXT", (void*)CmdSetDepthClipNegativeOneToOneEXT}, + {"vkCmdSetViewportWScalingEnableNV", (void*)CmdSetViewportWScalingEnableNV}, + {"vkCmdSetViewportSwizzleNV", (void*)CmdSetViewportSwizzleNV}, + {"vkCmdSetCoverageToColorEnableNV", (void*)CmdSetCoverageToColorEnableNV}, + {"vkCmdSetCoverageToColorLocationNV", (void*)CmdSetCoverageToColorLocationNV}, + {"vkCmdSetCoverageModulationModeNV", (void*)CmdSetCoverageModulationModeNV}, + {"vkCmdSetCoverageModulationTableEnableNV", (void*)CmdSetCoverageModulationTableEnableNV}, + {"vkCmdSetCoverageModulationTableNV", (void*)CmdSetCoverageModulationTableNV}, + {"vkCmdSetShadingRateImageEnableNV", (void*)CmdSetShadingRateImageEnableNV}, + {"vkCmdSetRepresentativeFragmentTestEnableNV", (void*)CmdSetRepresentativeFragmentTestEnableNV}, + {"vkCmdSetCoverageReductionModeNV", (void*)CmdSetCoverageReductionModeNV}, {"vkGetShaderModuleIdentifierEXT", (void*)GetShaderModuleIdentifierEXT}, {"vkGetShaderModuleCreateInfoIdentifierEXT", (void*)GetShaderModuleCreateInfoIdentifierEXT}, + {"vkGetPhysicalDeviceOpticalFlowImageFormatsNV", (void*)GetPhysicalDeviceOpticalFlowImageFormatsNV}, + {"vkCreateOpticalFlowSessionNV", (void*)CreateOpticalFlowSessionNV}, + {"vkDestroyOpticalFlowSessionNV", (void*)DestroyOpticalFlowSessionNV}, + {"vkBindOpticalFlowSessionImageNV", (void*)BindOpticalFlowSessionImageNV}, + {"vkCmdOpticalFlowExecuteNV", (void*)CmdOpticalFlowExecuteNV}, {"vkGetFramebufferTilePropertiesQCOM", (void*)GetFramebufferTilePropertiesQCOM}, {"vkGetDynamicRenderingTilePropertiesQCOM", (void*)GetDynamicRenderingTilePropertiesQCOM}, {"vkCreateAccelerationStructureKHR", (void*)CreateAccelerationStructureKHR}, diff --git a/icd/generated/vk_typemap_helper.h b/icd/generated/vk_typemap_helper.h index 0ebe449..b374b0e 100644 --- a/icd/generated/vk_typemap_helper.h +++ b/icd/generated/vk_typemap_helper.h @@ -5176,6 +5176,33 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePresentBarrierFeaturesNV Type; +}; + +// Map type VkSurfaceCapabilitiesPresentBarrierNV to id VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkSurfaceCapabilitiesPresentBarrierNV Type; +}; + +// Map type VkSwapchainPresentBarrierCreateInfoNV to id VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkSwapchainPresentBarrierCreateInfoNV Type; +}; + // Map type VkPhysicalDeviceDiagnosticsConfigFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; @@ -5515,6 +5542,33 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceFaultFeaturesEXT Type; +}; + +// Map type VkDeviceFaultCountsEXT to id VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceFaultCountsEXT Type; +}; + +// Map type VkDeviceFaultInfoEXT to id VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceFaultInfoEXT Type; +}; + // Map type VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; @@ -5598,6 +5652,24 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceAddressBindingReportFeaturesEXT Type; +}; + +// Map type VkDeviceAddressBindingCallbackDataEXT to id VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkDeviceAddressBindingCallbackDataEXT Type; +}; + // Map type VkPhysicalDeviceDepthClipControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; @@ -5981,6 +6053,96 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMicromapBuildInfoEXT Type; +}; + +// Map type VkMicromapCreateInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMicromapCreateInfoEXT Type; +}; + +// Map type VkPhysicalDeviceOpacityMicromapFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceOpacityMicromapFeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceOpacityMicromapPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceOpacityMicromapPropertiesEXT Type; +}; + +// Map type VkMicromapVersionInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMicromapVersionInfoEXT Type; +}; + +// Map type VkCopyMicromapToMemoryInfoEXT to id VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyMicromapToMemoryInfoEXT Type; +}; + +// Map type VkCopyMemoryToMicromapInfoEXT to id VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyMemoryToMicromapInfoEXT Type; +}; + +// Map type VkCopyMicromapInfoEXT to id VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkCopyMicromapInfoEXT Type; +}; + +// Map type VkMicromapBuildSizesInfoEXT to id VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkMicromapBuildSizesInfoEXT Type; +}; + +// Map type VkAccelerationStructureTrianglesOpacityMicromapEXT to id VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkAccelerationStructureTrianglesOpacityMicromapEXT Type; +}; + // Map type VkPhysicalDeviceBorderColorSwizzleFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; @@ -6125,6 +6287,24 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExtendedDynamicState3FeaturesEXT Type; +}; + +// Map type VkPhysicalDeviceExtendedDynamicState3PropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceExtendedDynamicState3PropertiesEXT Type; +}; + // Map type VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; @@ -6197,6 +6377,69 @@ template <> struct LvlSTypeMap { typedef VkShaderModuleIdentifierEXT Type; }; +// Map type VkPhysicalDeviceOpticalFlowFeaturesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceOpticalFlowFeaturesNV Type; +}; + +// Map type VkPhysicalDeviceOpticalFlowPropertiesNV to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDeviceOpticalFlowPropertiesNV Type; +}; + +// Map type VkOpticalFlowImageFormatInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowImageFormatInfoNV Type; +}; + +// Map type VkOpticalFlowImageFormatPropertiesNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowImageFormatPropertiesNV Type; +}; + +// Map type VkOpticalFlowSessionCreateInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowSessionCreateInfoNV Type; +}; + +// Map type VkOpticalFlowSessionCreatePrivateDataInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowSessionCreatePrivateDataInfoNV Type; +}; + +// Map type VkOpticalFlowExecuteInfoNV to id VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV +template <> struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV; +}; + +template <> struct LvlSTypeMap { + typedef VkOpticalFlowExecuteInfoNV Type; +}; + // Map type VkPhysicalDeviceLegacyDitheringFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; @@ -6206,6 +6449,15 @@ template <> struct LvlSTypeMap struct LvlTypeMap { + static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT; +}; + +template <> struct LvlSTypeMap { + typedef VkPhysicalDevicePipelineProtectedAccessFeaturesEXT Type; +}; + // Map type VkPhysicalDeviceTilePropertiesFeaturesQCOM to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM template <> struct LvlTypeMap { static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; diff --git a/scripts/generate_vulkan_wrapper.py b/scripts/generate_vulkan_wrapper.py index ad3f924..0217575 100755 --- a/scripts/generate_vulkan_wrapper.py +++ b/scripts/generate_vulkan_wrapper.py @@ -1170,6 +1170,9 @@ VK_EXT_custom_border_color = Extension(name='VK_EXT_custom_border_color', versio VK_GOOGLE_user_type = Extension(name='VK_GOOGLE_user_type', version=1, guard=None, commands=[ ]) +VK_NV_present_barrier = Extension(name='VK_NV_present_barrier', version=1, guard=None, commands=[ +]) + VK_EXT_private_data = Extension(name='VK_EXT_private_data', version=1, guard=None, commands=[ Command(name='vkCreatePrivateDataSlotEXT', dispatch='VkDevice'), Command(name='vkDestroyPrivateDataSlotEXT', dispatch='VkDevice'), @@ -1221,6 +1224,10 @@ VK_EXT_attachment_feedback_loop_layout = Extension(name='VK_EXT_attachment_feedb VK_EXT_4444_formats = Extension(name='VK_EXT_4444_formats', version=1, guard=None, commands=[ ]) +VK_EXT_device_fault = Extension(name='VK_EXT_device_fault', version=1, guard=None, commands=[ + Command(name='vkGetDeviceFaultInfoEXT', dispatch='VkDevice'), +]) + VK_ARM_rasterization_order_attachment_access = Extension(name='VK_ARM_rasterization_order_attachment_access', version=1, guard=None, commands=[ ]) @@ -1242,6 +1249,9 @@ VK_EXT_vertex_input_dynamic_state = Extension(name='VK_EXT_vertex_input_dynamic_ VK_EXT_physical_device_drm = Extension(name='VK_EXT_physical_device_drm', version=1, guard=None, commands=[ ]) +VK_EXT_device_address_binding_report = Extension(name='VK_EXT_device_address_binding_report', version=1, guard=None, commands=[ +]) + VK_EXT_depth_clip_control = Extension(name='VK_EXT_depth_clip_control', version=1, guard=None, commands=[ ]) @@ -1297,6 +1307,23 @@ VK_EXT_multi_draw = Extension(name='VK_EXT_multi_draw', version=1, guard=None, c VK_EXT_image_2d_view_of_3d = Extension(name='VK_EXT_image_2d_view_of_3d', version=1, guard=None, commands=[ ]) +VK_EXT_opacity_micromap = Extension(name='VK_EXT_opacity_micromap', version=2, guard=None, commands=[ + Command(name='vkCreateMicromapEXT', dispatch='VkDevice'), + Command(name='vkDestroyMicromapEXT', dispatch='VkDevice'), + Command(name='vkCmdBuildMicromapsEXT', dispatch='VkCommandBuffer'), + Command(name='vkBuildMicromapsEXT', dispatch='VkDevice'), + Command(name='vkCopyMicromapEXT', dispatch='VkDevice'), + Command(name='vkCopyMicromapToMemoryEXT', dispatch='VkDevice'), + Command(name='vkCopyMemoryToMicromapEXT', dispatch='VkDevice'), + Command(name='vkWriteMicromapsPropertiesEXT', dispatch='VkDevice'), + Command(name='vkCmdCopyMicromapEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdCopyMicromapToMemoryEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdCopyMemoryToMicromapEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdWriteMicromapsPropertiesEXT', dispatch='VkCommandBuffer'), + Command(name='vkGetDeviceMicromapCompatibilityEXT', dispatch='VkDevice'), + Command(name='vkGetMicromapBuildSizesEXT', dispatch='VkDevice'), +]) + VK_EXT_load_store_op_none = Extension(name='VK_EXT_load_store_op_none', version=1, guard=None, commands=[ ]) @@ -1333,6 +1360,40 @@ VK_EXT_image_compression_control_swapchain = Extension(name='VK_EXT_image_compre VK_QCOM_image_processing = Extension(name='VK_QCOM_image_processing', version=1, guard=None, commands=[ ]) +VK_EXT_extended_dynamic_state3 = Extension(name='VK_EXT_extended_dynamic_state3', version=2, guard=None, commands=[ + Command(name='vkCmdSetTessellationDomainOriginEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetDepthClampEnableEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetPolygonModeEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetRasterizationSamplesEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetSampleMaskEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetAlphaToCoverageEnableEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetAlphaToOneEnableEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetLogicOpEnableEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetColorBlendEnableEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetColorBlendEquationEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetColorWriteMaskEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetRasterizationStreamEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetConservativeRasterizationModeEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetExtraPrimitiveOverestimationSizeEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetDepthClipEnableEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetSampleLocationsEnableEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetColorBlendAdvancedEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetProvokingVertexModeEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetLineRasterizationModeEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetLineStippleEnableEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetDepthClipNegativeOneToOneEXT', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetViewportWScalingEnableNV', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetViewportSwizzleNV', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetCoverageToColorEnableNV', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetCoverageToColorLocationNV', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetCoverageModulationModeNV', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetCoverageModulationTableEnableNV', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetCoverageModulationTableNV', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetShadingRateImageEnableNV', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetRepresentativeFragmentTestEnableNV', dispatch='VkCommandBuffer'), + Command(name='vkCmdSetCoverageReductionModeNV', dispatch='VkCommandBuffer'), +]) + VK_EXT_subpass_merge_feedback = Extension(name='VK_EXT_subpass_merge_feedback', version=2, guard=None, commands=[ ]) @@ -1344,9 +1405,20 @@ VK_EXT_shader_module_identifier = Extension(name='VK_EXT_shader_module_identifie VK_EXT_rasterization_order_attachment_access = Extension(name='VK_EXT_rasterization_order_attachment_access', version=1, guard=None, commands=[ ]) +VK_NV_optical_flow = Extension(name='VK_NV_optical_flow', version=1, guard=None, commands=[ + Command(name='vkGetPhysicalDeviceOpticalFlowImageFormatsNV', dispatch='VkPhysicalDevice'), + Command(name='vkCreateOpticalFlowSessionNV', dispatch='VkDevice'), + Command(name='vkDestroyOpticalFlowSessionNV', dispatch='VkDevice'), + Command(name='vkBindOpticalFlowSessionImageNV', dispatch='VkDevice'), + Command(name='vkCmdOpticalFlowExecuteNV', dispatch='VkCommandBuffer'), +]) + VK_EXT_legacy_dithering = Extension(name='VK_EXT_legacy_dithering', version=1, guard=None, commands=[ ]) +VK_EXT_pipeline_protected_access = Extension(name='VK_EXT_pipeline_protected_access', version=1, guard=None, commands=[ +]) + VK_QCOM_tile_properties = Extension(name='VK_QCOM_tile_properties', version=1, guard=None, commands=[ Command(name='vkGetFramebufferTilePropertiesQCOM', dispatch='VkDevice'), Command(name='vkGetDynamicRenderingTilePropertiesQCOM', dispatch='VkDevice'), @@ -1520,7 +1592,7 @@ VK_QNX_screen_surface = Extension(name='VK_QNX_screen_surface', version=1, guard Command(name='vkGetPhysicalDeviceScreenPresentationSupportQNX', dispatch='VkPhysicalDevice'), ]) -VK_KHR_video_queue = Extension(name='VK_KHR_video_queue', version=6, guard='VK_ENABLE_BETA_EXTENSIONS', commands=[ +VK_KHR_video_queue = Extension(name='VK_KHR_video_queue', version=7, guard='VK_ENABLE_BETA_EXTENSIONS', commands=[ Command(name='vkGetPhysicalDeviceVideoCapabilitiesKHR', dispatch='VkPhysicalDevice'), Command(name='vkGetPhysicalDeviceVideoFormatPropertiesKHR', dispatch='VkPhysicalDevice'), Command(name='vkCreateVideoSessionKHR', dispatch='VkDevice'), @@ -1769,6 +1841,7 @@ extensions = [ VK_EXT_robustness2, VK_EXT_custom_border_color, VK_GOOGLE_user_type, + VK_NV_present_barrier, VK_EXT_private_data, VK_EXT_pipeline_creation_cache_control, VK_NV_device_diagnostics_config, @@ -1784,12 +1857,14 @@ extensions = [ VK_EXT_image_compression_control, VK_EXT_attachment_feedback_loop_layout, VK_EXT_4444_formats, + VK_EXT_device_fault, VK_ARM_rasterization_order_attachment_access, VK_EXT_rgba10x6_formats, VK_NV_acquire_winrt_display, VK_VALVE_mutable_descriptor_type, VK_EXT_vertex_input_dynamic_state, VK_EXT_physical_device_drm, + VK_EXT_device_address_binding_report, VK_EXT_depth_clip_control, VK_EXT_primitive_topology_list_restart, VK_HUAWEI_subpass_shading, @@ -1804,6 +1879,7 @@ extensions = [ VK_EXT_image_view_min_lod, VK_EXT_multi_draw, VK_EXT_image_2d_view_of_3d, + VK_EXT_opacity_micromap, VK_EXT_load_store_op_none, VK_EXT_border_color_swizzle, VK_EXT_pageable_device_local_memory, @@ -1815,10 +1891,13 @@ extensions = [ VK_GOOGLE_surfaceless_query, VK_EXT_image_compression_control_swapchain, VK_QCOM_image_processing, + VK_EXT_extended_dynamic_state3, VK_EXT_subpass_merge_feedback, VK_EXT_shader_module_identifier, VK_EXT_rasterization_order_attachment_access, + VK_NV_optical_flow, VK_EXT_legacy_dithering, + VK_EXT_pipeline_protected_access, VK_QCOM_tile_properties, VK_SEC_amigo_profiling, VK_EXT_mutable_descriptor_type, diff --git a/scripts/known_good.json b/scripts/known_good.json index a25a203..9eb3026 100644 --- a/scripts/known_good.json +++ b/scripts/known_good.json @@ -6,7 +6,7 @@ "sub_dir" : "Vulkan-Headers", "build_dir" : "Vulkan-Headers/build", "install_dir" : "Vulkan-Headers/build/install", - "commit" : "v1.3.229" + "commit" : "v1.3.230" }, { "name" : "MoltenVK", @@ -30,7 +30,7 @@ "sub_dir" : "Vulkan-Loader", "build_dir" : "Vulkan-Loader/build", "install_dir" : "Vulkan-Loader/build/install", - "commit" : "v1.3.229", + "commit" : "v1.3.230", "deps" : [ { "var_name" : "VULKAN_HEADERS_INSTALL_DIR", diff --git a/vulkaninfo/generated/vulkaninfo.hpp b/vulkaninfo/generated/vulkaninfo.hpp index 151b27a..475f762 100644 --- a/vulkaninfo/generated/vulkaninfo.hpp +++ b/vulkaninfo/generated/vulkaninfo.hpp @@ -354,6 +354,7 @@ std::string VkFormatString(VkFormat value) { case (VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG): return "FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG"; case (VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG): return "FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG"; case (VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG): return "FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG"; + case (VK_FORMAT_R16G16_S10_5_NV): return "FORMAT_R16G16_S10_5_NV"; default: return std::string("UNKNOWN_VkFormat_value") + std::to_string(value); } } @@ -700,6 +701,9 @@ std::vector VkFormatFeatureFlagBits2GetStrings(VkFormatFeatureFlag if (VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM"); if (VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM"); if (VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM & value) strings.push_back("FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM"); + if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV"); + if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV"); + if (VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV & value) strings.push_back("FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV"); return strings; } void DumpVkFormatFeatureFlags2(Printer &p, std::string name, VkFormatFeatureFlags2 value) { @@ -846,6 +850,7 @@ std::vector VkQueueFlagBitsGetStrings(VkQueueFlagBits value) { if (VK_QUEUE_PROTECTED_BIT & value) strings.push_back("QUEUE_PROTECTED_BIT"); if (VK_QUEUE_VIDEO_DECODE_BIT_KHR & value) strings.push_back("QUEUE_VIDEO_DECODE_BIT_KHR"); if (VK_QUEUE_VIDEO_ENCODE_BIT_KHR & value) strings.push_back("QUEUE_VIDEO_ENCODE_BIT_KHR"); + if (VK_QUEUE_OPTICAL_FLOW_BIT_NV & value) strings.push_back("QUEUE_OPTICAL_FLOW_BIT_NV"); return strings; } void DumpVkQueueFlags(Printer &p, std::string name, VkQueueFlags value) { @@ -901,6 +906,10 @@ std::string VkQueueFlagsString(VkQueueFlags value) { if (is_first) { is_first = false; } else { out += " | "; } out += "QUEUE_VIDEO_ENCODE_BIT_KHR"; } + if (VK_QUEUE_OPTICAL_FLOW_BIT_NV & value) { + if (is_first) { is_first = false; } else { out += " | "; } + out += "QUEUE_OPTICAL_FLOW_BIT_N"; + } return out; } std::vector VkResolveModeFlagBitsGetStrings(VkResolveModeFlagBits value) { @@ -1268,6 +1277,11 @@ void DumpVkPhysicalDeviceAccelerationStructurePropertiesKHR(Printer &p, std::str p.PrintKeyValue("maxDescriptorSetUpdateAfterBindAccelerationStructures", obj.maxDescriptorSetUpdateAfterBindAccelerationStructures); p.PrintKeyValue("minAccelerationStructureScratchOffsetAlignment", obj.minAccelerationStructureScratchOffsetAlignment); } +void DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceAddressBindingReportFeaturesEXT &obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(20); + p.PrintKeyBool("reportAddressBinding", static_cast(obj.reportAddressBinding)); +} void DumpVkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT &obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(28); @@ -1457,6 +1471,46 @@ void DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(Printer &p, std::strin p.PrintKeyBool("extendedDynamicState2LogicOp", static_cast(obj.extendedDynamicState2LogicOp)); p.PrintKeyBool("extendedDynamicState2PatchControlPoints", static_cast(obj.extendedDynamicState2PatchControlPoints)); } +void DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT &obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(53); + p.PrintKeyBool("extendedDynamicState3TessellationDomainOrigin", static_cast(obj.extendedDynamicState3TessellationDomainOrigin)); + p.PrintKeyBool("extendedDynamicState3DepthClampEnable", static_cast(obj.extendedDynamicState3DepthClampEnable)); + p.PrintKeyBool("extendedDynamicState3PolygonMode", static_cast(obj.extendedDynamicState3PolygonMode)); + p.PrintKeyBool("extendedDynamicState3RasterizationSamples", static_cast(obj.extendedDynamicState3RasterizationSamples)); + p.PrintKeyBool("extendedDynamicState3SampleMask", static_cast(obj.extendedDynamicState3SampleMask)); + p.PrintKeyBool("extendedDynamicState3AlphaToCoverageEnable", static_cast(obj.extendedDynamicState3AlphaToCoverageEnable)); + p.PrintKeyBool("extendedDynamicState3AlphaToOneEnable", static_cast(obj.extendedDynamicState3AlphaToOneEnable)); + p.PrintKeyBool("extendedDynamicState3LogicOpEnable", static_cast(obj.extendedDynamicState3LogicOpEnable)); + p.PrintKeyBool("extendedDynamicState3ColorBlendEnable", static_cast(obj.extendedDynamicState3ColorBlendEnable)); + p.PrintKeyBool("extendedDynamicState3ColorBlendEquation", static_cast(obj.extendedDynamicState3ColorBlendEquation)); + p.PrintKeyBool("extendedDynamicState3ColorWriteMask", static_cast(obj.extendedDynamicState3ColorWriteMask)); + p.PrintKeyBool("extendedDynamicState3RasterizationStream", static_cast(obj.extendedDynamicState3RasterizationStream)); + p.PrintKeyBool("extendedDynamicState3ConservativeRasterizationMode", static_cast(obj.extendedDynamicState3ConservativeRasterizationMode)); + p.PrintKeyBool("extendedDynamicState3ExtraPrimitiveOverestimationSize", static_cast(obj.extendedDynamicState3ExtraPrimitiveOverestimationSize)); + p.PrintKeyBool("extendedDynamicState3DepthClipEnable", static_cast(obj.extendedDynamicState3DepthClipEnable)); + p.PrintKeyBool("extendedDynamicState3SampleLocationsEnable", static_cast(obj.extendedDynamicState3SampleLocationsEnable)); + p.PrintKeyBool("extendedDynamicState3ColorBlendAdvanced", static_cast(obj.extendedDynamicState3ColorBlendAdvanced)); + p.PrintKeyBool("extendedDynamicState3ProvokingVertexMode", static_cast(obj.extendedDynamicState3ProvokingVertexMode)); + p.PrintKeyBool("extendedDynamicState3LineRasterizationMode", static_cast(obj.extendedDynamicState3LineRasterizationMode)); + p.PrintKeyBool("extendedDynamicState3LineStippleEnable", static_cast(obj.extendedDynamicState3LineStippleEnable)); + p.PrintKeyBool("extendedDynamicState3DepthClipNegativeOneToOne", static_cast(obj.extendedDynamicState3DepthClipNegativeOneToOne)); + p.PrintKeyBool("extendedDynamicState3ViewportWScalingEnable", static_cast(obj.extendedDynamicState3ViewportWScalingEnable)); + p.PrintKeyBool("extendedDynamicState3ViewportSwizzle", static_cast(obj.extendedDynamicState3ViewportSwizzle)); + p.PrintKeyBool("extendedDynamicState3CoverageToColorEnable", static_cast(obj.extendedDynamicState3CoverageToColorEnable)); + p.PrintKeyBool("extendedDynamicState3CoverageToColorLocation", static_cast(obj.extendedDynamicState3CoverageToColorLocation)); + p.PrintKeyBool("extendedDynamicState3CoverageModulationMode", static_cast(obj.extendedDynamicState3CoverageModulationMode)); + p.PrintKeyBool("extendedDynamicState3CoverageModulationTableEnable", static_cast(obj.extendedDynamicState3CoverageModulationTableEnable)); + p.PrintKeyBool("extendedDynamicState3CoverageModulationTable", static_cast(obj.extendedDynamicState3CoverageModulationTable)); + p.PrintKeyBool("extendedDynamicState3CoverageReductionMode", static_cast(obj.extendedDynamicState3CoverageReductionMode)); + p.PrintKeyBool("extendedDynamicState3RepresentativeFragmentTestEnable", static_cast(obj.extendedDynamicState3RepresentativeFragmentTestEnable)); + p.PrintKeyBool("extendedDynamicState3ShadingRateImageEnable", static_cast(obj.extendedDynamicState3ShadingRateImageEnable)); +} +void DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT &obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(36); + p.PrintKeyBool("dynamicPrimitiveTopologyUnrestricted", static_cast(obj.dynamicPrimitiveTopologyUnrestricted)); +} void DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(20); @@ -1467,6 +1521,12 @@ void DumpVkPhysicalDeviceExternalMemoryHostPropertiesEXT(Printer &p, std::string p.SetMinKeyWidth(31); p.PrintKeyValue("minImportedHostPointerAlignment", to_hex_str(p, obj.minImportedHostPointerAlignment)); } +void DumpVkPhysicalDeviceFaultFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceFaultFeaturesEXT &obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(23); + p.PrintKeyBool("deviceFault", static_cast(obj.deviceFault)); + p.PrintKeyBool("deviceFaultVendorBinary", static_cast(obj.deviceFaultVendorBinary)); +} void DumpVkPhysicalDeviceFeatures(Printer &p, std::string name, const VkPhysicalDeviceFeatures &obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(39); @@ -2024,6 +2084,19 @@ void DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(Printer &p, std::string n p.SetMinKeyWidth(18); p.PrintKeyBool("nonSeamlessCubeMap", static_cast(obj.nonSeamlessCubeMap)); } +void DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(Printer &p, std::string name, const VkPhysicalDeviceOpacityMicromapFeaturesEXT &obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(21); + p.PrintKeyBool("micromap", static_cast(obj.micromap)); + p.PrintKeyBool("micromapCaptureReplay", static_cast(obj.micromapCaptureReplay)); + p.PrintKeyBool("micromapHostCommands", static_cast(obj.micromapHostCommands)); +} +void DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(Printer &p, std::string name, const VkPhysicalDeviceOpacityMicromapPropertiesEXT &obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(32); + p.PrintKeyValue("maxOpacity2StateSubdivisionLevel", obj.maxOpacity2StateSubdivisionLevel); + p.PrintKeyValue("maxOpacity4StateSubdivisionLevel", obj.maxOpacity4StateSubdivisionLevel); +} void DumpVkPhysicalDevicePCIBusInfoPropertiesEXT(Printer &p, std::string name, const VkPhysicalDevicePCIBusInfoPropertiesEXT &obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(11); @@ -2063,6 +2136,11 @@ void DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(Printer &p, std::string n p.SetMinKeyWidth(28); p.PrintKeyBool("pipelinePropertiesIdentifier", static_cast(obj.pipelinePropertiesIdentifier)); } +void DumpVkPhysicalDevicePipelineProtectedAccessFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT &obj) { + ObjectWrapper object{p, name}; + p.SetMinKeyWidth(23); + p.PrintKeyBool("pipelineProtectedAccess", static_cast(obj.pipelineProtectedAccess)); +} void DumpVkPhysicalDevicePipelineRobustnessFeaturesEXT(Printer &p, std::string name, const VkPhysicalDevicePipelineRobustnessFeaturesEXT &obj) { ObjectWrapper object{p, name}; p.SetMinKeyWidth(18); @@ -2850,6 +2928,7 @@ struct phys_device_props2_chain { VkPhysicalDeviceDiscardRectanglePropertiesEXT PhysicalDeviceDiscardRectanglePropertiesEXT{}; VkPhysicalDeviceDriverProperties PhysicalDeviceDriverProperties{}; VkPhysicalDeviceDrmPropertiesEXT PhysicalDeviceDrmPropertiesEXT{}; + VkPhysicalDeviceExtendedDynamicState3PropertiesEXT PhysicalDeviceExtendedDynamicState3PropertiesEXT{}; VkPhysicalDeviceExternalMemoryHostPropertiesEXT PhysicalDeviceExternalMemoryHostPropertiesEXT{}; VkPhysicalDeviceFloatControlsProperties PhysicalDeviceFloatControlsProperties{}; VkPhysicalDeviceFragmentDensityMap2PropertiesEXT PhysicalDeviceFragmentDensityMap2PropertiesEXT{}; @@ -2865,6 +2944,7 @@ struct phys_device_props2_chain { VkPhysicalDeviceMeshShaderPropertiesEXT PhysicalDeviceMeshShaderPropertiesEXT{}; VkPhysicalDeviceMultiDrawPropertiesEXT PhysicalDeviceMultiDrawPropertiesEXT{}; VkPhysicalDeviceMultiviewProperties PhysicalDeviceMultiviewProperties{}; + VkPhysicalDeviceOpacityMicromapPropertiesEXT PhysicalDeviceOpacityMicromapPropertiesEXT{}; VkPhysicalDevicePCIBusInfoPropertiesEXT PhysicalDevicePCIBusInfoPropertiesEXT{}; VkPhysicalDevicePerformanceQueryPropertiesKHR PhysicalDevicePerformanceQueryPropertiesKHR{}; VkPhysicalDevicePipelineRobustnessPropertiesEXT PhysicalDevicePipelineRobustnessPropertiesEXT{}; @@ -2900,6 +2980,7 @@ struct phys_device_props2_chain { PhysicalDeviceDiscardRectanglePropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; PhysicalDeviceDriverProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; PhysicalDeviceDrmPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT; + PhysicalDeviceExtendedDynamicState3PropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; PhysicalDeviceExternalMemoryHostPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; PhysicalDeviceFloatControlsProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; PhysicalDeviceFragmentDensityMap2PropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; @@ -2915,6 +2996,7 @@ struct phys_device_props2_chain { PhysicalDeviceMeshShaderPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; PhysicalDeviceMultiDrawPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; PhysicalDeviceMultiviewProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; + PhysicalDeviceOpacityMicromapPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; PhysicalDevicePCIBusInfoPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; PhysicalDevicePerformanceQueryPropertiesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; PhysicalDevicePipelineRobustnessPropertiesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT; @@ -2950,6 +3032,7 @@ struct phys_device_props2_chain { chain_members.push_back(reinterpret_cast(&PhysicalDeviceDiscardRectanglePropertiesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceDriverProperties)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceDrmPropertiesEXT)); + chain_members.push_back(reinterpret_cast(&PhysicalDeviceExtendedDynamicState3PropertiesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceExternalMemoryHostPropertiesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceFloatControlsProperties)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceFragmentDensityMap2PropertiesEXT)); @@ -2965,6 +3048,7 @@ struct phys_device_props2_chain { chain_members.push_back(reinterpret_cast(&PhysicalDeviceMeshShaderPropertiesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceMultiDrawPropertiesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceMultiviewProperties)); + chain_members.push_back(reinterpret_cast(&PhysicalDeviceOpacityMicromapPropertiesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDevicePCIBusInfoPropertiesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDevicePerformanceQueryPropertiesKHR)); chain_members.push_back(reinterpret_cast(&PhysicalDevicePipelineRobustnessPropertiesEXT)); @@ -3038,6 +3122,7 @@ struct phys_device_features2_chain { VkPhysicalDevice8BitStorageFeatures PhysicalDevice8BitStorageFeatures{}; VkPhysicalDeviceASTCDecodeFeaturesEXT PhysicalDeviceASTCDecodeFeaturesEXT{}; VkPhysicalDeviceAccelerationStructureFeaturesKHR PhysicalDeviceAccelerationStructureFeaturesKHR{}; + VkPhysicalDeviceAddressBindingReportFeaturesEXT PhysicalDeviceAddressBindingReportFeaturesEXT{}; VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT{}; VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT PhysicalDeviceBlendOperationAdvancedFeaturesEXT{}; VkPhysicalDeviceBorderColorSwizzleFeaturesEXT PhysicalDeviceBorderColorSwizzleFeaturesEXT{}; @@ -3053,7 +3138,9 @@ struct phys_device_features2_chain { VkPhysicalDeviceDeviceMemoryReportFeaturesEXT PhysicalDeviceDeviceMemoryReportFeaturesEXT{}; VkPhysicalDeviceDynamicRenderingFeatures PhysicalDeviceDynamicRenderingFeatures{}; VkPhysicalDeviceExtendedDynamicState2FeaturesEXT PhysicalDeviceExtendedDynamicState2FeaturesEXT{}; + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT PhysicalDeviceExtendedDynamicState3FeaturesEXT{}; VkPhysicalDeviceExtendedDynamicStateFeaturesEXT PhysicalDeviceExtendedDynamicStateFeaturesEXT{}; + VkPhysicalDeviceFaultFeaturesEXT PhysicalDeviceFaultFeaturesEXT{}; VkPhysicalDeviceFragmentDensityMap2FeaturesEXT PhysicalDeviceFragmentDensityMap2FeaturesEXT{}; VkPhysicalDeviceFragmentDensityMapFeaturesEXT PhysicalDeviceFragmentDensityMapFeaturesEXT{}; VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR PhysicalDeviceFragmentShaderBarycentricFeaturesKHR{}; @@ -3080,11 +3167,13 @@ struct phys_device_features2_chain { VkPhysicalDeviceMultiviewFeatures PhysicalDeviceMultiviewFeatures{}; VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT PhysicalDeviceMutableDescriptorTypeFeaturesEXT{}; VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT PhysicalDeviceNonSeamlessCubeMapFeaturesEXT{}; + VkPhysicalDeviceOpacityMicromapFeaturesEXT PhysicalDeviceOpacityMicromapFeaturesEXT{}; VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT{}; VkPhysicalDevicePerformanceQueryFeaturesKHR PhysicalDevicePerformanceQueryFeaturesKHR{}; VkPhysicalDevicePipelineCreationCacheControlFeatures PhysicalDevicePipelineCreationCacheControlFeatures{}; VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR{}; VkPhysicalDevicePipelinePropertiesFeaturesEXT PhysicalDevicePipelinePropertiesFeaturesEXT{}; + VkPhysicalDevicePipelineProtectedAccessFeaturesEXT PhysicalDevicePipelineProtectedAccessFeaturesEXT{}; VkPhysicalDevicePipelineRobustnessFeaturesEXT PhysicalDevicePipelineRobustnessFeaturesEXT{}; #ifdef VK_ENABLE_BETA_EXTENSIONS VkPhysicalDevicePortabilitySubsetFeaturesKHR PhysicalDevicePortabilitySubsetFeaturesKHR{}; @@ -3144,6 +3233,7 @@ struct phys_device_features2_chain { PhysicalDevice8BitStorageFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; PhysicalDeviceASTCDecodeFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; PhysicalDeviceAccelerationStructureFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; + PhysicalDeviceAddressBindingReportFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; PhysicalDeviceBlendOperationAdvancedFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; PhysicalDeviceBorderColorSwizzleFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; @@ -3159,7 +3249,9 @@ struct phys_device_features2_chain { PhysicalDeviceDeviceMemoryReportFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT; PhysicalDeviceDynamicRenderingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; PhysicalDeviceExtendedDynamicState2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; + PhysicalDeviceExtendedDynamicState3FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; PhysicalDeviceExtendedDynamicStateFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; + PhysicalDeviceFaultFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; PhysicalDeviceFragmentDensityMap2FeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; PhysicalDeviceFragmentDensityMapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; PhysicalDeviceFragmentShaderBarycentricFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; @@ -3186,11 +3278,13 @@ struct phys_device_features2_chain { PhysicalDeviceMultiviewFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; PhysicalDeviceMutableDescriptorTypeFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; PhysicalDeviceNonSeamlessCubeMapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; + PhysicalDeviceOpacityMicromapFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; PhysicalDevicePerformanceQueryFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; PhysicalDevicePipelineCreationCacheControlFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; PhysicalDevicePipelineExecutablePropertiesFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; PhysicalDevicePipelinePropertiesFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; + PhysicalDevicePipelineProtectedAccessFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT; PhysicalDevicePipelineRobustnessFeaturesEXT.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT; #ifdef VK_ENABLE_BETA_EXTENSIONS PhysicalDevicePortabilitySubsetFeaturesKHR.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR; @@ -3249,6 +3343,7 @@ struct phys_device_features2_chain { chain_members.push_back(reinterpret_cast(&PhysicalDevice8BitStorageFeatures)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceASTCDecodeFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceAccelerationStructureFeaturesKHR)); + chain_members.push_back(reinterpret_cast(&PhysicalDeviceAddressBindingReportFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceBlendOperationAdvancedFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceBorderColorSwizzleFeaturesEXT)); @@ -3264,7 +3359,9 @@ struct phys_device_features2_chain { chain_members.push_back(reinterpret_cast(&PhysicalDeviceDeviceMemoryReportFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceDynamicRenderingFeatures)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceExtendedDynamicState2FeaturesEXT)); + chain_members.push_back(reinterpret_cast(&PhysicalDeviceExtendedDynamicState3FeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceExtendedDynamicStateFeaturesEXT)); + chain_members.push_back(reinterpret_cast(&PhysicalDeviceFaultFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceFragmentDensityMap2FeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceFragmentDensityMapFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceFragmentShaderBarycentricFeaturesKHR)); @@ -3291,11 +3388,13 @@ struct phys_device_features2_chain { chain_members.push_back(reinterpret_cast(&PhysicalDeviceMultiviewFeatures)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceMutableDescriptorTypeFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDeviceNonSeamlessCubeMapFeaturesEXT)); + chain_members.push_back(reinterpret_cast(&PhysicalDeviceOpacityMicromapFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDevicePerformanceQueryFeaturesKHR)); chain_members.push_back(reinterpret_cast(&PhysicalDevicePipelineCreationCacheControlFeatures)); chain_members.push_back(reinterpret_cast(&PhysicalDevicePipelineExecutablePropertiesFeaturesKHR)); chain_members.push_back(reinterpret_cast(&PhysicalDevicePipelinePropertiesFeaturesEXT)); + chain_members.push_back(reinterpret_cast(&PhysicalDevicePipelineProtectedAccessFeaturesEXT)); chain_members.push_back(reinterpret_cast(&PhysicalDevicePipelineRobustnessFeaturesEXT)); #ifdef VK_ENABLE_BETA_EXTENSIONS chain_members.push_back(reinterpret_cast(&PhysicalDevicePortabilitySubsetFeaturesKHR)); @@ -3526,6 +3625,12 @@ void chain_iterator_phys_device_props2(Printer &p, AppInstance &inst, AppGpu &gp DumpVkPhysicalDeviceDrmPropertiesEXT(p, "VkPhysicalDeviceDrmPropertiesEXT", *props); p.AddNewline(); } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT && + (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME))) { + VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* props = (VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*)structure; + DumpVkPhysicalDeviceExtendedDynamicState3PropertiesEXT(p, "VkPhysicalDeviceExtendedDynamicState3PropertiesEXT", *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT && (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME))) { VkPhysicalDeviceExternalMemoryHostPropertiesEXT* props = (VkPhysicalDeviceExternalMemoryHostPropertiesEXT*)structure; @@ -3622,6 +3727,12 @@ void chain_iterator_phys_device_props2(Printer &p, AppInstance &inst, AppGpu &gp DumpVkPhysicalDeviceMultiviewProperties(p, gpu.api_version.minor >= 1 ?"VkPhysicalDeviceMultiviewProperties":"VkPhysicalDeviceMultiviewPropertiesKHR", *props); p.AddNewline(); } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT && + (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME))) { + VkPhysicalDeviceOpacityMicromapPropertiesEXT* props = (VkPhysicalDeviceOpacityMicromapPropertiesEXT*)structure; + DumpVkPhysicalDeviceOpacityMicromapPropertiesEXT(p, "VkPhysicalDeviceOpacityMicromapPropertiesEXT", *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT && (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PCI_BUS_INFO_EXTENSION_NAME))) { VkPhysicalDevicePCIBusInfoPropertiesEXT* props = (VkPhysicalDevicePCIBusInfoPropertiesEXT*)structure; @@ -3807,6 +3918,12 @@ void chain_iterator_phys_device_features2(Printer &p, AppGpu &gpu, void * place) DumpVkPhysicalDeviceAccelerationStructureFeaturesKHR(p, "VkPhysicalDeviceAccelerationStructureFeaturesKHR", *props); p.AddNewline(); } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT && + (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME))) { + VkPhysicalDeviceAddressBindingReportFeaturesEXT* props = (VkPhysicalDeviceAddressBindingReportFeaturesEXT*)structure; + DumpVkPhysicalDeviceAddressBindingReportFeaturesEXT(p, "VkPhysicalDeviceAddressBindingReportFeaturesEXT", *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT && (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME))) { VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* props = (VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*)structure; @@ -3900,12 +4017,24 @@ void chain_iterator_phys_device_features2(Printer &p, AppGpu &gpu, void * place) DumpVkPhysicalDeviceExtendedDynamicState2FeaturesEXT(p, "VkPhysicalDeviceExtendedDynamicState2FeaturesEXT", *props); p.AddNewline(); } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT && + (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME))) { + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* props = (VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*)structure; + DumpVkPhysicalDeviceExtendedDynamicState3FeaturesEXT(p, "VkPhysicalDeviceExtendedDynamicState3FeaturesEXT", *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT && (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME))) { VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* props = (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT*)structure; DumpVkPhysicalDeviceExtendedDynamicStateFeaturesEXT(p, "VkPhysicalDeviceExtendedDynamicStateFeaturesEXT", *props); p.AddNewline(); } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT && + (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_DEVICE_FAULT_EXTENSION_NAME))) { + VkPhysicalDeviceFaultFeaturesEXT* props = (VkPhysicalDeviceFaultFeaturesEXT*)structure; + DumpVkPhysicalDeviceFaultFeaturesEXT(p, "VkPhysicalDeviceFaultFeaturesEXT", *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT && (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME))) { VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* props = (VkPhysicalDeviceFragmentDensityMap2FeaturesEXT*)structure; @@ -4068,6 +4197,12 @@ void chain_iterator_phys_device_features2(Printer &p, AppGpu &gpu, void * place) DumpVkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(p, "VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT", *props); p.AddNewline(); } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT && + (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME))) { + VkPhysicalDeviceOpacityMicromapFeaturesEXT* props = (VkPhysicalDeviceOpacityMicromapFeaturesEXT*)structure; + DumpVkPhysicalDeviceOpacityMicromapFeaturesEXT(p, "VkPhysicalDeviceOpacityMicromapFeaturesEXT", *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT && (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME))) { VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* props = (VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT*)structure; @@ -4099,6 +4234,12 @@ void chain_iterator_phys_device_features2(Printer &p, AppGpu &gpu, void * place) DumpVkPhysicalDevicePipelinePropertiesFeaturesEXT(p, "VkPhysicalDevicePipelinePropertiesFeaturesEXT", *props); p.AddNewline(); } + if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT && + (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME))) { + VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* props = (VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*)structure; + DumpVkPhysicalDevicePipelineProtectedAccessFeaturesEXT(p, "VkPhysicalDevicePipelineProtectedAccessFeaturesEXT", *props); + p.AddNewline(); + } if (structure->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT && (gpu.CheckPhysicalDeviceExtensionIncluded(VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME))) { VkPhysicalDevicePipelineRobustnessFeaturesEXT* props = (VkPhysicalDevicePipelineRobustnessFeaturesEXT*)structure; -- 2.7.4