From c71f94d8a86b22fd26a6a351fc682ae344d2b993 Mon Sep 17 00:00:00 2001 From: Mike Schuchardt Date: Thu, 29 Sep 2022 10:26:54 -0700 Subject: build: Update to header 1.3.230 - Update known-good - Generate source --- .../loader_generated_header_version.cmake | 2 +- loader/generated/vk_dispatch_table_helper.h | 151 +++ loader/generated/vk_layer_dispatch_table.h | 61 + loader/generated/vk_loader_extensions.c | 1421 +++++++++++++++++--- loader/generated/vk_loader_extensions.h | 3 + loader/generated/vk_object_types.h | 12 +- scripts/known_good.json | 2 +- 7 files changed, 1475 insertions(+), 177 deletions(-) diff --git a/loader/generated/loader_generated_header_version.cmake b/loader/generated/loader_generated_header_version.cmake index 5bfe42449..c2556650d 100644 --- a/loader/generated/loader_generated_header_version.cmake +++ b/loader/generated/loader_generated_header_version.cmake @@ -24,5 +24,5 @@ # ############################################################################ -set(LOADER_GENERATED_HEADER_VERSION "1.3.229") +set(LOADER_GENERATED_HEADER_VERSION "1.3.230") diff --git a/loader/generated/vk_dispatch_table_helper.h b/loader/generated/vk_dispatch_table_helper.h index 98cb0906d..6641530f4 100644 --- a/loader/generated/vk_dispatch_table_helper.h +++ b/loader/generated/vk_dispatch_table_helper.h @@ -281,6 +281,7 @@ static VKAPI_ATTR void VKAPI_CALL StubExportMetalObjectsEXT(VkDevice device, VkE #endif // VK_USE_PLATFORM_METAL_EXT static VKAPI_ATTR void VKAPI_CALL StubCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) { } static VKAPI_ATTR void VKAPI_CALL StubGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) { } +static VKAPI_ATTR VkResult VKAPI_CALL StubGetDeviceFaultInfoEXT(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) { return VK_SUCCESS; } static VKAPI_ATTR void VKAPI_CALL StubCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) { } #ifdef VK_USE_PLATFORM_FUCHSIA static VKAPI_ATTR VkResult VKAPI_CALL StubGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) { return VK_SUCCESS; } @@ -322,11 +323,60 @@ static VKAPI_ATTR void VKAPI_CALL StubCmdSetPrimitiveRestartEnableEXT(VkCommandB static VKAPI_ATTR void VKAPI_CALL StubCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) { } static VKAPI_ATTR void VKAPI_CALL StubCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) { } static VKAPI_ATTR void VKAPI_CALL StubCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) { } +static VKAPI_ATTR VkResult VKAPI_CALL StubCreateMicromapEXT(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) { return VK_SUCCESS; } +static VKAPI_ATTR void VKAPI_CALL StubDestroyMicromapEXT(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { } +static VKAPI_ATTR VkResult VKAPI_CALL StubBuildMicromapsEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) { return VK_SUCCESS; } +static VKAPI_ATTR VkResult VKAPI_CALL StubCopyMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) { return VK_SUCCESS; } +static VKAPI_ATTR VkResult VKAPI_CALL StubCopyMicromapToMemoryEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) { return VK_SUCCESS; } +static VKAPI_ATTR VkResult VKAPI_CALL StubCopyMemoryToMicromapEXT(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) { return VK_SUCCESS; } +static VKAPI_ATTR VkResult VKAPI_CALL StubWriteMicromapsPropertiesEXT(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) { return VK_SUCCESS; } +static VKAPI_ATTR void VKAPI_CALL StubCmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) { } +static VKAPI_ATTR void VKAPI_CALL StubGetDeviceMicromapCompatibilityEXT(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) { } +static VKAPI_ATTR void VKAPI_CALL StubGetMicromapBuildSizesEXT(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) { } static VKAPI_ATTR void VKAPI_CALL StubSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) { } static VKAPI_ATTR void VKAPI_CALL StubGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) { } static VKAPI_ATTR void VKAPI_CALL StubGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) { } +static VKAPI_ATTR void VKAPI_CALL StubCmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) { } static VKAPI_ATTR void VKAPI_CALL StubGetShaderModuleIdentifierEXT(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) { } static VKAPI_ATTR void VKAPI_CALL StubGetShaderModuleCreateInfoIdentifierEXT(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) { } +static VKAPI_ATTR VkResult VKAPI_CALL StubCreateOpticalFlowSessionNV(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) { return VK_SUCCESS; } +static VKAPI_ATTR void VKAPI_CALL StubDestroyOpticalFlowSessionNV(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) { } +static VKAPI_ATTR VkResult VKAPI_CALL StubBindOpticalFlowSessionImageNV(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) { return VK_SUCCESS; } +static VKAPI_ATTR void VKAPI_CALL StubCmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { } static VKAPI_ATTR VkResult VKAPI_CALL StubGetFramebufferTilePropertiesQCOM(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) { return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL StubGetDynamicRenderingTilePropertiesQCOM(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties) { return VK_SUCCESS; } static VKAPI_ATTR VkResult VKAPI_CALL StubCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) { return VK_SUCCESS; } @@ -1010,6 +1060,8 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp if (table->CmdSetFragmentShadingRateEnumNV == nullptr) { table->CmdSetFragmentShadingRateEnumNV = (PFN_vkCmdSetFragmentShadingRateEnumNV)StubCmdSetFragmentShadingRateEnumNV; } table->GetImageSubresourceLayout2EXT = (PFN_vkGetImageSubresourceLayout2EXT) gpa(device, "vkGetImageSubresourceLayout2EXT"); if (table->GetImageSubresourceLayout2EXT == nullptr) { table->GetImageSubresourceLayout2EXT = (PFN_vkGetImageSubresourceLayout2EXT)StubGetImageSubresourceLayout2EXT; } + table->GetDeviceFaultInfoEXT = (PFN_vkGetDeviceFaultInfoEXT) gpa(device, "vkGetDeviceFaultInfoEXT"); + if (table->GetDeviceFaultInfoEXT == nullptr) { table->GetDeviceFaultInfoEXT = (PFN_vkGetDeviceFaultInfoEXT)StubGetDeviceFaultInfoEXT; } table->CmdSetVertexInputEXT = (PFN_vkCmdSetVertexInputEXT) gpa(device, "vkCmdSetVertexInputEXT"); if (table->CmdSetVertexInputEXT == nullptr) { table->CmdSetVertexInputEXT = (PFN_vkCmdSetVertexInputEXT)StubCmdSetVertexInputEXT; } #ifdef VK_USE_PLATFORM_FUCHSIA @@ -1074,16 +1126,114 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp if (table->CmdDrawMultiEXT == nullptr) { table->CmdDrawMultiEXT = (PFN_vkCmdDrawMultiEXT)StubCmdDrawMultiEXT; } table->CmdDrawMultiIndexedEXT = (PFN_vkCmdDrawMultiIndexedEXT) gpa(device, "vkCmdDrawMultiIndexedEXT"); if (table->CmdDrawMultiIndexedEXT == nullptr) { table->CmdDrawMultiIndexedEXT = (PFN_vkCmdDrawMultiIndexedEXT)StubCmdDrawMultiIndexedEXT; } + table->CreateMicromapEXT = (PFN_vkCreateMicromapEXT) gpa(device, "vkCreateMicromapEXT"); + if (table->CreateMicromapEXT == nullptr) { table->CreateMicromapEXT = (PFN_vkCreateMicromapEXT)StubCreateMicromapEXT; } + table->DestroyMicromapEXT = (PFN_vkDestroyMicromapEXT) gpa(device, "vkDestroyMicromapEXT"); + if (table->DestroyMicromapEXT == nullptr) { table->DestroyMicromapEXT = (PFN_vkDestroyMicromapEXT)StubDestroyMicromapEXT; } + table->CmdBuildMicromapsEXT = (PFN_vkCmdBuildMicromapsEXT) gpa(device, "vkCmdBuildMicromapsEXT"); + if (table->CmdBuildMicromapsEXT == nullptr) { table->CmdBuildMicromapsEXT = (PFN_vkCmdBuildMicromapsEXT)StubCmdBuildMicromapsEXT; } + table->BuildMicromapsEXT = (PFN_vkBuildMicromapsEXT) gpa(device, "vkBuildMicromapsEXT"); + if (table->BuildMicromapsEXT == nullptr) { table->BuildMicromapsEXT = (PFN_vkBuildMicromapsEXT)StubBuildMicromapsEXT; } + table->CopyMicromapEXT = (PFN_vkCopyMicromapEXT) gpa(device, "vkCopyMicromapEXT"); + if (table->CopyMicromapEXT == nullptr) { table->CopyMicromapEXT = (PFN_vkCopyMicromapEXT)StubCopyMicromapEXT; } + table->CopyMicromapToMemoryEXT = (PFN_vkCopyMicromapToMemoryEXT) gpa(device, "vkCopyMicromapToMemoryEXT"); + if (table->CopyMicromapToMemoryEXT == nullptr) { table->CopyMicromapToMemoryEXT = (PFN_vkCopyMicromapToMemoryEXT)StubCopyMicromapToMemoryEXT; } + table->CopyMemoryToMicromapEXT = (PFN_vkCopyMemoryToMicromapEXT) gpa(device, "vkCopyMemoryToMicromapEXT"); + if (table->CopyMemoryToMicromapEXT == nullptr) { table->CopyMemoryToMicromapEXT = (PFN_vkCopyMemoryToMicromapEXT)StubCopyMemoryToMicromapEXT; } + table->WriteMicromapsPropertiesEXT = (PFN_vkWriteMicromapsPropertiesEXT) gpa(device, "vkWriteMicromapsPropertiesEXT"); + if (table->WriteMicromapsPropertiesEXT == nullptr) { table->WriteMicromapsPropertiesEXT = (PFN_vkWriteMicromapsPropertiesEXT)StubWriteMicromapsPropertiesEXT; } + table->CmdCopyMicromapEXT = (PFN_vkCmdCopyMicromapEXT) gpa(device, "vkCmdCopyMicromapEXT"); + if (table->CmdCopyMicromapEXT == nullptr) { table->CmdCopyMicromapEXT = (PFN_vkCmdCopyMicromapEXT)StubCmdCopyMicromapEXT; } + table->CmdCopyMicromapToMemoryEXT = (PFN_vkCmdCopyMicromapToMemoryEXT) gpa(device, "vkCmdCopyMicromapToMemoryEXT"); + if (table->CmdCopyMicromapToMemoryEXT == nullptr) { table->CmdCopyMicromapToMemoryEXT = (PFN_vkCmdCopyMicromapToMemoryEXT)StubCmdCopyMicromapToMemoryEXT; } + table->CmdCopyMemoryToMicromapEXT = (PFN_vkCmdCopyMemoryToMicromapEXT) gpa(device, "vkCmdCopyMemoryToMicromapEXT"); + if (table->CmdCopyMemoryToMicromapEXT == nullptr) { table->CmdCopyMemoryToMicromapEXT = (PFN_vkCmdCopyMemoryToMicromapEXT)StubCmdCopyMemoryToMicromapEXT; } + table->CmdWriteMicromapsPropertiesEXT = (PFN_vkCmdWriteMicromapsPropertiesEXT) gpa(device, "vkCmdWriteMicromapsPropertiesEXT"); + if (table->CmdWriteMicromapsPropertiesEXT == nullptr) { table->CmdWriteMicromapsPropertiesEXT = (PFN_vkCmdWriteMicromapsPropertiesEXT)StubCmdWriteMicromapsPropertiesEXT; } + table->GetDeviceMicromapCompatibilityEXT = (PFN_vkGetDeviceMicromapCompatibilityEXT) gpa(device, "vkGetDeviceMicromapCompatibilityEXT"); + if (table->GetDeviceMicromapCompatibilityEXT == nullptr) { table->GetDeviceMicromapCompatibilityEXT = (PFN_vkGetDeviceMicromapCompatibilityEXT)StubGetDeviceMicromapCompatibilityEXT; } + table->GetMicromapBuildSizesEXT = (PFN_vkGetMicromapBuildSizesEXT) gpa(device, "vkGetMicromapBuildSizesEXT"); + if (table->GetMicromapBuildSizesEXT == nullptr) { table->GetMicromapBuildSizesEXT = (PFN_vkGetMicromapBuildSizesEXT)StubGetMicromapBuildSizesEXT; } table->SetDeviceMemoryPriorityEXT = (PFN_vkSetDeviceMemoryPriorityEXT) gpa(device, "vkSetDeviceMemoryPriorityEXT"); if (table->SetDeviceMemoryPriorityEXT == nullptr) { table->SetDeviceMemoryPriorityEXT = (PFN_vkSetDeviceMemoryPriorityEXT)StubSetDeviceMemoryPriorityEXT; } table->GetDescriptorSetLayoutHostMappingInfoVALVE = (PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE) gpa(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE"); if (table->GetDescriptorSetLayoutHostMappingInfoVALVE == nullptr) { table->GetDescriptorSetLayoutHostMappingInfoVALVE = (PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)StubGetDescriptorSetLayoutHostMappingInfoVALVE; } table->GetDescriptorSetHostMappingVALVE = (PFN_vkGetDescriptorSetHostMappingVALVE) gpa(device, "vkGetDescriptorSetHostMappingVALVE"); if (table->GetDescriptorSetHostMappingVALVE == nullptr) { table->GetDescriptorSetHostMappingVALVE = (PFN_vkGetDescriptorSetHostMappingVALVE)StubGetDescriptorSetHostMappingVALVE; } + table->CmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT) gpa(device, "vkCmdSetTessellationDomainOriginEXT"); + if (table->CmdSetTessellationDomainOriginEXT == nullptr) { table->CmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)StubCmdSetTessellationDomainOriginEXT; } + table->CmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT) gpa(device, "vkCmdSetDepthClampEnableEXT"); + if (table->CmdSetDepthClampEnableEXT == nullptr) { table->CmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)StubCmdSetDepthClampEnableEXT; } + table->CmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT) gpa(device, "vkCmdSetPolygonModeEXT"); + if (table->CmdSetPolygonModeEXT == nullptr) { table->CmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT)StubCmdSetPolygonModeEXT; } + table->CmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT) gpa(device, "vkCmdSetRasterizationSamplesEXT"); + if (table->CmdSetRasterizationSamplesEXT == nullptr) { table->CmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT)StubCmdSetRasterizationSamplesEXT; } + table->CmdSetSampleMaskEXT = (PFN_vkCmdSetSampleMaskEXT) gpa(device, "vkCmdSetSampleMaskEXT"); + if (table->CmdSetSampleMaskEXT == nullptr) { table->CmdSetSampleMaskEXT = (PFN_vkCmdSetSampleMaskEXT)StubCmdSetSampleMaskEXT; } + table->CmdSetAlphaToCoverageEnableEXT = (PFN_vkCmdSetAlphaToCoverageEnableEXT) gpa(device, "vkCmdSetAlphaToCoverageEnableEXT"); + if (table->CmdSetAlphaToCoverageEnableEXT == nullptr) { table->CmdSetAlphaToCoverageEnableEXT = (PFN_vkCmdSetAlphaToCoverageEnableEXT)StubCmdSetAlphaToCoverageEnableEXT; } + table->CmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT) gpa(device, "vkCmdSetAlphaToOneEnableEXT"); + if (table->CmdSetAlphaToOneEnableEXT == nullptr) { table->CmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT)StubCmdSetAlphaToOneEnableEXT; } + table->CmdSetLogicOpEnableEXT = (PFN_vkCmdSetLogicOpEnableEXT) gpa(device, "vkCmdSetLogicOpEnableEXT"); + if (table->CmdSetLogicOpEnableEXT == nullptr) { table->CmdSetLogicOpEnableEXT = (PFN_vkCmdSetLogicOpEnableEXT)StubCmdSetLogicOpEnableEXT; } + table->CmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT) gpa(device, "vkCmdSetColorBlendEnableEXT"); + if (table->CmdSetColorBlendEnableEXT == nullptr) { table->CmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)StubCmdSetColorBlendEnableEXT; } + table->CmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT) gpa(device, "vkCmdSetColorBlendEquationEXT"); + if (table->CmdSetColorBlendEquationEXT == nullptr) { table->CmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)StubCmdSetColorBlendEquationEXT; } + table->CmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT) gpa(device, "vkCmdSetColorWriteMaskEXT"); + if (table->CmdSetColorWriteMaskEXT == nullptr) { table->CmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)StubCmdSetColorWriteMaskEXT; } + table->CmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT) gpa(device, "vkCmdSetRasterizationStreamEXT"); + if (table->CmdSetRasterizationStreamEXT == nullptr) { table->CmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)StubCmdSetRasterizationStreamEXT; } + table->CmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT) gpa(device, "vkCmdSetConservativeRasterizationModeEXT"); + if (table->CmdSetConservativeRasterizationModeEXT == nullptr) { table->CmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)StubCmdSetConservativeRasterizationModeEXT; } + table->CmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT) gpa(device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT"); + if (table->CmdSetExtraPrimitiveOverestimationSizeEXT == nullptr) { table->CmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)StubCmdSetExtraPrimitiveOverestimationSizeEXT; } + table->CmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT) gpa(device, "vkCmdSetDepthClipEnableEXT"); + if (table->CmdSetDepthClipEnableEXT == nullptr) { table->CmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)StubCmdSetDepthClipEnableEXT; } + table->CmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT) gpa(device, "vkCmdSetSampleLocationsEnableEXT"); + if (table->CmdSetSampleLocationsEnableEXT == nullptr) { table->CmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)StubCmdSetSampleLocationsEnableEXT; } + table->CmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT) gpa(device, "vkCmdSetColorBlendAdvancedEXT"); + if (table->CmdSetColorBlendAdvancedEXT == nullptr) { table->CmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)StubCmdSetColorBlendAdvancedEXT; } + table->CmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT) gpa(device, "vkCmdSetProvokingVertexModeEXT"); + if (table->CmdSetProvokingVertexModeEXT == nullptr) { table->CmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)StubCmdSetProvokingVertexModeEXT; } + table->CmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT) gpa(device, "vkCmdSetLineRasterizationModeEXT"); + if (table->CmdSetLineRasterizationModeEXT == nullptr) { table->CmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)StubCmdSetLineRasterizationModeEXT; } + table->CmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT) gpa(device, "vkCmdSetLineStippleEnableEXT"); + if (table->CmdSetLineStippleEnableEXT == nullptr) { table->CmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)StubCmdSetLineStippleEnableEXT; } + table->CmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT) gpa(device, "vkCmdSetDepthClipNegativeOneToOneEXT"); + if (table->CmdSetDepthClipNegativeOneToOneEXT == nullptr) { table->CmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)StubCmdSetDepthClipNegativeOneToOneEXT; } + table->CmdSetViewportWScalingEnableNV = (PFN_vkCmdSetViewportWScalingEnableNV) gpa(device, "vkCmdSetViewportWScalingEnableNV"); + if (table->CmdSetViewportWScalingEnableNV == nullptr) { table->CmdSetViewportWScalingEnableNV = (PFN_vkCmdSetViewportWScalingEnableNV)StubCmdSetViewportWScalingEnableNV; } + table->CmdSetViewportSwizzleNV = (PFN_vkCmdSetViewportSwizzleNV) gpa(device, "vkCmdSetViewportSwizzleNV"); + if (table->CmdSetViewportSwizzleNV == nullptr) { table->CmdSetViewportSwizzleNV = (PFN_vkCmdSetViewportSwizzleNV)StubCmdSetViewportSwizzleNV; } + table->CmdSetCoverageToColorEnableNV = (PFN_vkCmdSetCoverageToColorEnableNV) gpa(device, "vkCmdSetCoverageToColorEnableNV"); + if (table->CmdSetCoverageToColorEnableNV == nullptr) { table->CmdSetCoverageToColorEnableNV = (PFN_vkCmdSetCoverageToColorEnableNV)StubCmdSetCoverageToColorEnableNV; } + table->CmdSetCoverageToColorLocationNV = (PFN_vkCmdSetCoverageToColorLocationNV) gpa(device, "vkCmdSetCoverageToColorLocationNV"); + if (table->CmdSetCoverageToColorLocationNV == nullptr) { table->CmdSetCoverageToColorLocationNV = (PFN_vkCmdSetCoverageToColorLocationNV)StubCmdSetCoverageToColorLocationNV; } + table->CmdSetCoverageModulationModeNV = (PFN_vkCmdSetCoverageModulationModeNV) gpa(device, "vkCmdSetCoverageModulationModeNV"); + if (table->CmdSetCoverageModulationModeNV == nullptr) { table->CmdSetCoverageModulationModeNV = (PFN_vkCmdSetCoverageModulationModeNV)StubCmdSetCoverageModulationModeNV; } + table->CmdSetCoverageModulationTableEnableNV = (PFN_vkCmdSetCoverageModulationTableEnableNV) gpa(device, "vkCmdSetCoverageModulationTableEnableNV"); + if (table->CmdSetCoverageModulationTableEnableNV == nullptr) { table->CmdSetCoverageModulationTableEnableNV = (PFN_vkCmdSetCoverageModulationTableEnableNV)StubCmdSetCoverageModulationTableEnableNV; } + table->CmdSetCoverageModulationTableNV = (PFN_vkCmdSetCoverageModulationTableNV) gpa(device, "vkCmdSetCoverageModulationTableNV"); + if (table->CmdSetCoverageModulationTableNV == nullptr) { table->CmdSetCoverageModulationTableNV = (PFN_vkCmdSetCoverageModulationTableNV)StubCmdSetCoverageModulationTableNV; } + table->CmdSetShadingRateImageEnableNV = (PFN_vkCmdSetShadingRateImageEnableNV) gpa(device, "vkCmdSetShadingRateImageEnableNV"); + if (table->CmdSetShadingRateImageEnableNV == nullptr) { table->CmdSetShadingRateImageEnableNV = (PFN_vkCmdSetShadingRateImageEnableNV)StubCmdSetShadingRateImageEnableNV; } + table->CmdSetRepresentativeFragmentTestEnableNV = (PFN_vkCmdSetRepresentativeFragmentTestEnableNV) gpa(device, "vkCmdSetRepresentativeFragmentTestEnableNV"); + if (table->CmdSetRepresentativeFragmentTestEnableNV == nullptr) { table->CmdSetRepresentativeFragmentTestEnableNV = (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)StubCmdSetRepresentativeFragmentTestEnableNV; } + table->CmdSetCoverageReductionModeNV = (PFN_vkCmdSetCoverageReductionModeNV) gpa(device, "vkCmdSetCoverageReductionModeNV"); + if (table->CmdSetCoverageReductionModeNV == nullptr) { table->CmdSetCoverageReductionModeNV = (PFN_vkCmdSetCoverageReductionModeNV)StubCmdSetCoverageReductionModeNV; } table->GetShaderModuleIdentifierEXT = (PFN_vkGetShaderModuleIdentifierEXT) gpa(device, "vkGetShaderModuleIdentifierEXT"); if (table->GetShaderModuleIdentifierEXT == nullptr) { table->GetShaderModuleIdentifierEXT = (PFN_vkGetShaderModuleIdentifierEXT)StubGetShaderModuleIdentifierEXT; } table->GetShaderModuleCreateInfoIdentifierEXT = (PFN_vkGetShaderModuleCreateInfoIdentifierEXT) gpa(device, "vkGetShaderModuleCreateInfoIdentifierEXT"); if (table->GetShaderModuleCreateInfoIdentifierEXT == nullptr) { table->GetShaderModuleCreateInfoIdentifierEXT = (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)StubGetShaderModuleCreateInfoIdentifierEXT; } + table->CreateOpticalFlowSessionNV = (PFN_vkCreateOpticalFlowSessionNV) gpa(device, "vkCreateOpticalFlowSessionNV"); + if (table->CreateOpticalFlowSessionNV == nullptr) { table->CreateOpticalFlowSessionNV = (PFN_vkCreateOpticalFlowSessionNV)StubCreateOpticalFlowSessionNV; } + table->DestroyOpticalFlowSessionNV = (PFN_vkDestroyOpticalFlowSessionNV) gpa(device, "vkDestroyOpticalFlowSessionNV"); + if (table->DestroyOpticalFlowSessionNV == nullptr) { table->DestroyOpticalFlowSessionNV = (PFN_vkDestroyOpticalFlowSessionNV)StubDestroyOpticalFlowSessionNV; } + table->BindOpticalFlowSessionImageNV = (PFN_vkBindOpticalFlowSessionImageNV) gpa(device, "vkBindOpticalFlowSessionImageNV"); + if (table->BindOpticalFlowSessionImageNV == nullptr) { table->BindOpticalFlowSessionImageNV = (PFN_vkBindOpticalFlowSessionImageNV)StubBindOpticalFlowSessionImageNV; } + table->CmdOpticalFlowExecuteNV = (PFN_vkCmdOpticalFlowExecuteNV) gpa(device, "vkCmdOpticalFlowExecuteNV"); + if (table->CmdOpticalFlowExecuteNV == nullptr) { table->CmdOpticalFlowExecuteNV = (PFN_vkCmdOpticalFlowExecuteNV)StubCmdOpticalFlowExecuteNV; } table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM) gpa(device, "vkGetFramebufferTilePropertiesQCOM"); if (table->GetFramebufferTilePropertiesQCOM == nullptr) { table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)StubGetFramebufferTilePropertiesQCOM; } table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM) gpa(device, "vkGetDynamicRenderingTilePropertiesQCOM"); @@ -1297,4 +1447,5 @@ static inline void layer_init_instance_dispatch_table(VkInstance instance, VkLay #ifdef VK_USE_PLATFORM_SCREEN_QNX table->GetPhysicalDeviceScreenPresentationSupportQNX = (PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX) gpa(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX"); #endif // VK_USE_PLATFORM_SCREEN_QNX + table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV) gpa(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV"); } diff --git a/loader/generated/vk_layer_dispatch_table.h b/loader/generated/vk_layer_dispatch_table.h index 0015bbea5..5fc3c864f 100644 --- a/loader/generated/vk_layer_dispatch_table.h +++ b/loader/generated/vk_layer_dispatch_table.h @@ -275,6 +275,9 @@ typedef struct VkLayerInstanceDispatchTable_ { #ifdef VK_USE_PLATFORM_SCREEN_QNX PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX GetPhysicalDeviceScreenPresentationSupportQNX; #endif // VK_USE_PLATFORM_SCREEN_QNX + + // ---- VK_NV_optical_flow extension commands + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV; } VkLayerInstanceDispatchTable; // Device function pointer dispatch table @@ -880,6 +883,9 @@ typedef struct VkLayerDispatchTable_ { // ---- VK_EXT_image_compression_control extension commands PFN_vkGetImageSubresourceLayout2EXT GetImageSubresourceLayout2EXT; + // ---- VK_EXT_device_fault extension commands + PFN_vkGetDeviceFaultInfoEXT GetDeviceFaultInfoEXT; + // ---- VK_EXT_vertex_input_dynamic_state extension commands PFN_vkCmdSetVertexInputEXT CmdSetVertexInputEXT; @@ -943,6 +949,22 @@ typedef struct VkLayerDispatchTable_ { PFN_vkCmdDrawMultiEXT CmdDrawMultiEXT; PFN_vkCmdDrawMultiIndexedEXT CmdDrawMultiIndexedEXT; + // ---- VK_EXT_opacity_micromap extension commands + PFN_vkCreateMicromapEXT CreateMicromapEXT; + PFN_vkDestroyMicromapEXT DestroyMicromapEXT; + PFN_vkCmdBuildMicromapsEXT CmdBuildMicromapsEXT; + PFN_vkBuildMicromapsEXT BuildMicromapsEXT; + PFN_vkCopyMicromapEXT CopyMicromapEXT; + PFN_vkCopyMicromapToMemoryEXT CopyMicromapToMemoryEXT; + PFN_vkCopyMemoryToMicromapEXT CopyMemoryToMicromapEXT; + PFN_vkWriteMicromapsPropertiesEXT WriteMicromapsPropertiesEXT; + PFN_vkCmdCopyMicromapEXT CmdCopyMicromapEXT; + PFN_vkCmdCopyMicromapToMemoryEXT CmdCopyMicromapToMemoryEXT; + PFN_vkCmdCopyMemoryToMicromapEXT CmdCopyMemoryToMicromapEXT; + PFN_vkCmdWriteMicromapsPropertiesEXT CmdWriteMicromapsPropertiesEXT; + PFN_vkGetDeviceMicromapCompatibilityEXT GetDeviceMicromapCompatibilityEXT; + PFN_vkGetMicromapBuildSizesEXT GetMicromapBuildSizesEXT; + // ---- VK_EXT_pageable_device_local_memory extension commands PFN_vkSetDeviceMemoryPriorityEXT SetDeviceMemoryPriorityEXT; @@ -950,10 +972,49 @@ typedef struct VkLayerDispatchTable_ { PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE GetDescriptorSetLayoutHostMappingInfoVALVE; PFN_vkGetDescriptorSetHostMappingVALVE GetDescriptorSetHostMappingVALVE; + // ---- VK_EXT_extended_dynamic_state3 extension commands + PFN_vkCmdSetTessellationDomainOriginEXT CmdSetTessellationDomainOriginEXT; + PFN_vkCmdSetDepthClampEnableEXT CmdSetDepthClampEnableEXT; + PFN_vkCmdSetPolygonModeEXT CmdSetPolygonModeEXT; + PFN_vkCmdSetRasterizationSamplesEXT CmdSetRasterizationSamplesEXT; + PFN_vkCmdSetSampleMaskEXT CmdSetSampleMaskEXT; + PFN_vkCmdSetAlphaToCoverageEnableEXT CmdSetAlphaToCoverageEnableEXT; + PFN_vkCmdSetAlphaToOneEnableEXT CmdSetAlphaToOneEnableEXT; + PFN_vkCmdSetLogicOpEnableEXT CmdSetLogicOpEnableEXT; + PFN_vkCmdSetColorBlendEnableEXT CmdSetColorBlendEnableEXT; + PFN_vkCmdSetColorBlendEquationEXT CmdSetColorBlendEquationEXT; + PFN_vkCmdSetColorWriteMaskEXT CmdSetColorWriteMaskEXT; + PFN_vkCmdSetRasterizationStreamEXT CmdSetRasterizationStreamEXT; + PFN_vkCmdSetConservativeRasterizationModeEXT CmdSetConservativeRasterizationModeEXT; + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT CmdSetExtraPrimitiveOverestimationSizeEXT; + PFN_vkCmdSetDepthClipEnableEXT CmdSetDepthClipEnableEXT; + PFN_vkCmdSetSampleLocationsEnableEXT CmdSetSampleLocationsEnableEXT; + PFN_vkCmdSetColorBlendAdvancedEXT CmdSetColorBlendAdvancedEXT; + PFN_vkCmdSetProvokingVertexModeEXT CmdSetProvokingVertexModeEXT; + PFN_vkCmdSetLineRasterizationModeEXT CmdSetLineRasterizationModeEXT; + PFN_vkCmdSetLineStippleEnableEXT CmdSetLineStippleEnableEXT; + PFN_vkCmdSetDepthClipNegativeOneToOneEXT CmdSetDepthClipNegativeOneToOneEXT; + PFN_vkCmdSetViewportWScalingEnableNV CmdSetViewportWScalingEnableNV; + PFN_vkCmdSetViewportSwizzleNV CmdSetViewportSwizzleNV; + PFN_vkCmdSetCoverageToColorEnableNV CmdSetCoverageToColorEnableNV; + PFN_vkCmdSetCoverageToColorLocationNV CmdSetCoverageToColorLocationNV; + PFN_vkCmdSetCoverageModulationModeNV CmdSetCoverageModulationModeNV; + PFN_vkCmdSetCoverageModulationTableEnableNV CmdSetCoverageModulationTableEnableNV; + PFN_vkCmdSetCoverageModulationTableNV CmdSetCoverageModulationTableNV; + PFN_vkCmdSetShadingRateImageEnableNV CmdSetShadingRateImageEnableNV; + PFN_vkCmdSetRepresentativeFragmentTestEnableNV CmdSetRepresentativeFragmentTestEnableNV; + PFN_vkCmdSetCoverageReductionModeNV CmdSetCoverageReductionModeNV; + // ---- VK_EXT_shader_module_identifier extension commands PFN_vkGetShaderModuleIdentifierEXT GetShaderModuleIdentifierEXT; PFN_vkGetShaderModuleCreateInfoIdentifierEXT GetShaderModuleCreateInfoIdentifierEXT; + // ---- VK_NV_optical_flow extension commands + PFN_vkCreateOpticalFlowSessionNV CreateOpticalFlowSessionNV; + PFN_vkDestroyOpticalFlowSessionNV DestroyOpticalFlowSessionNV; + PFN_vkBindOpticalFlowSessionImageNV BindOpticalFlowSessionImageNV; + PFN_vkCmdOpticalFlowExecuteNV CmdOpticalFlowExecuteNV; + // ---- VK_QCOM_tile_properties extension commands PFN_vkGetFramebufferTilePropertiesQCOM GetFramebufferTilePropertiesQCOM; PFN_vkGetDynamicRenderingTilePropertiesQCOM GetDynamicRenderingTilePropertiesQCOM; diff --git a/loader/generated/vk_loader_extensions.c b/loader/generated/vk_loader_extensions.c index 15a67d72e..4960ab816 100644 --- a/loader/generated/vk_loader_extensions.c +++ b/loader/generated/vk_loader_extensions.c @@ -320,6 +320,9 @@ VKAPI_ATTR bool VKAPI_CALL loader_icd_init_entries(struct loader_icd_term *icd_t LOOKUP_GIPA(GetPhysicalDeviceScreenPresentationSupportQNX, false); #endif // VK_USE_PLATFORM_SCREEN_QNX + // ---- VK_NV_optical_flow extension commands + LOOKUP_GIPA(GetPhysicalDeviceOpticalFlowImageFormatsNV, false); + #undef LOOKUP_GIPA return true; @@ -940,6 +943,9 @@ VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct lo // ---- VK_EXT_image_compression_control extension commands table->GetImageSubresourceLayout2EXT = (PFN_vkGetImageSubresourceLayout2EXT)gdpa(dev, "vkGetImageSubresourceLayout2EXT"); + // ---- VK_EXT_device_fault extension commands + table->GetDeviceFaultInfoEXT = (PFN_vkGetDeviceFaultInfoEXT)gdpa(dev, "vkGetDeviceFaultInfoEXT"); + // ---- VK_EXT_vertex_input_dynamic_state extension commands table->CmdSetVertexInputEXT = (PFN_vkCmdSetVertexInputEXT)gdpa(dev, "vkCmdSetVertexInputEXT"); @@ -1003,6 +1009,22 @@ VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct lo table->CmdDrawMultiEXT = (PFN_vkCmdDrawMultiEXT)gdpa(dev, "vkCmdDrawMultiEXT"); table->CmdDrawMultiIndexedEXT = (PFN_vkCmdDrawMultiIndexedEXT)gdpa(dev, "vkCmdDrawMultiIndexedEXT"); + // ---- VK_EXT_opacity_micromap extension commands + table->CreateMicromapEXT = (PFN_vkCreateMicromapEXT)gdpa(dev, "vkCreateMicromapEXT"); + table->DestroyMicromapEXT = (PFN_vkDestroyMicromapEXT)gdpa(dev, "vkDestroyMicromapEXT"); + table->CmdBuildMicromapsEXT = (PFN_vkCmdBuildMicromapsEXT)gdpa(dev, "vkCmdBuildMicromapsEXT"); + table->BuildMicromapsEXT = (PFN_vkBuildMicromapsEXT)gdpa(dev, "vkBuildMicromapsEXT"); + table->CopyMicromapEXT = (PFN_vkCopyMicromapEXT)gdpa(dev, "vkCopyMicromapEXT"); + table->CopyMicromapToMemoryEXT = (PFN_vkCopyMicromapToMemoryEXT)gdpa(dev, "vkCopyMicromapToMemoryEXT"); + table->CopyMemoryToMicromapEXT = (PFN_vkCopyMemoryToMicromapEXT)gdpa(dev, "vkCopyMemoryToMicromapEXT"); + table->WriteMicromapsPropertiesEXT = (PFN_vkWriteMicromapsPropertiesEXT)gdpa(dev, "vkWriteMicromapsPropertiesEXT"); + table->CmdCopyMicromapEXT = (PFN_vkCmdCopyMicromapEXT)gdpa(dev, "vkCmdCopyMicromapEXT"); + table->CmdCopyMicromapToMemoryEXT = (PFN_vkCmdCopyMicromapToMemoryEXT)gdpa(dev, "vkCmdCopyMicromapToMemoryEXT"); + table->CmdCopyMemoryToMicromapEXT = (PFN_vkCmdCopyMemoryToMicromapEXT)gdpa(dev, "vkCmdCopyMemoryToMicromapEXT"); + table->CmdWriteMicromapsPropertiesEXT = (PFN_vkCmdWriteMicromapsPropertiesEXT)gdpa(dev, "vkCmdWriteMicromapsPropertiesEXT"); + table->GetDeviceMicromapCompatibilityEXT = (PFN_vkGetDeviceMicromapCompatibilityEXT)gdpa(dev, "vkGetDeviceMicromapCompatibilityEXT"); + table->GetMicromapBuildSizesEXT = (PFN_vkGetMicromapBuildSizesEXT)gdpa(dev, "vkGetMicromapBuildSizesEXT"); + // ---- VK_EXT_pageable_device_local_memory extension commands table->SetDeviceMemoryPriorityEXT = (PFN_vkSetDeviceMemoryPriorityEXT)gdpa(dev, "vkSetDeviceMemoryPriorityEXT"); @@ -1010,10 +1032,49 @@ VKAPI_ATTR void VKAPI_CALL loader_init_device_extension_dispatch_table(struct lo table->GetDescriptorSetLayoutHostMappingInfoVALVE = (PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)gdpa(dev, "vkGetDescriptorSetLayoutHostMappingInfoVALVE"); table->GetDescriptorSetHostMappingVALVE = (PFN_vkGetDescriptorSetHostMappingVALVE)gdpa(dev, "vkGetDescriptorSetHostMappingVALVE"); + // ---- VK_EXT_extended_dynamic_state3 extension commands + table->CmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)gdpa(dev, "vkCmdSetTessellationDomainOriginEXT"); + table->CmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)gdpa(dev, "vkCmdSetDepthClampEnableEXT"); + table->CmdSetPolygonModeEXT = (PFN_vkCmdSetPolygonModeEXT)gdpa(dev, "vkCmdSetPolygonModeEXT"); + table->CmdSetRasterizationSamplesEXT = (PFN_vkCmdSetRasterizationSamplesEXT)gdpa(dev, "vkCmdSetRasterizationSamplesEXT"); + table->CmdSetSampleMaskEXT = (PFN_vkCmdSetSampleMaskEXT)gdpa(dev, "vkCmdSetSampleMaskEXT"); + table->CmdSetAlphaToCoverageEnableEXT = (PFN_vkCmdSetAlphaToCoverageEnableEXT)gdpa(dev, "vkCmdSetAlphaToCoverageEnableEXT"); + table->CmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT)gdpa(dev, "vkCmdSetAlphaToOneEnableEXT"); + table->CmdSetLogicOpEnableEXT = (PFN_vkCmdSetLogicOpEnableEXT)gdpa(dev, "vkCmdSetLogicOpEnableEXT"); + table->CmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)gdpa(dev, "vkCmdSetColorBlendEnableEXT"); + table->CmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)gdpa(dev, "vkCmdSetColorBlendEquationEXT"); + table->CmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)gdpa(dev, "vkCmdSetColorWriteMaskEXT"); + table->CmdSetRasterizationStreamEXT = (PFN_vkCmdSetRasterizationStreamEXT)gdpa(dev, "vkCmdSetRasterizationStreamEXT"); + table->CmdSetConservativeRasterizationModeEXT = (PFN_vkCmdSetConservativeRasterizationModeEXT)gdpa(dev, "vkCmdSetConservativeRasterizationModeEXT"); + table->CmdSetExtraPrimitiveOverestimationSizeEXT = (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)gdpa(dev, "vkCmdSetExtraPrimitiveOverestimationSizeEXT"); + table->CmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)gdpa(dev, "vkCmdSetDepthClipEnableEXT"); + table->CmdSetSampleLocationsEnableEXT = (PFN_vkCmdSetSampleLocationsEnableEXT)gdpa(dev, "vkCmdSetSampleLocationsEnableEXT"); + table->CmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)gdpa(dev, "vkCmdSetColorBlendAdvancedEXT"); + table->CmdSetProvokingVertexModeEXT = (PFN_vkCmdSetProvokingVertexModeEXT)gdpa(dev, "vkCmdSetProvokingVertexModeEXT"); + table->CmdSetLineRasterizationModeEXT = (PFN_vkCmdSetLineRasterizationModeEXT)gdpa(dev, "vkCmdSetLineRasterizationModeEXT"); + table->CmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)gdpa(dev, "vkCmdSetLineStippleEnableEXT"); + table->CmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)gdpa(dev, "vkCmdSetDepthClipNegativeOneToOneEXT"); + table->CmdSetViewportWScalingEnableNV = (PFN_vkCmdSetViewportWScalingEnableNV)gdpa(dev, "vkCmdSetViewportWScalingEnableNV"); + table->CmdSetViewportSwizzleNV = (PFN_vkCmdSetViewportSwizzleNV)gdpa(dev, "vkCmdSetViewportSwizzleNV"); + table->CmdSetCoverageToColorEnableNV = (PFN_vkCmdSetCoverageToColorEnableNV)gdpa(dev, "vkCmdSetCoverageToColorEnableNV"); + table->CmdSetCoverageToColorLocationNV = (PFN_vkCmdSetCoverageToColorLocationNV)gdpa(dev, "vkCmdSetCoverageToColorLocationNV"); + table->CmdSetCoverageModulationModeNV = (PFN_vkCmdSetCoverageModulationModeNV)gdpa(dev, "vkCmdSetCoverageModulationModeNV"); + table->CmdSetCoverageModulationTableEnableNV = (PFN_vkCmdSetCoverageModulationTableEnableNV)gdpa(dev, "vkCmdSetCoverageModulationTableEnableNV"); + table->CmdSetCoverageModulationTableNV = (PFN_vkCmdSetCoverageModulationTableNV)gdpa(dev, "vkCmdSetCoverageModulationTableNV"); + table->CmdSetShadingRateImageEnableNV = (PFN_vkCmdSetShadingRateImageEnableNV)gdpa(dev, "vkCmdSetShadingRateImageEnableNV"); + table->CmdSetRepresentativeFragmentTestEnableNV = (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)gdpa(dev, "vkCmdSetRepresentativeFragmentTestEnableNV"); + table->CmdSetCoverageReductionModeNV = (PFN_vkCmdSetCoverageReductionModeNV)gdpa(dev, "vkCmdSetCoverageReductionModeNV"); + // ---- VK_EXT_shader_module_identifier extension commands table->GetShaderModuleIdentifierEXT = (PFN_vkGetShaderModuleIdentifierEXT)gdpa(dev, "vkGetShaderModuleIdentifierEXT"); table->GetShaderModuleCreateInfoIdentifierEXT = (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)gdpa(dev, "vkGetShaderModuleCreateInfoIdentifierEXT"); + // ---- VK_NV_optical_flow extension commands + table->CreateOpticalFlowSessionNV = (PFN_vkCreateOpticalFlowSessionNV)gdpa(dev, "vkCreateOpticalFlowSessionNV"); + table->DestroyOpticalFlowSessionNV = (PFN_vkDestroyOpticalFlowSessionNV)gdpa(dev, "vkDestroyOpticalFlowSessionNV"); + table->BindOpticalFlowSessionImageNV = (PFN_vkBindOpticalFlowSessionImageNV)gdpa(dev, "vkBindOpticalFlowSessionImageNV"); + table->CmdOpticalFlowExecuteNV = (PFN_vkCmdOpticalFlowExecuteNV)gdpa(dev, "vkCmdOpticalFlowExecuteNV"); + // ---- VK_QCOM_tile_properties extension commands table->GetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)gdpa(dev, "vkGetFramebufferTilePropertiesQCOM"); table->GetDynamicRenderingTilePropertiesQCOM = (PFN_vkGetDynamicRenderingTilePropertiesQCOM)gdpa(dev, "vkGetDynamicRenderingTilePropertiesQCOM"); @@ -1298,6 +1359,9 @@ VKAPI_ATTR void VKAPI_CALL loader_init_instance_extension_dispatch_table(VkLayer #ifdef VK_USE_PLATFORM_SCREEN_QNX table->GetPhysicalDeviceScreenPresentationSupportQNX = (PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)gpa(inst, "vkGetPhysicalDeviceScreenPresentationSupportQNX"); #endif // VK_USE_PLATFORM_SCREEN_QNX + + // ---- VK_NV_optical_flow extension commands + table->GetPhysicalDeviceOpticalFlowImageFormatsNV = (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)gpa(inst, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV"); } // Device command lookup function @@ -1904,6 +1968,9 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDis // ---- VK_EXT_image_compression_control extension commands if (!strcmp(name, "GetImageSubresourceLayout2EXT")) return (void *)table->GetImageSubresourceLayout2EXT; + // ---- VK_EXT_device_fault extension commands + if (!strcmp(name, "GetDeviceFaultInfoEXT")) return (void *)table->GetDeviceFaultInfoEXT; + // ---- VK_EXT_vertex_input_dynamic_state extension commands if (!strcmp(name, "CmdSetVertexInputEXT")) return (void *)table->CmdSetVertexInputEXT; @@ -1967,6 +2034,22 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDis if (!strcmp(name, "CmdDrawMultiEXT")) return (void *)table->CmdDrawMultiEXT; if (!strcmp(name, "CmdDrawMultiIndexedEXT")) return (void *)table->CmdDrawMultiIndexedEXT; + // ---- VK_EXT_opacity_micromap extension commands + if (!strcmp(name, "CreateMicromapEXT")) return (void *)table->CreateMicromapEXT; + if (!strcmp(name, "DestroyMicromapEXT")) return (void *)table->DestroyMicromapEXT; + if (!strcmp(name, "CmdBuildMicromapsEXT")) return (void *)table->CmdBuildMicromapsEXT; + if (!strcmp(name, "BuildMicromapsEXT")) return (void *)table->BuildMicromapsEXT; + if (!strcmp(name, "CopyMicromapEXT")) return (void *)table->CopyMicromapEXT; + if (!strcmp(name, "CopyMicromapToMemoryEXT")) return (void *)table->CopyMicromapToMemoryEXT; + if (!strcmp(name, "CopyMemoryToMicromapEXT")) return (void *)table->CopyMemoryToMicromapEXT; + if (!strcmp(name, "WriteMicromapsPropertiesEXT")) return (void *)table->WriteMicromapsPropertiesEXT; + if (!strcmp(name, "CmdCopyMicromapEXT")) return (void *)table->CmdCopyMicromapEXT; + if (!strcmp(name, "CmdCopyMicromapToMemoryEXT")) return (void *)table->CmdCopyMicromapToMemoryEXT; + if (!strcmp(name, "CmdCopyMemoryToMicromapEXT")) return (void *)table->CmdCopyMemoryToMicromapEXT; + if (!strcmp(name, "CmdWriteMicromapsPropertiesEXT")) return (void *)table->CmdWriteMicromapsPropertiesEXT; + if (!strcmp(name, "GetDeviceMicromapCompatibilityEXT")) return (void *)table->GetDeviceMicromapCompatibilityEXT; + if (!strcmp(name, "GetMicromapBuildSizesEXT")) return (void *)table->GetMicromapBuildSizesEXT; + // ---- VK_EXT_pageable_device_local_memory extension commands if (!strcmp(name, "SetDeviceMemoryPriorityEXT")) return (void *)table->SetDeviceMemoryPriorityEXT; @@ -1974,10 +2057,49 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_device_dispatch_table(const VkLayerDis if (!strcmp(name, "GetDescriptorSetLayoutHostMappingInfoVALVE")) return (void *)table->GetDescriptorSetLayoutHostMappingInfoVALVE; if (!strcmp(name, "GetDescriptorSetHostMappingVALVE")) return (void *)table->GetDescriptorSetHostMappingVALVE; + // ---- VK_EXT_extended_dynamic_state3 extension commands + if (!strcmp(name, "CmdSetTessellationDomainOriginEXT")) return (void *)table->CmdSetTessellationDomainOriginEXT; + if (!strcmp(name, "CmdSetDepthClampEnableEXT")) return (void *)table->CmdSetDepthClampEnableEXT; + if (!strcmp(name, "CmdSetPolygonModeEXT")) return (void *)table->CmdSetPolygonModeEXT; + if (!strcmp(name, "CmdSetRasterizationSamplesEXT")) return (void *)table->CmdSetRasterizationSamplesEXT; + if (!strcmp(name, "CmdSetSampleMaskEXT")) return (void *)table->CmdSetSampleMaskEXT; + if (!strcmp(name, "CmdSetAlphaToCoverageEnableEXT")) return (void *)table->CmdSetAlphaToCoverageEnableEXT; + if (!strcmp(name, "CmdSetAlphaToOneEnableEXT")) return (void *)table->CmdSetAlphaToOneEnableEXT; + if (!strcmp(name, "CmdSetLogicOpEnableEXT")) return (void *)table->CmdSetLogicOpEnableEXT; + if (!strcmp(name, "CmdSetColorBlendEnableEXT")) return (void *)table->CmdSetColorBlendEnableEXT; + if (!strcmp(name, "CmdSetColorBlendEquationEXT")) return (void *)table->CmdSetColorBlendEquationEXT; + if (!strcmp(name, "CmdSetColorWriteMaskEXT")) return (void *)table->CmdSetColorWriteMaskEXT; + if (!strcmp(name, "CmdSetRasterizationStreamEXT")) return (void *)table->CmdSetRasterizationStreamEXT; + if (!strcmp(name, "CmdSetConservativeRasterizationModeEXT")) return (void *)table->CmdSetConservativeRasterizationModeEXT; + if (!strcmp(name, "CmdSetExtraPrimitiveOverestimationSizeEXT")) return (void *)table->CmdSetExtraPrimitiveOverestimationSizeEXT; + if (!strcmp(name, "CmdSetDepthClipEnableEXT")) return (void *)table->CmdSetDepthClipEnableEXT; + if (!strcmp(name, "CmdSetSampleLocationsEnableEXT")) return (void *)table->CmdSetSampleLocationsEnableEXT; + if (!strcmp(name, "CmdSetColorBlendAdvancedEXT")) return (void *)table->CmdSetColorBlendAdvancedEXT; + if (!strcmp(name, "CmdSetProvokingVertexModeEXT")) return (void *)table->CmdSetProvokingVertexModeEXT; + if (!strcmp(name, "CmdSetLineRasterizationModeEXT")) return (void *)table->CmdSetLineRasterizationModeEXT; + if (!strcmp(name, "CmdSetLineStippleEnableEXT")) return (void *)table->CmdSetLineStippleEnableEXT; + if (!strcmp(name, "CmdSetDepthClipNegativeOneToOneEXT")) return (void *)table->CmdSetDepthClipNegativeOneToOneEXT; + if (!strcmp(name, "CmdSetViewportWScalingEnableNV")) return (void *)table->CmdSetViewportWScalingEnableNV; + if (!strcmp(name, "CmdSetViewportSwizzleNV")) return (void *)table->CmdSetViewportSwizzleNV; + if (!strcmp(name, "CmdSetCoverageToColorEnableNV")) return (void *)table->CmdSetCoverageToColorEnableNV; + if (!strcmp(name, "CmdSetCoverageToColorLocationNV")) return (void *)table->CmdSetCoverageToColorLocationNV; + if (!strcmp(name, "CmdSetCoverageModulationModeNV")) return (void *)table->CmdSetCoverageModulationModeNV; + if (!strcmp(name, "CmdSetCoverageModulationTableEnableNV")) return (void *)table->CmdSetCoverageModulationTableEnableNV; + if (!strcmp(name, "CmdSetCoverageModulationTableNV")) return (void *)table->CmdSetCoverageModulationTableNV; + if (!strcmp(name, "CmdSetShadingRateImageEnableNV")) return (void *)table->CmdSetShadingRateImageEnableNV; + if (!strcmp(name, "CmdSetRepresentativeFragmentTestEnableNV")) return (void *)table->CmdSetRepresentativeFragmentTestEnableNV; + if (!strcmp(name, "CmdSetCoverageReductionModeNV")) return (void *)table->CmdSetCoverageReductionModeNV; + // ---- VK_EXT_shader_module_identifier extension commands if (!strcmp(name, "GetShaderModuleIdentifierEXT")) return (void *)table->GetShaderModuleIdentifierEXT; if (!strcmp(name, "GetShaderModuleCreateInfoIdentifierEXT")) return (void *)table->GetShaderModuleCreateInfoIdentifierEXT; + // ---- VK_NV_optical_flow extension commands + if (!strcmp(name, "CreateOpticalFlowSessionNV")) return (void *)table->CreateOpticalFlowSessionNV; + if (!strcmp(name, "DestroyOpticalFlowSessionNV")) return (void *)table->DestroyOpticalFlowSessionNV; + if (!strcmp(name, "BindOpticalFlowSessionImageNV")) return (void *)table->BindOpticalFlowSessionImageNV; + if (!strcmp(name, "CmdOpticalFlowExecuteNV")) return (void *)table->CmdOpticalFlowExecuteNV; + // ---- VK_QCOM_tile_properties extension commands if (!strcmp(name, "GetFramebufferTilePropertiesQCOM")) return (void *)table->GetFramebufferTilePropertiesQCOM; if (!strcmp(name, "GetDynamicRenderingTilePropertiesQCOM")) return (void *)table->GetDynamicRenderingTilePropertiesQCOM; @@ -2267,6 +2389,9 @@ VKAPI_ATTR void* VKAPI_CALL loader_lookup_instance_dispatch_table(const VkLayerI if (!strcmp(name, "GetPhysicalDeviceScreenPresentationSupportQNX")) return (void *)table->GetPhysicalDeviceScreenPresentationSupportQNX; #endif // VK_USE_PLATFORM_SCREEN_QNX + // ---- VK_NV_optical_flow extension commands + if (!strcmp(name, "GetPhysicalDeviceOpticalFlowImageFormatsNV")) return (void *)table->GetPhysicalDeviceOpticalFlowImageFormatsNV; + *found_name = false; return NULL; } @@ -5970,6 +6095,23 @@ VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( } +// ---- VK_EXT_device_fault extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkGetDeviceFaultInfoEXT: Invalid device " + "[VUID-vkGetDeviceFaultInfoEXT-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->GetDeviceFaultInfoEXT(device, pFaultCounts, pFaultInfo); +} + + // ---- VK_NV_acquire_winrt_display extension trampoline/terminators #ifdef VK_USE_PLATFORM_WIN32_KHR @@ -6411,350 +6553,1068 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT( } -// ---- VK_EXT_pageable_device_local_memory extension trampoline/terminators +// ---- VK_EXT_opacity_micromap extension trampoline/terminators -VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( +VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( VkDevice device, - VkDeviceMemory memory, - float priority) { + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkSetDeviceMemoryPriorityEXT: Invalid device " - "[VUID-vkSetDeviceMemoryPriorityEXT-device-parameter]"); + "vkCreateMicromapEXT: Invalid device " + "[VUID-vkCreateMicromapEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->SetDeviceMemoryPriorityEXT(device, memory, priority); + return disp->CreateMicromapEXT(device, pCreateInfo, pAllocator, pMicromap); } - -// ---- VK_VALVE_descriptor_set_host_mapping extension trampoline/terminators - -VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE( +VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( VkDevice device, - const VkDescriptorSetBindingReferenceVALVE* pBindingReference, - VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) { + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkGetDescriptorSetLayoutHostMappingInfoVALVE: Invalid device " - "[VUID-vkGetDescriptorSetLayoutHostMappingInfoVALVE-device-parameter]"); + "vkDestroyMicromapEXT: Invalid device " + "[VUID-vkDestroyMicromapEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->GetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping); + disp->DestroyMicromapEXT(device, micromap, pAllocator); } -VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( - VkDevice device, - VkDescriptorSet descriptorSet, - void** ppData) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); +VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkGetDescriptorSetHostMappingVALVE: Invalid device " - "[VUID-vkGetDescriptorSetHostMappingVALVE-device-parameter]"); + "vkCmdBuildMicromapsEXT: Invalid commandBuffer " + "[VUID-vkCmdBuildMicromapsEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData); + disp->CmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos); } - -// ---- VK_EXT_shader_module_identifier extension trampoline/terminators - -VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( +VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( VkDevice device, - VkShaderModule shaderModule, - VkShaderModuleIdentifierEXT* pIdentifier) { + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkGetShaderModuleIdentifierEXT: Invalid device " - "[VUID-vkGetShaderModuleIdentifierEXT-device-parameter]"); + "vkBuildMicromapsEXT: Invalid device " + "[VUID-vkBuildMicromapsEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->GetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); + return disp->BuildMicromapsEXT(device, deferredOperation, infoCount, pInfos); } -VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( +VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModuleIdentifierEXT* pIdentifier) { + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkGetShaderModuleCreateInfoIdentifierEXT: Invalid device " - "[VUID-vkGetShaderModuleCreateInfoIdentifierEXT-device-parameter]"); + "vkCopyMicromapEXT: Invalid device " + "[VUID-vkCopyMicromapEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->GetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); + return disp->CopyMicromapEXT(device, deferredOperation, pInfo); } - -// ---- VK_QCOM_tile_properties extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( +VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( VkDevice device, - VkFramebuffer framebuffer, - uint32_t* pPropertiesCount, - VkTilePropertiesQCOM* pProperties) { + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkGetFramebufferTilePropertiesQCOM: Invalid device " - "[VUID-vkGetFramebufferTilePropertiesQCOM-device-parameter]"); + "vkCopyMicromapToMemoryEXT: Invalid device " + "[VUID-vkCopyMicromapToMemoryEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - return disp->GetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties); + return disp->CopyMicromapToMemoryEXT(device, deferredOperation, pInfo); } -VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( +VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( VkDevice device, - const VkRenderingInfo* pRenderingInfo, - VkTilePropertiesQCOM* pProperties) { + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkGetDynamicRenderingTilePropertiesQCOM: Invalid device " - "[VUID-vkGetDynamicRenderingTilePropertiesQCOM-device-parameter]"); + "vkCopyMemoryToMicromapEXT: Invalid device " + "[VUID-vkCopyMemoryToMicromapEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - return disp->GetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties); + return disp->CopyMemoryToMicromapEXT(device, deferredOperation, pInfo); } - -// ---- VK_KHR_acceleration_structure extension trampoline/terminators - -VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( +VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT( VkDevice device, - const VkAccelerationStructureCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureKHR* pAccelerationStructure) { + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCreateAccelerationStructureKHR: Invalid device " - "[VUID-vkCreateAccelerationStructureKHR-device-parameter]"); + "vkWriteMicromapsPropertiesEXT: Invalid device " + "[VUID-vkWriteMicromapsPropertiesEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - return disp->CreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); + return disp->WriteMicromapsPropertiesEXT(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); } -VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR( - VkDevice device, - VkAccelerationStructureKHR accelerationStructure, - const VkAllocationCallbacks* pAllocator) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); +VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkDestroyAccelerationStructureKHR: Invalid device " - "[VUID-vkDestroyAccelerationStructureKHR-device-parameter]"); + "vkCmdCopyMicromapEXT: Invalid commandBuffer " + "[VUID-vkCmdCopyMicromapEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->DestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); + disp->CmdCopyMicromapEXT(commandBuffer, pInfo); } -VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( +VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + const VkCopyMicromapToMemoryInfoEXT* pInfo) { const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCmdBuildAccelerationStructuresKHR: Invalid commandBuffer " - "[VUID-vkCmdBuildAccelerationStructuresKHR-commandBuffer-parameter]"); + "vkCmdCopyMicromapToMemoryEXT: Invalid commandBuffer " + "[VUID-vkCmdCopyMicromapToMemoryEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->CmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); + disp->CmdCopyMicromapToMemoryEXT(commandBuffer, pInfo); } -VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR( +VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkDeviceAddress* pIndirectDeviceAddresses, - const uint32_t* pIndirectStrides, - const uint32_t* const* ppMaxPrimitiveCounts) { + const VkCopyMemoryToMicromapInfoEXT* pInfo) { const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCmdBuildAccelerationStructuresIndirectKHR: Invalid commandBuffer " - "[VUID-vkCmdBuildAccelerationStructuresIndirectKHR-commandBuffer-parameter]"); + "vkCmdCopyMemoryToMicromapEXT: Invalid commandBuffer " + "[VUID-vkCmdCopyMemoryToMicromapEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->CmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); + disp->CmdCopyMemoryToMicromapEXT(commandBuffer, pInfo); } -VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR( +VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdWriteMicromapsPropertiesEXT: Invalid commandBuffer " + "[VUID-vkCmdWriteMicromapsPropertiesEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); +} + +VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkBuildAccelerationStructuresKHR: Invalid device " - "[VUID-vkBuildAccelerationStructuresKHR-device-parameter]"); + "vkGetDeviceMicromapCompatibilityEXT: Invalid device " + "[VUID-vkGetDeviceMicromapCompatibilityEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - return disp->BuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); + disp->GetDeviceMicromapCompatibilityEXT(device, pVersionInfo, pCompatibility); } -VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR( +VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureInfoKHR* pInfo) { + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCopyAccelerationStructureKHR: Invalid device " - "[VUID-vkCopyAccelerationStructureKHR-device-parameter]"); + "vkGetMicromapBuildSizesEXT: Invalid device " + "[VUID-vkGetMicromapBuildSizesEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - return disp->CopyAccelerationStructureKHR(device, deferredOperation, pInfo); + disp->GetMicromapBuildSizesEXT(device, buildType, pBuildInfo, pSizeInfo); } -VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( + +// ---- VK_EXT_pageable_device_local_memory extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + VkDeviceMemory memory, + float priority) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCopyAccelerationStructureToMemoryKHR: Invalid device " - "[VUID-vkCopyAccelerationStructureToMemoryKHR-device-parameter]"); + "vkSetDeviceMemoryPriorityEXT: Invalid device " + "[VUID-vkSetDeviceMemoryPriorityEXT-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - return disp->CopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); + disp->SetDeviceMemoryPriorityEXT(device, memory, priority); } -VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( + +// ---- VK_VALVE_descriptor_set_host_mapping extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCopyMemoryToAccelerationStructureKHR: Invalid device " - "[VUID-vkCopyMemoryToAccelerationStructureKHR-device-parameter]"); + "vkGetDescriptorSetLayoutHostMappingInfoVALVE: Invalid device " + "[VUID-vkGetDescriptorSetLayoutHostMappingInfoVALVE-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - return disp->CopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); + disp->GetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping); } -VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR( +VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( VkDevice device, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - size_t dataSize, - void* pData, - size_t stride) { + VkDescriptorSet descriptorSet, + void** ppData) { const VkLayerDispatchTable *disp = loader_get_dispatch(device); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkWriteAccelerationStructuresPropertiesKHR: Invalid device " - "[VUID-vkWriteAccelerationStructuresPropertiesKHR-device-parameter]"); + "vkGetDescriptorSetHostMappingVALVE: Invalid device " + "[VUID-vkGetDescriptorSetHostMappingVALVE-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - return disp->WriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); + disp->GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData); } -VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR( + +// ---- VK_EXT_extended_dynamic_state3 extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureInfoKHR* pInfo) { + VkTessellationDomainOrigin domainOrigin) { const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCmdCopyAccelerationStructureKHR: Invalid commandBuffer " - "[VUID-vkCmdCopyAccelerationStructureKHR-commandBuffer-parameter]"); + "vkCmdSetTessellationDomainOriginEXT: Invalid commandBuffer " + "[VUID-vkCmdSetTessellationDomainOriginEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->CmdCopyAccelerationStructureKHR(commandBuffer, pInfo); + disp->CmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); } -VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR( +VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + VkBool32 depthClampEnable) { const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCmdCopyAccelerationStructureToMemoryKHR: Invalid commandBuffer " - "[VUID-vkCmdCopyAccelerationStructureToMemoryKHR-commandBuffer-parameter]"); + "vkCmdSetDepthClampEnableEXT: Invalid commandBuffer " + "[VUID-vkCmdSetDepthClampEnableEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->CmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); + disp->CmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); } -VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR( +VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + VkPolygonMode polygonMode) { const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCmdCopyMemoryToAccelerationStructureKHR: Invalid commandBuffer " - "[VUID-vkCmdCopyMemoryToAccelerationStructureKHR-commandBuffer-parameter]"); + "vkCmdSetPolygonModeEXT: Invalid commandBuffer " + "[VUID-vkCmdSetPolygonModeEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->CmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); + disp->CmdSetPolygonModeEXT(commandBuffer, polygonMode); } -VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR( - VkDevice device, - const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); +VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkGetAccelerationStructureDeviceAddressKHR: Invalid device " - "[VUID-vkGetAccelerationStructureDeviceAddressKHR-device-parameter]"); + "vkCmdSetRasterizationSamplesEXT: Invalid commandBuffer " + "[VUID-vkCmdSetRasterizationSamplesEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - return disp->GetAccelerationStructureDeviceAddressKHR(device, pInfo); + disp->CmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); } -VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( +VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery) { + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask) { const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkCmdWriteAccelerationStructuresPropertiesKHR: Invalid commandBuffer " - "[VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commandBuffer-parameter]"); + "vkCmdSetSampleMaskEXT: Invalid commandBuffer " + "[VUID-vkCmdSetSampleMaskEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->CmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + disp->CmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); } -VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR( - VkDevice device, - const VkAccelerationStructureVersionInfoKHR* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); +VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkGetDeviceAccelerationStructureCompatibilityKHR: Invalid device " - "[VUID-vkGetDeviceAccelerationStructureCompatibilityKHR-device-parameter]"); + "vkCmdSetAlphaToCoverageEnableEXT: Invalid commandBuffer " + "[VUID-vkCmdSetAlphaToCoverageEnableEXT-commandBuffer-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } - disp->GetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility); + disp->CmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); } -VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, - const uint32_t* pMaxPrimitiveCounts, - VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { - const VkLayerDispatchTable *disp = loader_get_dispatch(device); +VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); if (NULL == disp) { loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, - "vkGetAccelerationStructureBuildSizesKHR: Invalid device " - "[VUID-vkGetAccelerationStructureBuildSizesKHR-device-parameter]"); + "vkCmdSetAlphaToOneEnableEXT: Invalid commandBuffer " + "[VUID-vkCmdSetAlphaToOneEnableEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetLogicOpEnableEXT: Invalid commandBuffer " + "[VUID-vkCmdSetLogicOpEnableEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetColorBlendEnableEXT: Invalid commandBuffer " + "[VUID-vkCmdSetColorBlendEnableEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetColorBlendEquationEXT: Invalid commandBuffer " + "[VUID-vkCmdSetColorBlendEquationEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetColorWriteMaskEXT: Invalid commandBuffer " + "[VUID-vkCmdSetColorWriteMaskEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetRasterizationStreamEXT: Invalid commandBuffer " + "[VUID-vkCmdSetRasterizationStreamEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetConservativeRasterizationModeEXT: Invalid commandBuffer " + "[VUID-vkCmdSetConservativeRasterizationModeEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetExtraPrimitiveOverestimationSizeEXT: Invalid commandBuffer " + "[VUID-vkCmdSetExtraPrimitiveOverestimationSizeEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetDepthClipEnableEXT: Invalid commandBuffer " + "[VUID-vkCmdSetDepthClipEnableEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetSampleLocationsEnableEXT: Invalid commandBuffer " + "[VUID-vkCmdSetSampleLocationsEnableEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetColorBlendAdvancedEXT: Invalid commandBuffer " + "[VUID-vkCmdSetColorBlendAdvancedEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetProvokingVertexModeEXT: Invalid commandBuffer " + "[VUID-vkCmdSetProvokingVertexModeEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetLineRasterizationModeEXT: Invalid commandBuffer " + "[VUID-vkCmdSetLineRasterizationModeEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetLineStippleEnableEXT: Invalid commandBuffer " + "[VUID-vkCmdSetLineStippleEnableEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetDepthClipNegativeOneToOneEXT: Invalid commandBuffer " + "[VUID-vkCmdSetDepthClipNegativeOneToOneEXT-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetViewportWScalingEnableNV: Invalid commandBuffer " + "[VUID-vkCmdSetViewportWScalingEnableNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetViewportSwizzleNV: Invalid commandBuffer " + "[VUID-vkCmdSetViewportSwizzleNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetCoverageToColorEnableNV: Invalid commandBuffer " + "[VUID-vkCmdSetCoverageToColorEnableNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetCoverageToColorLocationNV: Invalid commandBuffer " + "[VUID-vkCmdSetCoverageToColorLocationNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetCoverageModulationModeNV: Invalid commandBuffer " + "[VUID-vkCmdSetCoverageModulationModeNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetCoverageModulationTableEnableNV: Invalid commandBuffer " + "[VUID-vkCmdSetCoverageModulationTableEnableNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetCoverageModulationTableNV: Invalid commandBuffer " + "[VUID-vkCmdSetCoverageModulationTableNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetShadingRateImageEnableNV: Invalid commandBuffer " + "[VUID-vkCmdSetShadingRateImageEnableNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetRepresentativeFragmentTestEnableNV: Invalid commandBuffer " + "[VUID-vkCmdSetRepresentativeFragmentTestEnableNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); +} + +VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdSetCoverageReductionModeNV: Invalid commandBuffer " + "[VUID-vkCmdSetCoverageReductionModeNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); +} + + +// ---- VK_EXT_shader_module_identifier extension trampoline/terminators + +VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( + VkDevice device, + VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkGetShaderModuleIdentifierEXT: Invalid device " + "[VUID-vkGetShaderModuleIdentifierEXT-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->GetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); +} + +VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkGetShaderModuleCreateInfoIdentifierEXT: Invalid device " + "[VUID-vkGetShaderModuleCreateInfoIdentifierEXT-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->GetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); +} + + +// ---- VK_NV_optical_flow extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) { + const VkLayerInstanceDispatchTable *disp; + VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); + if (VK_NULL_HANDLE == unwrapped_phys_dev) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkGetPhysicalDeviceOpticalFlowImageFormatsNV: Invalid physicalDevice " + "[VUID-vkGetPhysicalDeviceOpticalFlowImageFormatsNV-physicalDevice-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp = loader_get_instance_layer_dispatch(physicalDevice); + return disp->GetPhysicalDeviceOpticalFlowImageFormatsNV(unwrapped_phys_dev, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) { + struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; + struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; + if (NULL == icd_term->dispatch.GetPhysicalDeviceOpticalFlowImageFormatsNV) { + loader_log(icd_term->this_instance, VULKAN_LOADER_ERROR_BIT, 0, + "ICD associated with VkPhysicalDevice does not support GetPhysicalDeviceOpticalFlowImageFormatsNV"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return icd_term->dispatch.GetPhysicalDeviceOpticalFlowImageFormatsNV(phys_dev_term->phys_dev, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCreateOpticalFlowSessionNV: Invalid device " + "[VUID-vkCreateOpticalFlowSessionNV-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->CreateOpticalFlowSessionNV(device, pCreateInfo, pAllocator, pSession); +} + +VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkDestroyOpticalFlowSessionNV: Invalid device " + "[VUID-vkDestroyOpticalFlowSessionNV-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->DestroyOpticalFlowSessionNV(device, session, pAllocator); +} + +VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkBindOpticalFlowSessionImageNV: Invalid device " + "[VUID-vkBindOpticalFlowSessionImageNV-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->BindOpticalFlowSessionImageNV(device, session, bindingPoint, view, layout); +} + +VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdOpticalFlowExecuteNV: Invalid commandBuffer " + "[VUID-vkCmdOpticalFlowExecuteNV-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo); +} + + +// ---- VK_QCOM_tile_properties extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( + VkDevice device, + VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkGetFramebufferTilePropertiesQCOM: Invalid device " + "[VUID-vkGetFramebufferTilePropertiesQCOM-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->GetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties); +} + +VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkGetDynamicRenderingTilePropertiesQCOM: Invalid device " + "[VUID-vkGetDynamicRenderingTilePropertiesQCOM-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->GetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties); +} + + +// ---- VK_KHR_acceleration_structure extension trampoline/terminators + +VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCreateAccelerationStructureKHR: Invalid device " + "[VUID-vkCreateAccelerationStructureKHR-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->CreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); +} + +VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR( + VkDevice device, + VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkDestroyAccelerationStructureKHR: Invalid device " + "[VUID-vkDestroyAccelerationStructureKHR-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->DestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); +} + +VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdBuildAccelerationStructuresKHR: Invalid commandBuffer " + "[VUID-vkCmdBuildAccelerationStructuresKHR-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); +} + +VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkDeviceAddress* pIndirectDeviceAddresses, + const uint32_t* pIndirectStrides, + const uint32_t* const* ppMaxPrimitiveCounts) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdBuildAccelerationStructuresIndirectKHR: Invalid commandBuffer " + "[VUID-vkCmdBuildAccelerationStructuresIndirectKHR-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); +} + +VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkBuildAccelerationStructuresKHR: Invalid device " + "[VUID-vkBuildAccelerationStructuresKHR-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->BuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); +} + +VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCopyAccelerationStructureKHR: Invalid device " + "[VUID-vkCopyAccelerationStructureKHR-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->CopyAccelerationStructureKHR(device, deferredOperation, pInfo); +} + +VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCopyAccelerationStructureToMemoryKHR: Invalid device " + "[VUID-vkCopyAccelerationStructureToMemoryKHR-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->CopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); +} + +VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCopyMemoryToAccelerationStructureKHR: Invalid device " + "[VUID-vkCopyMemoryToAccelerationStructureKHR-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->CopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); +} + +VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR( + VkDevice device, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkWriteAccelerationStructuresPropertiesKHR: Invalid device " + "[VUID-vkWriteAccelerationStructuresPropertiesKHR-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->WriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); +} + +VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdCopyAccelerationStructureKHR: Invalid commandBuffer " + "[VUID-vkCmdCopyAccelerationStructureKHR-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdCopyAccelerationStructureKHR(commandBuffer, pInfo); +} + +VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdCopyAccelerationStructureToMemoryKHR: Invalid commandBuffer " + "[VUID-vkCmdCopyAccelerationStructureToMemoryKHR-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); +} + +VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdCopyMemoryToAccelerationStructureKHR: Invalid commandBuffer " + "[VUID-vkCmdCopyMemoryToAccelerationStructureKHR-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); +} + +VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR( + VkDevice device, + const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkGetAccelerationStructureDeviceAddressKHR: Invalid device " + "[VUID-vkGetAccelerationStructureDeviceAddressKHR-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + return disp->GetAccelerationStructureDeviceAddressKHR(device, pInfo); +} + +VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) { + const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkCmdWriteAccelerationStructuresPropertiesKHR: Invalid commandBuffer " + "[VUID-vkCmdWriteAccelerationStructuresPropertiesKHR-commandBuffer-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->CmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); +} + +VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR( + VkDevice device, + const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkGetDeviceAccelerationStructureCompatibilityKHR: Invalid device " + "[VUID-vkGetDeviceAccelerationStructureCompatibilityKHR-device-parameter]"); + abort(); /* Intentionally fail so user can correct issue. */ + } + disp->GetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility); +} + +VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) { + const VkLayerDispatchTable *disp = loader_get_dispatch(device); + if (NULL == disp) { + loader_log(NULL, VULKAN_LOADER_ERROR_BIT | VULKAN_LOADER_VALIDATION_BIT, 0, + "vkGetAccelerationStructureBuildSizesKHR: Invalid device " + "[VUID-vkGetAccelerationStructureBuildSizesKHR-device-parameter]"); abort(); /* Intentionally fail so user can correct issue. */ } disp->GetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); @@ -8117,6 +8977,12 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *na return true; } + // ---- VK_EXT_device_fault extension commands + if (!strcmp("vkGetDeviceFaultInfoEXT", name)) { + *addr = (void *)GetDeviceFaultInfoEXT; + return true; + } + // ---- VK_NV_acquire_winrt_display extension commands #ifdef VK_USE_PLATFORM_WIN32_KHR if (!strcmp("vkAcquireWinrtDisplayNV", name)) { @@ -8263,6 +9129,64 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *na return true; } + // ---- VK_EXT_opacity_micromap extension commands + if (!strcmp("vkCreateMicromapEXT", name)) { + *addr = (void *)CreateMicromapEXT; + return true; + } + if (!strcmp("vkDestroyMicromapEXT", name)) { + *addr = (void *)DestroyMicromapEXT; + return true; + } + if (!strcmp("vkCmdBuildMicromapsEXT", name)) { + *addr = (void *)CmdBuildMicromapsEXT; + return true; + } + if (!strcmp("vkBuildMicromapsEXT", name)) { + *addr = (void *)BuildMicromapsEXT; + return true; + } + if (!strcmp("vkCopyMicromapEXT", name)) { + *addr = (void *)CopyMicromapEXT; + return true; + } + if (!strcmp("vkCopyMicromapToMemoryEXT", name)) { + *addr = (void *)CopyMicromapToMemoryEXT; + return true; + } + if (!strcmp("vkCopyMemoryToMicromapEXT", name)) { + *addr = (void *)CopyMemoryToMicromapEXT; + return true; + } + if (!strcmp("vkWriteMicromapsPropertiesEXT", name)) { + *addr = (void *)WriteMicromapsPropertiesEXT; + return true; + } + if (!strcmp("vkCmdCopyMicromapEXT", name)) { + *addr = (void *)CmdCopyMicromapEXT; + return true; + } + if (!strcmp("vkCmdCopyMicromapToMemoryEXT", name)) { + *addr = (void *)CmdCopyMicromapToMemoryEXT; + return true; + } + if (!strcmp("vkCmdCopyMemoryToMicromapEXT", name)) { + *addr = (void *)CmdCopyMemoryToMicromapEXT; + return true; + } + if (!strcmp("vkCmdWriteMicromapsPropertiesEXT", name)) { + *addr = (void *)CmdWriteMicromapsPropertiesEXT; + return true; + } + if (!strcmp("vkGetDeviceMicromapCompatibilityEXT", name)) { + *addr = (void *)GetDeviceMicromapCompatibilityEXT; + return true; + } + if (!strcmp("vkGetMicromapBuildSizesEXT", name)) { + *addr = (void *)GetMicromapBuildSizesEXT; + return true; + } + // ---- VK_EXT_pageable_device_local_memory extension commands if (!strcmp("vkSetDeviceMemoryPriorityEXT", name)) { *addr = (void *)SetDeviceMemoryPriorityEXT; @@ -8279,6 +9203,132 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *na return true; } + // ---- VK_EXT_extended_dynamic_state3 extension commands + if (!strcmp("vkCmdSetTessellationDomainOriginEXT", name)) { + *addr = (void *)CmdSetTessellationDomainOriginEXT; + return true; + } + if (!strcmp("vkCmdSetDepthClampEnableEXT", name)) { + *addr = (void *)CmdSetDepthClampEnableEXT; + return true; + } + if (!strcmp("vkCmdSetPolygonModeEXT", name)) { + *addr = (void *)CmdSetPolygonModeEXT; + return true; + } + if (!strcmp("vkCmdSetRasterizationSamplesEXT", name)) { + *addr = (void *)CmdSetRasterizationSamplesEXT; + return true; + } + if (!strcmp("vkCmdSetSampleMaskEXT", name)) { + *addr = (void *)CmdSetSampleMaskEXT; + return true; + } + if (!strcmp("vkCmdSetAlphaToCoverageEnableEXT", name)) { + *addr = (void *)CmdSetAlphaToCoverageEnableEXT; + return true; + } + if (!strcmp("vkCmdSetAlphaToOneEnableEXT", name)) { + *addr = (void *)CmdSetAlphaToOneEnableEXT; + return true; + } + if (!strcmp("vkCmdSetLogicOpEnableEXT", name)) { + *addr = (void *)CmdSetLogicOpEnableEXT; + return true; + } + if (!strcmp("vkCmdSetColorBlendEnableEXT", name)) { + *addr = (void *)CmdSetColorBlendEnableEXT; + return true; + } + if (!strcmp("vkCmdSetColorBlendEquationEXT", name)) { + *addr = (void *)CmdSetColorBlendEquationEXT; + return true; + } + if (!strcmp("vkCmdSetColorWriteMaskEXT", name)) { + *addr = (void *)CmdSetColorWriteMaskEXT; + return true; + } + if (!strcmp("vkCmdSetRasterizationStreamEXT", name)) { + *addr = (void *)CmdSetRasterizationStreamEXT; + return true; + } + if (!strcmp("vkCmdSetConservativeRasterizationModeEXT", name)) { + *addr = (void *)CmdSetConservativeRasterizationModeEXT; + return true; + } + if (!strcmp("vkCmdSetExtraPrimitiveOverestimationSizeEXT", name)) { + *addr = (void *)CmdSetExtraPrimitiveOverestimationSizeEXT; + return true; + } + if (!strcmp("vkCmdSetDepthClipEnableEXT", name)) { + *addr = (void *)CmdSetDepthClipEnableEXT; + return true; + } + if (!strcmp("vkCmdSetSampleLocationsEnableEXT", name)) { + *addr = (void *)CmdSetSampleLocationsEnableEXT; + return true; + } + if (!strcmp("vkCmdSetColorBlendAdvancedEXT", name)) { + *addr = (void *)CmdSetColorBlendAdvancedEXT; + return true; + } + if (!strcmp("vkCmdSetProvokingVertexModeEXT", name)) { + *addr = (void *)CmdSetProvokingVertexModeEXT; + return true; + } + if (!strcmp("vkCmdSetLineRasterizationModeEXT", name)) { + *addr = (void *)CmdSetLineRasterizationModeEXT; + return true; + } + if (!strcmp("vkCmdSetLineStippleEnableEXT", name)) { + *addr = (void *)CmdSetLineStippleEnableEXT; + return true; + } + if (!strcmp("vkCmdSetDepthClipNegativeOneToOneEXT", name)) { + *addr = (void *)CmdSetDepthClipNegativeOneToOneEXT; + return true; + } + if (!strcmp("vkCmdSetViewportWScalingEnableNV", name)) { + *addr = (void *)CmdSetViewportWScalingEnableNV; + return true; + } + if (!strcmp("vkCmdSetViewportSwizzleNV", name)) { + *addr = (void *)CmdSetViewportSwizzleNV; + return true; + } + if (!strcmp("vkCmdSetCoverageToColorEnableNV", name)) { + *addr = (void *)CmdSetCoverageToColorEnableNV; + return true; + } + if (!strcmp("vkCmdSetCoverageToColorLocationNV", name)) { + *addr = (void *)CmdSetCoverageToColorLocationNV; + return true; + } + if (!strcmp("vkCmdSetCoverageModulationModeNV", name)) { + *addr = (void *)CmdSetCoverageModulationModeNV; + return true; + } + if (!strcmp("vkCmdSetCoverageModulationTableEnableNV", name)) { + *addr = (void *)CmdSetCoverageModulationTableEnableNV; + return true; + } + if (!strcmp("vkCmdSetCoverageModulationTableNV", name)) { + *addr = (void *)CmdSetCoverageModulationTableNV; + return true; + } + if (!strcmp("vkCmdSetShadingRateImageEnableNV", name)) { + *addr = (void *)CmdSetShadingRateImageEnableNV; + return true; + } + if (!strcmp("vkCmdSetRepresentativeFragmentTestEnableNV", name)) { + *addr = (void *)CmdSetRepresentativeFragmentTestEnableNV; + return true; + } + if (!strcmp("vkCmdSetCoverageReductionModeNV", name)) { + *addr = (void *)CmdSetCoverageReductionModeNV; + return true; + } + // ---- VK_EXT_shader_module_identifier extension commands if (!strcmp("vkGetShaderModuleIdentifierEXT", name)) { *addr = (void *)GetShaderModuleIdentifierEXT; @@ -8289,6 +9339,28 @@ bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *na return true; } + // ---- VK_NV_optical_flow extension commands + if (!strcmp("vkGetPhysicalDeviceOpticalFlowImageFormatsNV", name)) { + *addr = (void *)GetPhysicalDeviceOpticalFlowImageFormatsNV; + return true; + } + if (!strcmp("vkCreateOpticalFlowSessionNV", name)) { + *addr = (void *)CreateOpticalFlowSessionNV; + return true; + } + if (!strcmp("vkDestroyOpticalFlowSessionNV", name)) { + *addr = (void *)DestroyOpticalFlowSessionNV; + return true; + } + if (!strcmp("vkBindOpticalFlowSessionImageNV", name)) { + *addr = (void *)BindOpticalFlowSessionImageNV; + return true; + } + if (!strcmp("vkCmdOpticalFlowExecuteNV", name)) { + *addr = (void *)CmdOpticalFlowExecuteNV; + return true; + } + // ---- VK_QCOM_tile_properties extension commands if (!strcmp("vkGetFramebufferTilePropertiesQCOM", name)) { *addr = (void *)GetFramebufferTilePropertiesQCOM; @@ -8767,6 +9839,9 @@ const VkLayerInstanceDispatchTable instance_disp = { #ifdef VK_USE_PLATFORM_SCREEN_QNX .GetPhysicalDeviceScreenPresentationSupportQNX = terminator_GetPhysicalDeviceScreenPresentationSupportQNX, #endif // VK_USE_PLATFORM_SCREEN_QNX + + // ---- VK_NV_optical_flow extension commands + .GetPhysicalDeviceOpticalFlowImageFormatsNV = terminator_GetPhysicalDeviceOpticalFlowImageFormatsNV, }; // A null-terminated list of all of the instance extensions supported by the loader. diff --git a/loader/generated/vk_loader_extensions.h b/loader/generated/vk_loader_extensions.h index 83c9fd98a..c0bcfa877 100644 --- a/loader/generated/vk_loader_extensions.h +++ b/loader/generated/vk_loader_extensions.h @@ -471,6 +471,9 @@ struct loader_icd_term_dispatch { #ifdef VK_USE_PLATFORM_SCREEN_QNX PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX GetPhysicalDeviceScreenPresentationSupportQNX; #endif // VK_USE_PLATFORM_SCREEN_QNX + + // ---- VK_NV_optical_flow extension commands + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV GetPhysicalDeviceOpticalFlowImageFormatsNV; }; struct loader_instance_extension_enables { diff --git a/loader/generated/vk_object_types.h b/loader/generated/vk_object_types.h index 823193b87..5c18a2ca2 100644 --- a/loader/generated/vk_object_types.h +++ b/loader/generated/vk_object_types.h @@ -81,8 +81,10 @@ typedef enum VulkanObjectType { kVulkanObjectTypePerformanceConfigurationINTEL = 42, kVulkanObjectTypeIndirectCommandsLayoutNV = 43, kVulkanObjectTypeBufferCollectionFUCHSIA = 44, - kVulkanObjectTypeAccelerationStructureKHR = 45, - kVulkanObjectTypeMax = 46, + kVulkanObjectTypeMicromapEXT = 45, + kVulkanObjectTypeOpticalFlowSessionNV = 46, + kVulkanObjectTypeAccelerationStructureKHR = 47, + kVulkanObjectTypeMax = 48, // Aliases for backwards compatibilty of "promoted" types kVulkanObjectTypeDescriptorUpdateTemplateKHR = kVulkanObjectTypeDescriptorUpdateTemplate, kVulkanObjectTypeSamplerYcbcrConversionKHR = kVulkanObjectTypeSamplerYcbcrConversion, @@ -136,6 +138,8 @@ static const char * const object_string[kVulkanObjectTypeMax] = { "PerformanceConfigurationINTEL", "IndirectCommandsLayoutNV", "BufferCollectionFUCHSIA", + "MicromapEXT", + "OpticalFlowSessionNV", "AccelerationStructureKHR", }; @@ -186,6 +190,8 @@ const VkDebugReportObjectTypeEXT get_debug_report_enum[] = { VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypePerformanceConfigurationINTEL VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeIndirectCommandsLayoutNV VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT, // kVulkanObjectTypeBufferCollectionFUCHSIA + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeMicromapEXT + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeOpticalFlowSessionNV VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT, // kVulkanObjectTypeAccelerationStructureKHR }; @@ -236,6 +242,8 @@ const VkObjectType get_object_type_enum[] = { VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, // kVulkanObjectTypePerformanceConfigurationINTEL VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV, // kVulkanObjectTypeIndirectCommandsLayoutNV VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA, // kVulkanObjectTypeBufferCollectionFUCHSIA + VK_OBJECT_TYPE_MICROMAP_EXT, // kVulkanObjectTypeMicromapEXT + VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV, // kVulkanObjectTypeOpticalFlowSessionNV VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR, // kVulkanObjectTypeAccelerationStructureKHR }; diff --git a/scripts/known_good.json b/scripts/known_good.json index 76ece831b..8d5bd1235 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": "googletest", -- cgit v1.2.3