From e056c12782125c3ad5876f3ac7528d9889808675 Mon Sep 17 00:00:00 2001 From: Chris Forbes Date: Thu, 22 Jul 2021 13:54:04 -0700 Subject: Inline GetPhysicalDeviceProperties2 into QueryPresentationProperties In general, we implement the 1.1 instance / physical device API as preferring to call the native 1.1 function if available; otherwise falling back to calling the equivalent GPDP2 function. If the underlying driver supports *neither* then any caller of that function has already invoked UB by calling it and so falling over is acceptable. Unfortunately, the loader itself does call vkGetPhysicalDeviceProperties2 in one case, regardless of what the driver may support, in order to determine whether the platform's swapchain implementation should expose some features. On a 1.0 driver without the GPDP2 extension, this caused trouble. As a slight further wrinkle, vkGetPhysicalDeviceProperties2 "cannot fail", making propagating a failure back up through the loader annoying. As a workaround, inline the calls to GetPhysicalDeviceProperties2 and GetPhysicalDeviceProperties2KHR into QueryPresentationProperties, where we can handle our one special case of both function pointers being missing but behavior being defined. Bug: b/192130684 Change-Id: Iff2bae98b7931bed80fafd895cf57061becabd8d --- vulkan/libvulkan/driver.cpp | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index d7fdab5586..cf774fd9b8 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -979,6 +979,8 @@ VkResult EnumerateInstanceExtensionProperties( void QueryPresentationProperties( VkPhysicalDevice physicalDevice, VkPhysicalDevicePresentationPropertiesANDROID* presentation_properties) { + ATRACE_CALL(); + // Request the android-specific presentation properties via GPDP2 VkPhysicalDeviceProperties2 properties = { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, @@ -994,7 +996,17 @@ void QueryPresentationProperties( presentation_properties->pNext = nullptr; presentation_properties->sharedImage = VK_FALSE; - GetPhysicalDeviceProperties2(physicalDevice, &properties); + const auto& driver = GetData(physicalDevice).driver; + + if (driver.GetPhysicalDeviceProperties2) { + // >= 1.1 driver, supports core GPDP2 entrypoint. + driver.GetPhysicalDeviceProperties2(physicalDevice, &properties); + } else if (driver.GetPhysicalDeviceProperties2KHR) { + // Old driver, but may support presentation properties + // if we have the GPDP2 extension. Otherwise, no presentation + // properties supported. + driver.GetPhysicalDeviceProperties2KHR(physicalDevice, &properties); + } } VkResult EnumerateDeviceExtensionProperties( -- cgit v1.2.3-59-g8ed1b From fa7af492359030e28391e1a13d7b9749057d3603 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Tue, 20 Jul 2021 17:40:24 -0600 Subject: Change Vulkan API to 1.2 The commit changes the platform code to support Vulkan 1.2. Bug: 191881132 Test: build Change-Id: I6e71a84b85874a71031734004b8e44ee0ea7446f --- vulkan/libvulkan/api.cpp | 2 +- vulkan/libvulkan/driver.cpp | 8 ++++++-- vulkan/nulldrv/null_driver.cpp | 2 +- 3 files changed, 8 insertions(+), 4 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/api.cpp b/vulkan/libvulkan/api.cpp index fa3b2601a4..9ecc5687cc 100644 --- a/vulkan/libvulkan/api.cpp +++ b/vulkan/libvulkan/api.cpp @@ -1473,7 +1473,7 @@ VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) { if (!EnsureInitialized()) return VK_ERROR_OUT_OF_HOST_MEMORY; - *pApiVersion = VK_API_VERSION_1_1; + *pApiVersion = VK_API_VERSION_1_2; return VK_SUCCESS; } diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index cf774fd9b8..ffc7c94566 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -365,7 +365,7 @@ CreateInfoWrapper::CreateInfoWrapper(const VkInstanceCreateInfo& create_info, const VkAllocationCallbacks& allocator) : is_instance_(true), allocator_(allocator), - loader_api_version_(VK_API_VERSION_1_1), + loader_api_version_(VK_API_VERSION_1_2), icd_api_version_(icd_api_version), physical_dev_(VK_NULL_HANDLE), instance_info_(create_info), @@ -377,7 +377,7 @@ CreateInfoWrapper::CreateInfoWrapper(VkPhysicalDevice physical_dev, const VkAllocationCallbacks& allocator) : is_instance_(false), allocator_(allocator), - loader_api_version_(VK_API_VERSION_1_1), + loader_api_version_(VK_API_VERSION_1_2), icd_api_version_(icd_api_version), physical_dev_(physical_dev), dev_info_(create_info), @@ -519,6 +519,10 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { is_instance_ ? loader_api_version_ : std::min(icd_api_version_, loader_api_version_); switch (api_version) { + case VK_API_VERSION_1_2: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_2); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_2); + [[clang::fallthrough]]; case VK_API_VERSION_1_1: hook_extensions_.set(ProcHook::EXTENSION_CORE_1_1); hal_extensions_.set(ProcHook::EXTENSION_CORE_1_1); diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp index b94233b24a..ddc5cbd77f 100644 --- a/vulkan/nulldrv/null_driver.cpp +++ b/vulkan/nulldrv/null_driver.cpp @@ -260,7 +260,7 @@ namespace null_driver { VKAPI_ATTR VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) { - *pApiVersion = VK_API_VERSION_1_1; + *pApiVersion = VK_API_VERSION_1_2; return VK_SUCCESS; } -- cgit v1.2.3-59-g8ed1b From b68a2251024524f64447dc858aa3f017e07fdf78 Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Mon, 23 Aug 2021 16:37:18 +0000 Subject: Deprecate old VK_* defines Bug: 191881132 Test: build Change-Id: If7ff23e465b54258c9e2445981cbc11cbe14e174 --- vulkan/libvulkan/driver.cpp | 4 ++-- vulkan/nulldrv/null_driver.cpp | 4 ++-- vulkan/vkjson/vkjson.cc | 4 ++-- vulkan/vkjson/vkjson.h | 8 -------- 4 files changed, 6 insertions(+), 14 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index ffc7c94566..648353ee1d 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -1115,7 +1115,7 @@ VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, if (result != VK_SUCCESS) return result; - icd_api_version ^= VK_VERSION_PATCH(icd_api_version); + icd_api_version ^= VK_API_VERSION_PATCH(icd_api_version); } CreateInfoWrapper wrapper(*pCreateInfo, icd_api_version, data_allocator); @@ -1199,7 +1199,7 @@ VkResult CreateDevice(VkPhysicalDevice physicalDevice, CreateInfoWrapper wrapper( physicalDevice, *pCreateInfo, - properties.apiVersion ^ VK_VERSION_PATCH(properties.apiVersion), + properties.apiVersion ^ VK_API_VERSION_PATCH(properties.apiVersion), data_allocator); VkResult result = wrapper.Validate(); if (result != VK_SUCCESS) diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp index ddc5cbd77f..a9f37e56cf 100644 --- a/vulkan/nulldrv/null_driver.cpp +++ b/vulkan/nulldrv/null_driver.cpp @@ -397,8 +397,8 @@ VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice /*gpu*/, void GetPhysicalDeviceProperties(VkPhysicalDevice, VkPhysicalDeviceProperties* properties) { - properties->apiVersion = VK_MAKE_VERSION(1, 0, VK_HEADER_VERSION); - properties->driverVersion = VK_MAKE_VERSION(0, 0, 1); + properties->apiVersion = VK_MAKE_API_VERSION(0, 1, 2, VK_HEADER_VERSION); + properties->driverVersion = VK_MAKE_API_VERSION(0, 0, 0, 1); properties->vendorID = 0; properties->deviceID = 0; properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER; diff --git a/vulkan/vkjson/vkjson.cc b/vulkan/vkjson/vkjson.cc index 438e5dd10d..bdb76484d0 100644 --- a/vulkan/vkjson/vkjson.cc +++ b/vulkan/vkjson/vkjson.cc @@ -841,7 +841,7 @@ template inline bool Iterate(Visitor* visitor, VkJsonDevice* device) { bool ret = true; switch (device->properties.apiVersion ^ - VK_VERSION_PATCH(device->properties.apiVersion)) { + VK_API_VERSION_PATCH(device->properties.apiVersion)) { case VK_API_VERSION_1_2: FALLTHROUGH_INTENDED; case VK_API_VERSION_1_1: @@ -897,7 +897,7 @@ inline bool Iterate(Visitor* visitor, VkJsonDevice* device) { template inline bool Iterate(Visitor* visitor, VkJsonInstance* instance) { bool ret = true; - switch (instance->api_version ^ VK_VERSION_PATCH(instance->api_version)) { + switch (instance->api_version ^ VK_API_VERSION_PATCH(instance->api_version)) { case VK_API_VERSION_1_2: FALLTHROUGH_INTENDED; case VK_API_VERSION_1_1: diff --git a/vulkan/vkjson/vkjson.h b/vulkan/vkjson/vkjson.h index 52e7bee288..aca1d6085e 100644 --- a/vulkan/vkjson/vkjson.h +++ b/vulkan/vkjson/vkjson.h @@ -33,14 +33,6 @@ #undef max #endif -#ifndef VK_API_VERSION_1_0 -#define VK_API_VERSION_1_0 VK_MAKE_VERSION(1, 0, 0) -#endif - -#ifndef VK_API_VERSION_1_1 -#define VK_API_VERSION_1_1 VK_MAKE_VERSION(1, 1, 0) -#endif - /* * Annotation to tell clang that we intend to fall through from one case to * another in a switch. Sourced from android-base/macros.h. -- cgit v1.2.3-59-g8ed1b From b700ae8ceeed33b876a6e4676ac0f05bbdf9be78 Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Mon, 27 Sep 2021 04:50:04 +0000 Subject: Vulkan: update the loader for vulkan-headers v1.3.197 Bug: 191881132 Test: build Change-Id: Ie9e13d64a438d895f92e826e693477d508200054 --- vulkan/libvulkan/api_gen.cpp | 444 +++++++++++++++++++++++++++++++++++++ vulkan/libvulkan/api_gen.h | 37 ++++ vulkan/libvulkan/driver.cpp | 2 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/nulldrv/null_driver_gen.cpp | 37 ++++ vulkan/nulldrv/null_driver_gen.h | 37 ++++ 6 files changed, 558 insertions(+) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/api_gen.cpp b/vulkan/libvulkan/api_gen.cpp index 33401d24d6..eb9fc477e3 100644 --- a/vulkan/libvulkan/api_gen.cpp +++ b/vulkan/libvulkan/api_gen.cpp @@ -179,6 +179,7 @@ bool InitDispatchTable( INIT_PROC(false, instance, GetPhysicalDeviceExternalFenceProperties); INIT_PROC(false, instance, EnumeratePhysicalDeviceGroups); INIT_PROC_EXT(KHR_swapchain, false, instance, GetPhysicalDevicePresentRectanglesKHR); + INIT_PROC(false, instance, GetPhysicalDeviceToolProperties); // clang-format on return success; @@ -334,6 +335,9 @@ bool InitDispatchTable( INIT_PROC(false, dev, GetBufferMemoryRequirements2); INIT_PROC(false, dev, GetImageMemoryRequirements2); INIT_PROC(false, dev, GetImageSparseMemoryRequirements2); + INIT_PROC(false, dev, GetDeviceBufferMemoryRequirements); + INIT_PROC(false, dev, GetDeviceImageMemoryRequirements); + INIT_PROC(false, dev, GetDeviceImageSparseMemoryRequirements); INIT_PROC(false, dev, CreateSamplerYcbcrConversion); INIT_PROC(false, dev, DestroySamplerYcbcrConversion); INIT_PROC(false, dev, GetDeviceQueue2); @@ -352,6 +356,39 @@ bool InitDispatchTable( INIT_PROC(false, dev, GetBufferOpaqueCaptureAddress); INIT_PROC(false, dev, GetBufferDeviceAddress); INIT_PROC(false, dev, GetDeviceMemoryOpaqueCaptureAddress); + INIT_PROC(false, dev, CmdSetCullMode); + INIT_PROC(false, dev, CmdSetFrontFace); + INIT_PROC(false, dev, CmdSetPrimitiveTopology); + INIT_PROC(false, dev, CmdSetViewportWithCount); + INIT_PROC(false, dev, CmdSetScissorWithCount); + INIT_PROC(false, dev, CmdBindVertexBuffers2); + INIT_PROC(false, dev, CmdSetDepthTestEnable); + INIT_PROC(false, dev, CmdSetDepthWriteEnable); + INIT_PROC(false, dev, CmdSetDepthCompareOp); + INIT_PROC(false, dev, CmdSetDepthBoundsTestEnable); + INIT_PROC(false, dev, CmdSetStencilTestEnable); + INIT_PROC(false, dev, CmdSetStencilOp); + INIT_PROC(false, dev, CmdSetRasterizerDiscardEnable); + INIT_PROC(false, dev, CmdSetDepthBiasEnable); + INIT_PROC(false, dev, CmdSetPrimitiveRestartEnable); + INIT_PROC(false, dev, CreatePrivateDataSlot); + INIT_PROC(false, dev, DestroyPrivateDataSlot); + INIT_PROC(false, dev, SetPrivateData); + INIT_PROC(false, dev, GetPrivateData); + INIT_PROC(false, dev, CmdCopyBuffer2); + INIT_PROC(false, dev, CmdCopyImage2); + INIT_PROC(false, dev, CmdBlitImage2); + INIT_PROC(false, dev, CmdCopyBufferToImage2); + INIT_PROC(false, dev, CmdCopyImageToBuffer2); + INIT_PROC(false, dev, CmdResolveImage2); + INIT_PROC(false, dev, CmdSetEvent2); + INIT_PROC(false, dev, CmdResetEvent2); + INIT_PROC(false, dev, CmdWaitEvents2); + INIT_PROC(false, dev, CmdPipelineBarrier2); + INIT_PROC(false, dev, QueueSubmit2); + INIT_PROC(false, dev, CmdWriteTimestamp2); + INIT_PROC(false, dev, CmdBeginRendering); + INIT_PROC(false, dev, CmdEndRendering); // clang-format on return success; @@ -530,6 +567,9 @@ VKAPI_ATTR void UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR void GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); @@ -548,6 +588,40 @@ VKAPI_ATTR void CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuf VKAPI_ATTR uint64_t GetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); VKAPI_ATTR VkDeviceAddress GetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); VKAPI_ATTR uint64_t GetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +VKAPI_ATTR VkResult GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +VKAPI_ATTR void CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +VKAPI_ATTR void CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +VKAPI_ATTR void CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +VKAPI_ATTR void CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +VKAPI_ATTR void CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +VKAPI_ATTR void CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +VKAPI_ATTR void CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +VKAPI_ATTR void CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +VKAPI_ATTR void CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +VKAPI_ATTR void CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +VKAPI_ATTR void CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +VKAPI_ATTR void CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +VKAPI_ATTR void CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +VKAPI_ATTR void CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +VKAPI_ATTR void CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +VKAPI_ATTR VkResult CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +VKAPI_ATTR void DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +VKAPI_ATTR void GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +VKAPI_ATTR void CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +VKAPI_ATTR void CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +VKAPI_ATTR void CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +VKAPI_ATTR void CmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +VKAPI_ATTR void CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +VKAPI_ATTR void CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +VKAPI_ATTR void CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +VKAPI_ATTR void CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +VKAPI_ATTR void CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +VKAPI_ATTR void CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +VKAPI_ATTR VkResult QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +VKAPI_ATTR void CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo); +VKAPI_ATTR void CmdEndRendering(VkCommandBuffer commandBuffer); VKAPI_ATTR VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { return GetData(instance).dispatch.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); @@ -625,6 +699,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pNa "vkGetPhysicalDeviceSurfaceFormatsKHR", "vkGetPhysicalDeviceSurfacePresentModesKHR", "vkGetPhysicalDeviceSurfaceSupportKHR", + "vkGetPhysicalDeviceToolProperties", "vkGetPhysicalDeviceToolPropertiesEXT", "vkGetPhysicalDeviceVideoCapabilitiesKHR", "vkGetPhysicalDeviceVideoFormatPropertiesKHR", @@ -680,18 +755,25 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkCmdBeginQuery", reinterpret_cast(CmdBeginQuery) }, { "vkCmdBeginRenderPass", reinterpret_cast(CmdBeginRenderPass) }, { "vkCmdBeginRenderPass2", reinterpret_cast(CmdBeginRenderPass2) }, + { "vkCmdBeginRendering", reinterpret_cast(CmdBeginRendering) }, { "vkCmdBindDescriptorSets", reinterpret_cast(CmdBindDescriptorSets) }, { "vkCmdBindIndexBuffer", reinterpret_cast(CmdBindIndexBuffer) }, { "vkCmdBindPipeline", reinterpret_cast(CmdBindPipeline) }, { "vkCmdBindVertexBuffers", reinterpret_cast(CmdBindVertexBuffers) }, + { "vkCmdBindVertexBuffers2", reinterpret_cast(CmdBindVertexBuffers2) }, { "vkCmdBlitImage", reinterpret_cast(CmdBlitImage) }, + { "vkCmdBlitImage2", reinterpret_cast(CmdBlitImage2) }, { "vkCmdClearAttachments", reinterpret_cast(CmdClearAttachments) }, { "vkCmdClearColorImage", reinterpret_cast(CmdClearColorImage) }, { "vkCmdClearDepthStencilImage", reinterpret_cast(CmdClearDepthStencilImage) }, { "vkCmdCopyBuffer", reinterpret_cast(CmdCopyBuffer) }, + { "vkCmdCopyBuffer2", reinterpret_cast(CmdCopyBuffer2) }, { "vkCmdCopyBufferToImage", reinterpret_cast(CmdCopyBufferToImage) }, + { "vkCmdCopyBufferToImage2", reinterpret_cast(CmdCopyBufferToImage2) }, { "vkCmdCopyImage", reinterpret_cast(CmdCopyImage) }, + { "vkCmdCopyImage2", reinterpret_cast(CmdCopyImage2) }, { "vkCmdCopyImageToBuffer", reinterpret_cast(CmdCopyImageToBuffer) }, + { "vkCmdCopyImageToBuffer2", reinterpret_cast(CmdCopyImageToBuffer2) }, { "vkCmdCopyQueryPoolResults", reinterpret_cast(CmdCopyQueryPoolResults) }, { "vkCmdDispatch", reinterpret_cast(CmdDispatch) }, { "vkCmdDispatchBase", reinterpret_cast(CmdDispatchBase) }, @@ -705,29 +787,50 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkCmdEndQuery", reinterpret_cast(CmdEndQuery) }, { "vkCmdEndRenderPass", reinterpret_cast(CmdEndRenderPass) }, { "vkCmdEndRenderPass2", reinterpret_cast(CmdEndRenderPass2) }, + { "vkCmdEndRendering", reinterpret_cast(CmdEndRendering) }, { "vkCmdExecuteCommands", reinterpret_cast(CmdExecuteCommands) }, { "vkCmdFillBuffer", reinterpret_cast(CmdFillBuffer) }, { "vkCmdNextSubpass", reinterpret_cast(CmdNextSubpass) }, { "vkCmdNextSubpass2", reinterpret_cast(CmdNextSubpass2) }, { "vkCmdPipelineBarrier", reinterpret_cast(CmdPipelineBarrier) }, + { "vkCmdPipelineBarrier2", reinterpret_cast(CmdPipelineBarrier2) }, { "vkCmdPushConstants", reinterpret_cast(CmdPushConstants) }, { "vkCmdResetEvent", reinterpret_cast(CmdResetEvent) }, + { "vkCmdResetEvent2", reinterpret_cast(CmdResetEvent2) }, { "vkCmdResetQueryPool", reinterpret_cast(CmdResetQueryPool) }, { "vkCmdResolveImage", reinterpret_cast(CmdResolveImage) }, + { "vkCmdResolveImage2", reinterpret_cast(CmdResolveImage2) }, { "vkCmdSetBlendConstants", reinterpret_cast(CmdSetBlendConstants) }, + { "vkCmdSetCullMode", reinterpret_cast(CmdSetCullMode) }, { "vkCmdSetDepthBias", reinterpret_cast(CmdSetDepthBias) }, + { "vkCmdSetDepthBiasEnable", reinterpret_cast(CmdSetDepthBiasEnable) }, { "vkCmdSetDepthBounds", reinterpret_cast(CmdSetDepthBounds) }, + { "vkCmdSetDepthBoundsTestEnable", reinterpret_cast(CmdSetDepthBoundsTestEnable) }, + { "vkCmdSetDepthCompareOp", reinterpret_cast(CmdSetDepthCompareOp) }, + { "vkCmdSetDepthTestEnable", reinterpret_cast(CmdSetDepthTestEnable) }, + { "vkCmdSetDepthWriteEnable", reinterpret_cast(CmdSetDepthWriteEnable) }, { "vkCmdSetDeviceMask", reinterpret_cast(CmdSetDeviceMask) }, { "vkCmdSetEvent", reinterpret_cast(CmdSetEvent) }, + { "vkCmdSetEvent2", reinterpret_cast(CmdSetEvent2) }, + { "vkCmdSetFrontFace", reinterpret_cast(CmdSetFrontFace) }, { "vkCmdSetLineWidth", reinterpret_cast(CmdSetLineWidth) }, + { "vkCmdSetPrimitiveRestartEnable", reinterpret_cast(CmdSetPrimitiveRestartEnable) }, + { "vkCmdSetPrimitiveTopology", reinterpret_cast(CmdSetPrimitiveTopology) }, + { "vkCmdSetRasterizerDiscardEnable", reinterpret_cast(CmdSetRasterizerDiscardEnable) }, { "vkCmdSetScissor", reinterpret_cast(CmdSetScissor) }, + { "vkCmdSetScissorWithCount", reinterpret_cast(CmdSetScissorWithCount) }, { "vkCmdSetStencilCompareMask", reinterpret_cast(CmdSetStencilCompareMask) }, + { "vkCmdSetStencilOp", reinterpret_cast(CmdSetStencilOp) }, { "vkCmdSetStencilReference", reinterpret_cast(CmdSetStencilReference) }, + { "vkCmdSetStencilTestEnable", reinterpret_cast(CmdSetStencilTestEnable) }, { "vkCmdSetStencilWriteMask", reinterpret_cast(CmdSetStencilWriteMask) }, { "vkCmdSetViewport", reinterpret_cast(CmdSetViewport) }, + { "vkCmdSetViewportWithCount", reinterpret_cast(CmdSetViewportWithCount) }, { "vkCmdUpdateBuffer", reinterpret_cast(CmdUpdateBuffer) }, { "vkCmdWaitEvents", reinterpret_cast(CmdWaitEvents) }, + { "vkCmdWaitEvents2", reinterpret_cast(CmdWaitEvents2) }, { "vkCmdWriteTimestamp", reinterpret_cast(CmdWriteTimestamp) }, + { "vkCmdWriteTimestamp2", reinterpret_cast(CmdWriteTimestamp2) }, { "vkCreateBuffer", reinterpret_cast(CreateBuffer) }, { "vkCreateBufferView", reinterpret_cast(CreateBufferView) }, { "vkCreateCommandPool", reinterpret_cast(CreateCommandPool) }, @@ -745,6 +848,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkCreateInstance", nullptr }, { "vkCreatePipelineCache", reinterpret_cast(CreatePipelineCache) }, { "vkCreatePipelineLayout", reinterpret_cast(CreatePipelineLayout) }, + { "vkCreatePrivateDataSlot", reinterpret_cast(CreatePrivateDataSlot) }, { "vkCreateQueryPool", reinterpret_cast(CreateQueryPool) }, { "vkCreateRenderPass", reinterpret_cast(CreateRenderPass) }, { "vkCreateRenderPass2", reinterpret_cast(CreateRenderPass2) }, @@ -769,6 +873,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkDestroyPipeline", reinterpret_cast(DestroyPipeline) }, { "vkDestroyPipelineCache", reinterpret_cast(DestroyPipelineCache) }, { "vkDestroyPipelineLayout", reinterpret_cast(DestroyPipelineLayout) }, + { "vkDestroyPrivateDataSlot", reinterpret_cast(DestroyPrivateDataSlot) }, { "vkDestroyQueryPool", reinterpret_cast(DestroyQueryPool) }, { "vkDestroyRenderPass", reinterpret_cast(DestroyRenderPass) }, { "vkDestroySampler", reinterpret_cast(DestroySampler) }, @@ -793,9 +898,12 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkGetBufferMemoryRequirements2", reinterpret_cast(GetBufferMemoryRequirements2) }, { "vkGetBufferOpaqueCaptureAddress", reinterpret_cast(GetBufferOpaqueCaptureAddress) }, { "vkGetDescriptorSetLayoutSupport", reinterpret_cast(GetDescriptorSetLayoutSupport) }, + { "vkGetDeviceBufferMemoryRequirements", reinterpret_cast(GetDeviceBufferMemoryRequirements) }, { "vkGetDeviceGroupPeerMemoryFeatures", reinterpret_cast(GetDeviceGroupPeerMemoryFeatures) }, { "vkGetDeviceGroupPresentCapabilitiesKHR", reinterpret_cast(GetDeviceGroupPresentCapabilitiesKHR) }, { "vkGetDeviceGroupSurfacePresentModesKHR", reinterpret_cast(GetDeviceGroupSurfacePresentModesKHR) }, + { "vkGetDeviceImageMemoryRequirements", reinterpret_cast(GetDeviceImageMemoryRequirements) }, + { "vkGetDeviceImageSparseMemoryRequirements", reinterpret_cast(GetDeviceImageSparseMemoryRequirements) }, { "vkGetDeviceMemoryCommitment", reinterpret_cast(GetDeviceMemoryCommitment) }, { "vkGetDeviceMemoryOpaqueCaptureAddress", reinterpret_cast(GetDeviceMemoryOpaqueCaptureAddress) }, { "vkGetDeviceProcAddr", reinterpret_cast(GetDeviceProcAddr) }, @@ -811,6 +919,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkGetInstanceProcAddr", reinterpret_cast(GetInstanceProcAddr) }, { "vkGetMemoryAndroidHardwareBufferANDROID", reinterpret_cast(GetMemoryAndroidHardwareBufferANDROID) }, { "vkGetPipelineCacheData", reinterpret_cast(GetPipelineCacheData) }, + { "vkGetPrivateData", reinterpret_cast(GetPrivateData) }, { "vkGetQueryPoolResults", reinterpret_cast(GetQueryPoolResults) }, { "vkGetRenderAreaGranularity", reinterpret_cast(GetRenderAreaGranularity) }, { "vkGetSemaphoreCounterValue", reinterpret_cast(GetSemaphoreCounterValue) }, @@ -821,6 +930,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkQueueBindSparse", reinterpret_cast(QueueBindSparse) }, { "vkQueuePresentKHR", reinterpret_cast(QueuePresentKHR) }, { "vkQueueSubmit", reinterpret_cast(QueueSubmit) }, + { "vkQueueSubmit2", reinterpret_cast(QueueSubmit2) }, { "vkQueueWaitIdle", reinterpret_cast(QueueWaitIdle) }, { "vkResetCommandBuffer", reinterpret_cast(ResetCommandBuffer) }, { "vkResetCommandPool", reinterpret_cast(ResetCommandPool) }, @@ -829,6 +939,7 @@ VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const cha { "vkResetFences", reinterpret_cast(ResetFences) }, { "vkResetQueryPool", reinterpret_cast(ResetQueryPool) }, { "vkSetEvent", reinterpret_cast(SetEvent) }, + { "vkSetPrivateData", reinterpret_cast(SetPrivateData) }, { "vkSignalSemaphore", reinterpret_cast(SignalSemaphore) }, { "vkTrimCommandPool", reinterpret_cast(TrimCommandPool) }, { "vkUnmapMemory", reinterpret_cast(UnmapMemory) }, @@ -1515,6 +1626,18 @@ VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImage GetData(device).dispatch.GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } +VKAPI_ATTR void GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + GetData(device).dispatch.GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +VKAPI_ATTR void GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + GetData(device).dispatch.GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +VKAPI_ATTR void GetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + GetData(device).dispatch.GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { return GetData(device).dispatch.CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); } @@ -1587,6 +1710,142 @@ VKAPI_ATTR uint64_t GetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const V return GetData(device).dispatch.GetDeviceMemoryOpaqueCaptureAddress(device, pInfo); } +VKAPI_ATTR VkResult GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { + return GetData(physicalDevice).dispatch.GetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); +} + +VKAPI_ATTR void CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + GetData(commandBuffer).dispatch.CmdSetCullMode(commandBuffer, cullMode); +} + +VKAPI_ATTR void CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + GetData(commandBuffer).dispatch.CmdSetFrontFace(commandBuffer, frontFace); +} + +VKAPI_ATTR void CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + GetData(commandBuffer).dispatch.CmdSetPrimitiveTopology(commandBuffer, primitiveTopology); +} + +VKAPI_ATTR void CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { + GetData(commandBuffer).dispatch.CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); +} + +VKAPI_ATTR void CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { + GetData(commandBuffer).dispatch.CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); +} + +VKAPI_ATTR void CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + GetData(commandBuffer).dispatch.CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} + +VKAPI_ATTR void CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + GetData(commandBuffer).dispatch.CmdSetDepthTestEnable(commandBuffer, depthTestEnable); +} + +VKAPI_ATTR void CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + GetData(commandBuffer).dispatch.CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); +} + +VKAPI_ATTR void CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + GetData(commandBuffer).dispatch.CmdSetDepthCompareOp(commandBuffer, depthCompareOp); +} + +VKAPI_ATTR void CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + GetData(commandBuffer).dispatch.CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); +} + +VKAPI_ATTR void CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + GetData(commandBuffer).dispatch.CmdSetStencilTestEnable(commandBuffer, stencilTestEnable); +} + +VKAPI_ATTR void CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + GetData(commandBuffer).dispatch.CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} + +VKAPI_ATTR void CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + GetData(commandBuffer).dispatch.CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); +} + +VKAPI_ATTR void CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + GetData(commandBuffer).dispatch.CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); +} + +VKAPI_ATTR void CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + GetData(commandBuffer).dispatch.CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); +} + +VKAPI_ATTR VkResult CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { + return GetData(device).dispatch.CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); +} + +VKAPI_ATTR void DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { + GetData(device).dispatch.DestroyPrivateDataSlot(device, privateDataSlot, pAllocator); +} + +VKAPI_ATTR VkResult SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { + return GetData(device).dispatch.SetPrivateData(device, objectType, objectHandle, privateDataSlot, data); +} + +VKAPI_ATTR void GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + GetData(device).dispatch.GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); +} + +VKAPI_ATTR void CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + GetData(commandBuffer).dispatch.CmdCopyBuffer2(commandBuffer, pCopyBufferInfo); +} + +VKAPI_ATTR void CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + GetData(commandBuffer).dispatch.CmdCopyImage2(commandBuffer, pCopyImageInfo); +} + +VKAPI_ATTR void CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + GetData(commandBuffer).dispatch.CmdBlitImage2(commandBuffer, pBlitImageInfo); +} + +VKAPI_ATTR void CmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + GetData(commandBuffer).dispatch.CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); +} + +VKAPI_ATTR void CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + GetData(commandBuffer).dispatch.CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); +} + +VKAPI_ATTR void CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + GetData(commandBuffer).dispatch.CmdResolveImage2(commandBuffer, pResolveImageInfo); +} + +VKAPI_ATTR void CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { + GetData(commandBuffer).dispatch.CmdSetEvent2(commandBuffer, event, pDependencyInfo); +} + +VKAPI_ATTR void CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + GetData(commandBuffer).dispatch.CmdResetEvent2(commandBuffer, event, stageMask); +} + +VKAPI_ATTR void CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { + GetData(commandBuffer).dispatch.CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); +} + +VKAPI_ATTR void CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + GetData(commandBuffer).dispatch.CmdPipelineBarrier2(commandBuffer, pDependencyInfo); +} + +VKAPI_ATTR VkResult QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { + return GetData(queue).dispatch.QueueSubmit2(queue, submitCount, pSubmits, fence); +} + +VKAPI_ATTR void CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { + GetData(commandBuffer).dispatch.CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); +} + +VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) { + GetData(commandBuffer).dispatch.CmdBeginRendering(commandBuffer, pRenderingInfo); +} + +VKAPI_ATTR void CmdEndRendering(VkCommandBuffer commandBuffer) { + GetData(commandBuffer).dispatch.CmdEndRendering(commandBuffer); +} + } // anonymous namespace @@ -2482,6 +2741,21 @@ VKAPI_ATTR void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkIma vulkan::api::GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } +__attribute__((visibility("default"))) +VKAPI_ATTR void vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + vulkan::api::GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) { + vulkan::api::GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) { + vulkan::api::GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + __attribute__((visibility("default"))) VKAPI_ATTR VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) { return vulkan::api::CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); @@ -2572,4 +2846,174 @@ VKAPI_ATTR uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const return vulkan::api::GetDeviceMemoryOpaqueCaptureAddress(device, pInfo); } +__attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkGetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties) { + return vulkan::api::GetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) { + vulkan::api::CmdSetCullMode(commandBuffer, cullMode); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) { + vulkan::api::CmdSetFrontFace(commandBuffer, frontFace); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) { + vulkan::api::CmdSetPrimitiveTopology(commandBuffer, primitiveTopology); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) { + vulkan::api::CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) { + vulkan::api::CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) { + vulkan::api::CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) { + vulkan::api::CmdSetDepthTestEnable(commandBuffer, depthTestEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) { + vulkan::api::CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) { + vulkan::api::CmdSetDepthCompareOp(commandBuffer, depthCompareOp); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) { + vulkan::api::CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) { + vulkan::api::CmdSetStencilTestEnable(commandBuffer, stencilTestEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) { + vulkan::api::CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) { + vulkan::api::CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) { + vulkan::api::CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) { + vulkan::api::CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) { + return vulkan::api::CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) { + vulkan::api::DestroyPrivateDataSlot(device, privateDataSlot, pAllocator); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) { + return vulkan::api::SetPrivateData(device, objectType, objectHandle, privateDataSlot, data); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) { + vulkan::api::GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) { + vulkan::api::CmdCopyBuffer2(commandBuffer, pCopyBufferInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) { + vulkan::api::CmdCopyImage2(commandBuffer, pCopyImageInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) { + vulkan::api::CmdBlitImage2(commandBuffer, pBlitImageInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) { + vulkan::api::CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) { + vulkan::api::CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) { + vulkan::api::CmdResolveImage2(commandBuffer, pResolveImageInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) { + vulkan::api::CmdSetEvent2(commandBuffer, event, pDependencyInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) { + vulkan::api::CmdResetEvent2(commandBuffer, event, stageMask); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) { + vulkan::api::CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) { + vulkan::api::CmdPipelineBarrier2(commandBuffer, pDependencyInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) { + return vulkan::api::QueueSubmit2(queue, submitCount, pSubmits, fence); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) { + vulkan::api::CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) { + vulkan::api::CmdBeginRendering(commandBuffer, pRenderingInfo); +} + +__attribute__((visibility("default"))) +VKAPI_ATTR void vkCmdEndRendering(VkCommandBuffer commandBuffer) { + vulkan::api::CmdEndRendering(commandBuffer); +} + // clang-format on diff --git a/vulkan/libvulkan/api_gen.h b/vulkan/libvulkan/api_gen.h index ad5cc34799..4998018882 100644 --- a/vulkan/libvulkan/api_gen.h +++ b/vulkan/libvulkan/api_gen.h @@ -60,6 +60,7 @@ struct InstanceDispatchTable { PFN_vkGetPhysicalDeviceExternalFenceProperties GetPhysicalDeviceExternalFenceProperties; PFN_vkEnumeratePhysicalDeviceGroups EnumeratePhysicalDeviceGroups; PFN_vkGetPhysicalDevicePresentRectanglesKHR GetPhysicalDevicePresentRectanglesKHR; + PFN_vkGetPhysicalDeviceToolProperties GetPhysicalDeviceToolProperties; // clang-format on }; @@ -207,6 +208,9 @@ struct DeviceDispatchTable { PFN_vkGetBufferMemoryRequirements2 GetBufferMemoryRequirements2; PFN_vkGetImageMemoryRequirements2 GetImageMemoryRequirements2; PFN_vkGetImageSparseMemoryRequirements2 GetImageSparseMemoryRequirements2; + PFN_vkGetDeviceBufferMemoryRequirements GetDeviceBufferMemoryRequirements; + PFN_vkGetDeviceImageMemoryRequirements GetDeviceImageMemoryRequirements; + PFN_vkGetDeviceImageSparseMemoryRequirements GetDeviceImageSparseMemoryRequirements; PFN_vkCreateSamplerYcbcrConversion CreateSamplerYcbcrConversion; PFN_vkDestroySamplerYcbcrConversion DestroySamplerYcbcrConversion; PFN_vkGetDeviceQueue2 GetDeviceQueue2; @@ -225,6 +229,39 @@ struct DeviceDispatchTable { PFN_vkGetBufferOpaqueCaptureAddress GetBufferOpaqueCaptureAddress; PFN_vkGetBufferDeviceAddress GetBufferDeviceAddress; PFN_vkGetDeviceMemoryOpaqueCaptureAddress GetDeviceMemoryOpaqueCaptureAddress; + PFN_vkCmdSetCullMode CmdSetCullMode; + PFN_vkCmdSetFrontFace CmdSetFrontFace; + PFN_vkCmdSetPrimitiveTopology CmdSetPrimitiveTopology; + PFN_vkCmdSetViewportWithCount CmdSetViewportWithCount; + PFN_vkCmdSetScissorWithCount CmdSetScissorWithCount; + PFN_vkCmdBindVertexBuffers2 CmdBindVertexBuffers2; + PFN_vkCmdSetDepthTestEnable CmdSetDepthTestEnable; + PFN_vkCmdSetDepthWriteEnable CmdSetDepthWriteEnable; + PFN_vkCmdSetDepthCompareOp CmdSetDepthCompareOp; + PFN_vkCmdSetDepthBoundsTestEnable CmdSetDepthBoundsTestEnable; + PFN_vkCmdSetStencilTestEnable CmdSetStencilTestEnable; + PFN_vkCmdSetStencilOp CmdSetStencilOp; + PFN_vkCmdSetRasterizerDiscardEnable CmdSetRasterizerDiscardEnable; + PFN_vkCmdSetDepthBiasEnable CmdSetDepthBiasEnable; + PFN_vkCmdSetPrimitiveRestartEnable CmdSetPrimitiveRestartEnable; + PFN_vkCreatePrivateDataSlot CreatePrivateDataSlot; + PFN_vkDestroyPrivateDataSlot DestroyPrivateDataSlot; + PFN_vkSetPrivateData SetPrivateData; + PFN_vkGetPrivateData GetPrivateData; + PFN_vkCmdCopyBuffer2 CmdCopyBuffer2; + PFN_vkCmdCopyImage2 CmdCopyImage2; + PFN_vkCmdBlitImage2 CmdBlitImage2; + PFN_vkCmdCopyBufferToImage2 CmdCopyBufferToImage2; + PFN_vkCmdCopyImageToBuffer2 CmdCopyImageToBuffer2; + PFN_vkCmdResolveImage2 CmdResolveImage2; + PFN_vkCmdSetEvent2 CmdSetEvent2; + PFN_vkCmdResetEvent2 CmdResetEvent2; + PFN_vkCmdWaitEvents2 CmdWaitEvents2; + PFN_vkCmdPipelineBarrier2 CmdPipelineBarrier2; + PFN_vkQueueSubmit2 QueueSubmit2; + PFN_vkCmdWriteTimestamp2 CmdWriteTimestamp2; + PFN_vkCmdBeginRendering CmdBeginRendering; + PFN_vkCmdEndRendering CmdEndRendering; // clang-format on }; diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 648353ee1d..238429f957 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -657,6 +657,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: case ProcHook::EXTENSION_CORE_1_2: + case ProcHook::EXTENSION_CORE_1_3: case ProcHook::EXTENSION_COUNT: // Device and meta extensions. If we ever get here it's a bug in // our code. But enumerating them lets us avoid having a default @@ -711,6 +712,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: case ProcHook::EXTENSION_CORE_1_2: + case ProcHook::EXTENSION_CORE_1_3: case ProcHook::EXTENSION_COUNT: // Instance and meta extensions. If we ever get here it's a bug // in our code. But enumerating them lets us avoid having a diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 047e774004..819f6b211c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -58,6 +58,7 @@ struct ProcHook { EXTENSION_CORE_1_0, EXTENSION_CORE_1_1, EXTENSION_CORE_1_2, + EXTENSION_CORE_1_3, EXTENSION_COUNT, EXTENSION_UNKNOWN, }; diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp index edda12c6f9..f6dcf0900c 100644 --- a/vulkan/nulldrv/null_driver_gen.cpp +++ b/vulkan/nulldrv/null_driver_gen.cpp @@ -68,18 +68,25 @@ const NameProc kInstanceProcs[] = { {"vkCmdBeginQuery", reinterpret_cast(static_cast(CmdBeginQuery))}, {"vkCmdBeginRenderPass", reinterpret_cast(static_cast(CmdBeginRenderPass))}, {"vkCmdBeginRenderPass2", reinterpret_cast(static_cast(CmdBeginRenderPass2))}, + {"vkCmdBeginRendering", reinterpret_cast(static_cast(CmdBeginRendering))}, {"vkCmdBindDescriptorSets", reinterpret_cast(static_cast(CmdBindDescriptorSets))}, {"vkCmdBindIndexBuffer", reinterpret_cast(static_cast(CmdBindIndexBuffer))}, {"vkCmdBindPipeline", reinterpret_cast(static_cast(CmdBindPipeline))}, {"vkCmdBindVertexBuffers", reinterpret_cast(static_cast(CmdBindVertexBuffers))}, + {"vkCmdBindVertexBuffers2", reinterpret_cast(static_cast(CmdBindVertexBuffers2))}, {"vkCmdBlitImage", reinterpret_cast(static_cast(CmdBlitImage))}, + {"vkCmdBlitImage2", reinterpret_cast(static_cast(CmdBlitImage2))}, {"vkCmdClearAttachments", reinterpret_cast(static_cast(CmdClearAttachments))}, {"vkCmdClearColorImage", reinterpret_cast(static_cast(CmdClearColorImage))}, {"vkCmdClearDepthStencilImage", reinterpret_cast(static_cast(CmdClearDepthStencilImage))}, {"vkCmdCopyBuffer", reinterpret_cast(static_cast(CmdCopyBuffer))}, + {"vkCmdCopyBuffer2", reinterpret_cast(static_cast(CmdCopyBuffer2))}, {"vkCmdCopyBufferToImage", reinterpret_cast(static_cast(CmdCopyBufferToImage))}, + {"vkCmdCopyBufferToImage2", reinterpret_cast(static_cast(CmdCopyBufferToImage2))}, {"vkCmdCopyImage", reinterpret_cast(static_cast(CmdCopyImage))}, + {"vkCmdCopyImage2", reinterpret_cast(static_cast(CmdCopyImage2))}, {"vkCmdCopyImageToBuffer", reinterpret_cast(static_cast(CmdCopyImageToBuffer))}, + {"vkCmdCopyImageToBuffer2", reinterpret_cast(static_cast(CmdCopyImageToBuffer2))}, {"vkCmdCopyQueryPoolResults", reinterpret_cast(static_cast(CmdCopyQueryPoolResults))}, {"vkCmdDispatch", reinterpret_cast(static_cast(CmdDispatch))}, {"vkCmdDispatchBase", reinterpret_cast(static_cast(CmdDispatchBase))}, @@ -93,29 +100,50 @@ const NameProc kInstanceProcs[] = { {"vkCmdEndQuery", reinterpret_cast(static_cast(CmdEndQuery))}, {"vkCmdEndRenderPass", reinterpret_cast(static_cast(CmdEndRenderPass))}, {"vkCmdEndRenderPass2", reinterpret_cast(static_cast(CmdEndRenderPass2))}, + {"vkCmdEndRendering", reinterpret_cast(static_cast(CmdEndRendering))}, {"vkCmdExecuteCommands", reinterpret_cast(static_cast(CmdExecuteCommands))}, {"vkCmdFillBuffer", reinterpret_cast(static_cast(CmdFillBuffer))}, {"vkCmdNextSubpass", reinterpret_cast(static_cast(CmdNextSubpass))}, {"vkCmdNextSubpass2", reinterpret_cast(static_cast(CmdNextSubpass2))}, {"vkCmdPipelineBarrier", reinterpret_cast(static_cast(CmdPipelineBarrier))}, + {"vkCmdPipelineBarrier2", reinterpret_cast(static_cast(CmdPipelineBarrier2))}, {"vkCmdPushConstants", reinterpret_cast(static_cast(CmdPushConstants))}, {"vkCmdResetEvent", reinterpret_cast(static_cast(CmdResetEvent))}, + {"vkCmdResetEvent2", reinterpret_cast(static_cast(CmdResetEvent2))}, {"vkCmdResetQueryPool", reinterpret_cast(static_cast(CmdResetQueryPool))}, {"vkCmdResolveImage", reinterpret_cast(static_cast(CmdResolveImage))}, + {"vkCmdResolveImage2", reinterpret_cast(static_cast(CmdResolveImage2))}, {"vkCmdSetBlendConstants", reinterpret_cast(static_cast(CmdSetBlendConstants))}, + {"vkCmdSetCullMode", reinterpret_cast(static_cast(CmdSetCullMode))}, {"vkCmdSetDepthBias", reinterpret_cast(static_cast(CmdSetDepthBias))}, + {"vkCmdSetDepthBiasEnable", reinterpret_cast(static_cast(CmdSetDepthBiasEnable))}, {"vkCmdSetDepthBounds", reinterpret_cast(static_cast(CmdSetDepthBounds))}, + {"vkCmdSetDepthBoundsTestEnable", reinterpret_cast(static_cast(CmdSetDepthBoundsTestEnable))}, + {"vkCmdSetDepthCompareOp", reinterpret_cast(static_cast(CmdSetDepthCompareOp))}, + {"vkCmdSetDepthTestEnable", reinterpret_cast(static_cast(CmdSetDepthTestEnable))}, + {"vkCmdSetDepthWriteEnable", reinterpret_cast(static_cast(CmdSetDepthWriteEnable))}, {"vkCmdSetDeviceMask", reinterpret_cast(static_cast(CmdSetDeviceMask))}, {"vkCmdSetEvent", reinterpret_cast(static_cast(CmdSetEvent))}, + {"vkCmdSetEvent2", reinterpret_cast(static_cast(CmdSetEvent2))}, + {"vkCmdSetFrontFace", reinterpret_cast(static_cast(CmdSetFrontFace))}, {"vkCmdSetLineWidth", reinterpret_cast(static_cast(CmdSetLineWidth))}, + {"vkCmdSetPrimitiveRestartEnable", reinterpret_cast(static_cast(CmdSetPrimitiveRestartEnable))}, + {"vkCmdSetPrimitiveTopology", reinterpret_cast(static_cast(CmdSetPrimitiveTopology))}, + {"vkCmdSetRasterizerDiscardEnable", reinterpret_cast(static_cast(CmdSetRasterizerDiscardEnable))}, {"vkCmdSetScissor", reinterpret_cast(static_cast(CmdSetScissor))}, + {"vkCmdSetScissorWithCount", reinterpret_cast(static_cast(CmdSetScissorWithCount))}, {"vkCmdSetStencilCompareMask", reinterpret_cast(static_cast(CmdSetStencilCompareMask))}, + {"vkCmdSetStencilOp", reinterpret_cast(static_cast(CmdSetStencilOp))}, {"vkCmdSetStencilReference", reinterpret_cast(static_cast(CmdSetStencilReference))}, + {"vkCmdSetStencilTestEnable", reinterpret_cast(static_cast(CmdSetStencilTestEnable))}, {"vkCmdSetStencilWriteMask", reinterpret_cast(static_cast(CmdSetStencilWriteMask))}, {"vkCmdSetViewport", reinterpret_cast(static_cast(CmdSetViewport))}, + {"vkCmdSetViewportWithCount", reinterpret_cast(static_cast(CmdSetViewportWithCount))}, {"vkCmdUpdateBuffer", reinterpret_cast(static_cast(CmdUpdateBuffer))}, {"vkCmdWaitEvents", reinterpret_cast(static_cast(CmdWaitEvents))}, + {"vkCmdWaitEvents2", reinterpret_cast(static_cast(CmdWaitEvents2))}, {"vkCmdWriteTimestamp", reinterpret_cast(static_cast(CmdWriteTimestamp))}, + {"vkCmdWriteTimestamp2", reinterpret_cast(static_cast(CmdWriteTimestamp2))}, {"vkCreateBuffer", reinterpret_cast(static_cast(CreateBuffer))}, {"vkCreateBufferView", reinterpret_cast(static_cast(CreateBufferView))}, {"vkCreateCommandPool", reinterpret_cast(static_cast(CreateCommandPool))}, @@ -134,6 +162,7 @@ const NameProc kInstanceProcs[] = { {"vkCreateInstance", reinterpret_cast(static_cast(CreateInstance))}, {"vkCreatePipelineCache", reinterpret_cast(static_cast(CreatePipelineCache))}, {"vkCreatePipelineLayout", reinterpret_cast(static_cast(CreatePipelineLayout))}, + {"vkCreatePrivateDataSlot", reinterpret_cast(static_cast(CreatePrivateDataSlot))}, {"vkCreateQueryPool", reinterpret_cast(static_cast(CreateQueryPool))}, {"vkCreateRenderPass", reinterpret_cast(static_cast(CreateRenderPass))}, {"vkCreateRenderPass2", reinterpret_cast(static_cast(CreateRenderPass2))}, @@ -159,6 +188,7 @@ const NameProc kInstanceProcs[] = { {"vkDestroyPipeline", reinterpret_cast(static_cast(DestroyPipeline))}, {"vkDestroyPipelineCache", reinterpret_cast(static_cast(DestroyPipelineCache))}, {"vkDestroyPipelineLayout", reinterpret_cast(static_cast(DestroyPipelineLayout))}, + {"vkDestroyPrivateDataSlot", reinterpret_cast(static_cast(DestroyPrivateDataSlot))}, {"vkDestroyQueryPool", reinterpret_cast(static_cast(DestroyQueryPool))}, {"vkDestroyRenderPass", reinterpret_cast(static_cast(DestroyRenderPass))}, {"vkDestroySampler", reinterpret_cast(static_cast(DestroySampler))}, @@ -183,7 +213,10 @@ const NameProc kInstanceProcs[] = { {"vkGetBufferMemoryRequirements2", reinterpret_cast(static_cast(GetBufferMemoryRequirements2))}, {"vkGetBufferOpaqueCaptureAddress", reinterpret_cast(static_cast(GetBufferOpaqueCaptureAddress))}, {"vkGetDescriptorSetLayoutSupport", reinterpret_cast(static_cast(GetDescriptorSetLayoutSupport))}, + {"vkGetDeviceBufferMemoryRequirements", reinterpret_cast(static_cast(GetDeviceBufferMemoryRequirements))}, {"vkGetDeviceGroupPeerMemoryFeatures", reinterpret_cast(static_cast(GetDeviceGroupPeerMemoryFeatures))}, + {"vkGetDeviceImageMemoryRequirements", reinterpret_cast(static_cast(GetDeviceImageMemoryRequirements))}, + {"vkGetDeviceImageSparseMemoryRequirements", reinterpret_cast(static_cast(GetDeviceImageSparseMemoryRequirements))}, {"vkGetDeviceMemoryCommitment", reinterpret_cast(static_cast(GetDeviceMemoryCommitment))}, {"vkGetDeviceMemoryOpaqueCaptureAddress", reinterpret_cast(static_cast(GetDeviceMemoryOpaqueCaptureAddress))}, {"vkGetDeviceProcAddr", reinterpret_cast(static_cast(GetDeviceProcAddr))}, @@ -221,7 +254,9 @@ const NameProc kInstanceProcs[] = { {"vkGetPhysicalDeviceSparseImageFormatProperties", reinterpret_cast(static_cast(GetPhysicalDeviceSparseImageFormatProperties))}, {"vkGetPhysicalDeviceSparseImageFormatProperties2", reinterpret_cast(static_cast(GetPhysicalDeviceSparseImageFormatProperties2))}, {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", reinterpret_cast(static_cast(GetPhysicalDeviceSparseImageFormatProperties2KHR))}, + {"vkGetPhysicalDeviceToolProperties", reinterpret_cast(static_cast(GetPhysicalDeviceToolProperties))}, {"vkGetPipelineCacheData", reinterpret_cast(static_cast(GetPipelineCacheData))}, + {"vkGetPrivateData", reinterpret_cast(static_cast(GetPrivateData))}, {"vkGetQueryPoolResults", reinterpret_cast(static_cast(GetQueryPoolResults))}, {"vkGetRenderAreaGranularity", reinterpret_cast(static_cast(GetRenderAreaGranularity))}, {"vkGetSemaphoreCounterValue", reinterpret_cast(static_cast(GetSemaphoreCounterValue))}, @@ -233,6 +268,7 @@ const NameProc kInstanceProcs[] = { {"vkQueueBindSparse", reinterpret_cast(static_cast(QueueBindSparse))}, {"vkQueueSignalReleaseImageANDROID", reinterpret_cast(static_cast(QueueSignalReleaseImageANDROID))}, {"vkQueueSubmit", reinterpret_cast(static_cast(QueueSubmit))}, + {"vkQueueSubmit2", reinterpret_cast(static_cast(QueueSubmit2))}, {"vkQueueWaitIdle", reinterpret_cast(static_cast(QueueWaitIdle))}, {"vkResetCommandBuffer", reinterpret_cast(static_cast(ResetCommandBuffer))}, {"vkResetCommandPool", reinterpret_cast(static_cast(ResetCommandPool))}, @@ -241,6 +277,7 @@ const NameProc kInstanceProcs[] = { {"vkResetFences", reinterpret_cast(static_cast(ResetFences))}, {"vkResetQueryPool", reinterpret_cast(static_cast(ResetQueryPool))}, {"vkSetEvent", reinterpret_cast(static_cast(SetEvent))}, + {"vkSetPrivateData", reinterpret_cast(static_cast(SetPrivateData))}, {"vkSignalSemaphore", reinterpret_cast(static_cast(SignalSemaphore))}, {"vkTrimCommandPool", reinterpret_cast(static_cast(TrimCommandPool))}, {"vkUnmapMemory", reinterpret_cast(static_cast(UnmapMemory))}, diff --git a/vulkan/nulldrv/null_driver_gen.h b/vulkan/nulldrv/null_driver_gen.h index e59cae925f..315f1dcb08 100644 --- a/vulkan/nulldrv/null_driver_gen.h +++ b/vulkan/nulldrv/null_driver_gen.h @@ -200,6 +200,9 @@ VKAPI_ATTR void UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet VKAPI_ATTR void GetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); VKAPI_ATTR void GetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); VKAPI_ATTR void GetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +VKAPI_ATTR void GetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +VKAPI_ATTR void GetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); VKAPI_ATTR VkResult CreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); VKAPI_ATTR void DestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); VKAPI_ATTR void GetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); @@ -220,6 +223,40 @@ VKAPI_ATTR void CmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuf VKAPI_ATTR uint64_t GetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); VKAPI_ATTR VkDeviceAddress GetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); VKAPI_ATTR uint64_t GetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +VKAPI_ATTR VkResult GetPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +VKAPI_ATTR void CmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +VKAPI_ATTR void CmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +VKAPI_ATTR void CmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +VKAPI_ATTR void CmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +VKAPI_ATTR void CmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +VKAPI_ATTR void CmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +VKAPI_ATTR void CmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +VKAPI_ATTR void CmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +VKAPI_ATTR void CmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +VKAPI_ATTR void CmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +VKAPI_ATTR void CmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +VKAPI_ATTR void CmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +VKAPI_ATTR void CmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +VKAPI_ATTR void CmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +VKAPI_ATTR void CmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +VKAPI_ATTR VkResult CreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +VKAPI_ATTR void DestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +VKAPI_ATTR VkResult SetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +VKAPI_ATTR void GetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +VKAPI_ATTR void CmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +VKAPI_ATTR void CmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +VKAPI_ATTR void CmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +VKAPI_ATTR void CmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +VKAPI_ATTR void CmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +VKAPI_ATTR void CmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +VKAPI_ATTR void CmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +VKAPI_ATTR void CmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +VKAPI_ATTR void CmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +VKAPI_ATTR void CmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +VKAPI_ATTR VkResult QueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +VKAPI_ATTR void CmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +VKAPI_ATTR void CmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo); +VKAPI_ATTR void CmdEndRendering(VkCommandBuffer commandBuffer); // clang-format on } // namespace null_driver -- cgit v1.2.3-59-g8ed1b From 628c41ac1d788cac4310bd62e52323de98b392c9 Mon Sep 17 00:00:00 2001 From: Trevor David Black Date: Mon, 27 Sep 2021 05:07:22 +0000 Subject: Change Vulkan API to 1.3 The commit changes the platform code to support Vulkan 1.3. Bug: 191881132 Test: build Change-Id: I75ed8a0737ef20ff95e4a27ce39cc855d8a1deeb --- vulkan/libvulkan/api.cpp | 2 +- vulkan/libvulkan/driver.cpp | 8 ++++++-- vulkan/nulldrv/null_driver.cpp | 2 +- vulkan/vkjson/vkjson.cc | 4 ++++ 4 files changed, 12 insertions(+), 4 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/api.cpp b/vulkan/libvulkan/api.cpp index 9ecc5687cc..c335e2a952 100644 --- a/vulkan/libvulkan/api.cpp +++ b/vulkan/libvulkan/api.cpp @@ -1473,7 +1473,7 @@ VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) { if (!EnsureInitialized()) return VK_ERROR_OUT_OF_HOST_MEMORY; - *pApiVersion = VK_API_VERSION_1_2; + *pApiVersion = VK_API_VERSION_1_3; return VK_SUCCESS; } diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 238429f957..92250621ed 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -365,7 +365,7 @@ CreateInfoWrapper::CreateInfoWrapper(const VkInstanceCreateInfo& create_info, const VkAllocationCallbacks& allocator) : is_instance_(true), allocator_(allocator), - loader_api_version_(VK_API_VERSION_1_2), + loader_api_version_(VK_API_VERSION_1_3), icd_api_version_(icd_api_version), physical_dev_(VK_NULL_HANDLE), instance_info_(create_info), @@ -377,7 +377,7 @@ CreateInfoWrapper::CreateInfoWrapper(VkPhysicalDevice physical_dev, const VkAllocationCallbacks& allocator) : is_instance_(false), allocator_(allocator), - loader_api_version_(VK_API_VERSION_1_2), + loader_api_version_(VK_API_VERSION_1_3), icd_api_version_(icd_api_version), physical_dev_(physical_dev), dev_info_(create_info), @@ -519,6 +519,10 @@ VkResult CreateInfoWrapper::SanitizeExtensions() { is_instance_ ? loader_api_version_ : std::min(icd_api_version_, loader_api_version_); switch (api_version) { + case VK_API_VERSION_1_3: + hook_extensions_.set(ProcHook::EXTENSION_CORE_1_3); + hal_extensions_.set(ProcHook::EXTENSION_CORE_1_3); + [[clang::fallthrough]]; case VK_API_VERSION_1_2: hook_extensions_.set(ProcHook::EXTENSION_CORE_1_2); hal_extensions_.set(ProcHook::EXTENSION_CORE_1_2); diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp index a9f37e56cf..eea0ec92e7 100644 --- a/vulkan/nulldrv/null_driver.cpp +++ b/vulkan/nulldrv/null_driver.cpp @@ -260,7 +260,7 @@ namespace null_driver { VKAPI_ATTR VkResult EnumerateInstanceVersion(uint32_t* pApiVersion) { - *pApiVersion = VK_API_VERSION_1_2; + *pApiVersion = VK_API_VERSION_1_3; return VK_SUCCESS; } diff --git a/vulkan/vkjson/vkjson.cc b/vulkan/vkjson/vkjson.cc index 90cf42c7f7..798fd4a5ab 100644 --- a/vulkan/vkjson/vkjson.cc +++ b/vulkan/vkjson/vkjson.cc @@ -973,6 +973,8 @@ inline bool Iterate(Visitor* visitor, VkJsonDevice* device) { bool ret = true; switch (device->properties.apiVersion ^ VK_API_VERSION_PATCH(device->properties.apiVersion)) { + case VK_API_VERSION_1_3: + FALLTHROUGH_INTENDED; case VK_API_VERSION_1_2: ret &= visitor->Visit("core12", &device->core12); FALLTHROUGH_INTENDED; @@ -1030,6 +1032,8 @@ template inline bool Iterate(Visitor* visitor, VkJsonInstance* instance) { bool ret = true; switch (instance->api_version ^ VK_API_VERSION_PATCH(instance->api_version)) { + case VK_API_VERSION_1_3: + FALLTHROUGH_INTENDED; case VK_API_VERSION_1_2: ret &= visitor->Visit("apiVersion", &instance->api_version); FALLTHROUGH_INTENDED; -- cgit v1.2.3-59-g8ed1b From 6ba85d939187ca6ad201ab7b098391733317c259 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Fri, 18 Feb 2022 16:44:58 -0700 Subject: swapchain: Implement VK_GOOGLE_surfaceless_query This extension allows ANGLE to call Vulkan WSI queries before it has a VkSurfaceKHR. Bug: 203826952 Test: Test with ANGLE EGLConfig-generation code Change-Id: I7e53a8a28157023658baac0778033159bdd2285e --- vulkan/libvulkan/driver.cpp | 4 + vulkan/libvulkan/driver_gen.cpp | 1 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/libvulkan/swapchain.cpp | 189 +++++++++++++++++++++++++------------ vulkan/scripts/driver_generator.py | 1 + 5 files changed, 137 insertions(+), 59 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 92250621ed..6a075613df 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -634,6 +634,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: + case ProcHook::GOOGLE_surfaceless_query: hook_extensions_.set(ext_bit); // return now as these extensions do not require HAL support return; @@ -712,6 +713,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: + case ProcHook::GOOGLE_surfaceless_query: case ProcHook::ANDROID_native_buffer: case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: @@ -932,6 +934,8 @@ VkResult EnumerateInstanceExtensionProperties( loader_extensions.push_back({ VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION}); + loader_extensions.push_back({VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, + VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION}); static const VkExtensionProperties loader_debug_report_extension = { VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION, diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 5f37a50a03..f84fc8814c 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -565,6 +565,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata; if (strcmp(name, "VK_EXT_swapchain_colorspace") == 0) return ProcHook::EXT_swapchain_colorspace; if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing; + if (strcmp(name, "VK_GOOGLE_surfaceless_query") == 0) return ProcHook::GOOGLE_surfaceless_query; if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface; if (strcmp(name, "VK_KHR_get_surface_capabilities2") == 0) return ProcHook::KHR_get_surface_capabilities2; if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 819f6b211c..6a6c5b3d3c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -41,6 +41,7 @@ struct ProcHook { EXT_hdr_metadata, EXT_swapchain_colorspace, GOOGLE_display_timing, + GOOGLE_surfaceless_query, KHR_android_surface, KHR_get_surface_capabilities2, KHR_incremental_present, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 4a6b4f12a1..20a0aad712 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -619,42 +619,65 @@ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/, VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice /*pdev*/, + VkPhysicalDevice pdev, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* capabilities) { ATRACE_CALL(); int err; - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - int width, height; - err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - int transform_hint; - err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - int max_buffer_count; - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &max_buffer_count); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; + if (surface == VK_NULL_HANDLE) { + const InstanceData& instance_data = GetData(pdev); + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + // It is an error to pass a surface==VK_NULL_HANDLE unless the + // VK_GOOGLE_surfaceless_query extension is enabled + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this + // extension for this function is for + // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following + // four values cannot be known without a surface. Default values will + // be supplied anyway, but cannot be relied upon. + width = 1000; + height = 1000; + transform_hint = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; + max_buffer_count = 10; + } else { + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + + err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + + err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, + &transform_hint); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + + err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, + &max_buffer_count); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } } capabilities->minImageCount = std::min(max_buffer_count, 3); capabilities->maxImageCount = static_cast(max_buffer_count); @@ -695,23 +718,43 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, const InstanceData& instance_data = GetData(pdev); bool wide_color_support = false; - Surface& surface = *SurfaceFromHandle(surface_handle); - int err = native_window_get_wide_color_support(surface.window.get(), - &wide_color_support); - if (err) { - return VK_ERROR_SURFACE_LOST_KHR; - } + uint64_t consumer_usage = 0; bool swapchain_ext = instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); - ALOGV("wide_color_support is: %d", wide_color_support); + if (surface_handle == VK_NULL_HANDLE) { + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The EGL loader + // unconditionally supports wide color formats, even if they will cause + // a SurfaceFlinger fallback. Based on that, wide_color_support will be + // set to true in this case. + wide_color_support = true; + + // TODO(b/203826952): research proper value; temporarily use the + // values seen on Pixel + consumer_usage = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY; + } else { + Surface& surface = *SurfaceFromHandle(surface_handle); + int err = native_window_get_wide_color_support(surface.window.get(), + &wide_color_support); + if (err) { + return VK_ERROR_SURFACE_LOST_KHR; + } + ALOGV("wide_color_support is: %d", wide_color_support); + + consumer_usage = surface.consumer_usage; + } wide_color_support = wide_color_support && swapchain_ext; AHardwareBuffer_Desc desc = {}; desc.width = 1; desc.height = 1; desc.layers = 1; - desc.usage = surface.consumer_usage | - AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | + desc.usage = consumer_usage | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER; // We must support R8G8B8A8 @@ -731,6 +774,10 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT}); } + // NOTE: Any new formats that are added must be coordinated across different + // Android users. This includes the ANGLE team (a layered implementation of + // OpenGL-ES). + desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM; if (AHardwareBuffer_isSupported(&desc)) { all_formats.emplace_back(VkSurfaceFormatKHR{ @@ -770,6 +817,10 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VK_COLOR_SPACE_PASS_THROUGH_EXT}); } + // NOTE: Any new formats that are added must be coordinated across different + // Android users. This includes the ANGLE team (a layered implementation of + // OpenGL-ES). + VkResult result = VK_SUCCESS; if (formats) { uint32_t transfer_count = all_formats.size(); @@ -865,31 +916,51 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, int err; int query_value; - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + std::vector present_modes; + if (surface == VK_NULL_HANDLE) { + const InstanceData& instance_data = GetData(pdev); + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this + // extension for this function is for + // VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR and + // VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR. We technically cannot + // know if VK_PRESENT_MODE_SHARED_MAILBOX_KHR is supported without a + // surface, and that cannot be relied upon. + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); + } else { + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, - &query_value); - if (err != android::OK || query_value < 0) { - ALOGE( - "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " - "value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; - } - uint32_t min_undequeued_buffers = static_cast(query_value); + err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, + &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " + "value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t min_undequeued_buffers = static_cast(query_value); + + err = + window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t max_buffer_count = static_cast(query_value); - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); - if (err != android::OK || query_value < 0) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; + if (min_undequeued_buffers + 1 < max_buffer_count) + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); } - uint32_t max_buffer_count = static_cast(query_value); - - std::vector present_modes; - if (min_undequeued_buffers + 1 < max_buffer_count) - present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); - present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); VkPhysicalDevicePresentationPropertiesANDROID present_properties; QueryPresentationProperties(pdev, &present_properties); diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index 6a73023193..cd25dd817c 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -27,6 +27,7 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_EXT_hdr_metadata', 'VK_EXT_swapchain_colorspace', 'VK_GOOGLE_display_timing', + 'VK_GOOGLE_surfaceless_query', 'VK_KHR_android_surface', 'VK_KHR_get_surface_capabilities2', 'VK_KHR_incremental_present', -- cgit v1.2.3-59-g8ed1b From c7c4aa3297f87f06ac63c2f1f259aecb59fc41f7 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Mon, 28 Feb 2022 16:47:43 -0700 Subject: swapchain: Implement VK_KHR_surface_protected_capabilities Bug: 221490496 Test: Test with ANGLE EGLConfig-generation code Change-Id: Id01e677175a2cf98f4d893e21f3c654375772153 --- vulkan/libvulkan/driver.cpp | 5 +++++ vulkan/libvulkan/driver_gen.cpp | 1 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/libvulkan/swapchain.cpp | 6 ++++++ vulkan/scripts/driver_generator.py | 1 + 5 files changed, 14 insertions(+) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 6a075613df..60c0cb5c3e 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -632,6 +632,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { switch (ext_bit) { case ProcHook::KHR_android_surface: case ProcHook::KHR_surface: + case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::GOOGLE_surfaceless_query: @@ -711,6 +712,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_external_fence_capabilities: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::KHR_surface: + case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: case ProcHook::GOOGLE_surfaceless_query: @@ -925,6 +927,9 @@ VkResult EnumerateInstanceExtensionProperties( loader_extensions.push_back({ VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION}); + loader_extensions.push_back( + {VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME, + VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION}); loader_extensions.push_back({ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, VK_KHR_ANDROID_SURFACE_SPEC_VERSION}); diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index f84fc8814c..b436db1de7 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -571,6 +571,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image; if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface; + if (strcmp(name, "VK_KHR_surface_protected_capabilities") == 0) return ProcHook::KHR_surface_protected_capabilities; if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain; if (strcmp(name, "VK_ANDROID_external_memory_android_hardware_buffer") == 0) return ProcHook::ANDROID_external_memory_android_hardware_buffer; if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 6a6c5b3d3c..079f9cca39 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -47,6 +47,7 @@ struct ProcHook { KHR_incremental_present, KHR_shared_presentable_image, KHR_surface, + KHR_surface_protected_capabilities, KHR_swapchain, ANDROID_external_memory_android_hardware_buffer, KHR_bind_memory2, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 20a0aad712..0be4403731 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -865,6 +865,12 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( .supportedUsageFlags; } break; + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: { + VkSurfaceProtectedCapabilitiesKHR* protected_caps = + reinterpret_cast(caps); + protected_caps->supportsProtected = VK_TRUE; + } break; + default: // Ignore all other extension structs break; diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index cd25dd817c..af56764a21 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -33,6 +33,7 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_KHR_incremental_present', 'VK_KHR_shared_presentable_image', 'VK_KHR_surface', + 'VK_KHR_surface_protected_capabilities', 'VK_KHR_swapchain', ] -- cgit v1.2.3-59-g8ed1b From 4d1ad47aca661452dbe99d277167dc4cc21dd61c Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Mon, 14 Mar 2022 17:27:47 -0600 Subject: Revert "swapchain: Implement VK_KHR_surface_protected_capabilities" In order to help the automerger get this everywhere, am reverting it here, and then will land it in AOSP master (which will automerge here again). This reverts commit a9e06fd447e8ebf22b2dd025d6ee1aa3f93b2bc1. Test: Manual Inspection Bug: 221490496 Change-Id: I21dcc2ab87d34b2366d32d06b910c88400c5f70d --- vulkan/libvulkan/driver.cpp | 8 +------- vulkan/libvulkan/driver_gen.cpp | 1 - vulkan/libvulkan/driver_gen.h | 1 - vulkan/libvulkan/swapchain.cpp | 6 ------ vulkan/scripts/driver_generator.py | 1 - 5 files changed, 1 insertion(+), 16 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 60c0cb5c3e..8cb1b21160 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -632,7 +632,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { switch (ext_bit) { case ProcHook::KHR_android_surface: case ProcHook::KHR_surface: - case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::GOOGLE_surfaceless_query: @@ -712,7 +711,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_external_fence_capabilities: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::KHR_surface: - case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: case ProcHook::GOOGLE_surfaceless_query: @@ -924,12 +922,8 @@ VkResult EnumerateInstanceExtensionProperties( uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { std::vector loader_extensions; - loader_extensions.push_back({ - VK_KHR_SURFACE_EXTENSION_NAME, - VK_KHR_SURFACE_SPEC_VERSION}); loader_extensions.push_back( - {VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME, - VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION}); + {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION}); loader_extensions.push_back({ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, VK_KHR_ANDROID_SURFACE_SPEC_VERSION}); diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index b436db1de7..f84fc8814c 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -571,7 +571,6 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image; if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface; - if (strcmp(name, "VK_KHR_surface_protected_capabilities") == 0) return ProcHook::KHR_surface_protected_capabilities; if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain; if (strcmp(name, "VK_ANDROID_external_memory_android_hardware_buffer") == 0) return ProcHook::ANDROID_external_memory_android_hardware_buffer; if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 079f9cca39..6a6c5b3d3c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -47,7 +47,6 @@ struct ProcHook { KHR_incremental_present, KHR_shared_presentable_image, KHR_surface, - KHR_surface_protected_capabilities, KHR_swapchain, ANDROID_external_memory_android_hardware_buffer, KHR_bind_memory2, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 0be4403731..20a0aad712 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -865,12 +865,6 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( .supportedUsageFlags; } break; - case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: { - VkSurfaceProtectedCapabilitiesKHR* protected_caps = - reinterpret_cast(caps); - protected_caps->supportsProtected = VK_TRUE; - } break; - default: // Ignore all other extension structs break; diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index af56764a21..cd25dd817c 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -33,7 +33,6 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_KHR_incremental_present', 'VK_KHR_shared_presentable_image', 'VK_KHR_surface', - 'VK_KHR_surface_protected_capabilities', 'VK_KHR_swapchain', ] -- cgit v1.2.3-59-g8ed1b From e7f036c24c2814bd18cb2ff892428c21bf45ec18 Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Tue, 15 Mar 2022 16:49:21 -0600 Subject: Revert "swapchain: Implement VK_GOOGLE_surfaceless_query" In order to help the automerger get this everywhere, am reverting it here, and then will land it in AOSP master (which will automerge here again). This reverts commit 8e0f12163f90a1a511625ba1f290de95777beb86. Test: Manual inspection Bug: 203826952 Change-Id: I227993c87b1601b8dc0d1cf4bb008d5af9abc930 --- vulkan/libvulkan/driver.cpp | 10 +- vulkan/libvulkan/driver_gen.cpp | 1 - vulkan/libvulkan/driver_gen.h | 1 - vulkan/libvulkan/swapchain.cpp | 184 ++++++++++++------------------------- vulkan/scripts/driver_generator.py | 1 - 5 files changed, 62 insertions(+), 135 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 8cb1b21160..6e54d6c0de 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -634,7 +634,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: - case ProcHook::GOOGLE_surfaceless_query: hook_extensions_.set(ext_bit); // return now as these extensions do not require HAL support return; @@ -713,7 +712,6 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: - case ProcHook::GOOGLE_surfaceless_query: case ProcHook::ANDROID_native_buffer: case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: @@ -930,11 +928,9 @@ VkResult EnumerateInstanceExtensionProperties( loader_extensions.push_back({ VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME, VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION}); - loader_extensions.push_back({ - VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, - VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION}); - loader_extensions.push_back({VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, - VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION}); + loader_extensions.push_back( + {VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, + VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION}); static const VkExtensionProperties loader_debug_report_extension = { VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION, diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index f84fc8814c..5f37a50a03 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -565,7 +565,6 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata; if (strcmp(name, "VK_EXT_swapchain_colorspace") == 0) return ProcHook::EXT_swapchain_colorspace; if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing; - if (strcmp(name, "VK_GOOGLE_surfaceless_query") == 0) return ProcHook::GOOGLE_surfaceless_query; if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface; if (strcmp(name, "VK_KHR_get_surface_capabilities2") == 0) return ProcHook::KHR_get_surface_capabilities2; if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 6a6c5b3d3c..819f6b211c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -41,7 +41,6 @@ struct ProcHook { EXT_hdr_metadata, EXT_swapchain_colorspace, GOOGLE_display_timing, - GOOGLE_surfaceless_query, KHR_android_surface, KHR_get_surface_capabilities2, KHR_incremental_present, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 5fdee217ab..9decd84a2e 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -619,65 +619,43 @@ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/, VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice pdev, + VkPhysicalDevice /*pdev*/, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* capabilities) { ATRACE_CALL(); int err; - int width, height; - int transform_hint; - int max_buffer_count; - if (surface == VK_NULL_HANDLE) { - const InstanceData& instance_data = GetData(pdev); - ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; - bool surfaceless_enabled = - instance_data.hook_extensions.test(surfaceless); - if (!surfaceless_enabled) { - // It is an error to pass a surface==VK_NULL_HANDLE unless the - // VK_GOOGLE_surfaceless_query extension is enabled - return VK_ERROR_SURFACE_LOST_KHR; - } - // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this - // extension for this function is for - // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following - // four values cannot be known without a surface. Default values will - // be supplied anyway, but cannot be relied upon. - width = 1000; - height = 1000; - transform_hint = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; - max_buffer_count = 10; - } else { - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } + int width, height; + err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } - err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, - &transform_hint); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } + int transform_hint; + err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, - &max_buffer_count); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } + int max_buffer_count; + err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, + &max_buffer_count); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; } capabilities->minImageCount = std::min(max_buffer_count, 3); capabilities->maxImageCount = static_cast(max_buffer_count); @@ -718,34 +696,13 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, const InstanceData& instance_data = GetData(pdev); bool wide_color_support = false; - uint64_t consumer_usage = 0; - if (surface_handle == VK_NULL_HANDLE) { - ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; - bool surfaceless_enabled = - instance_data.hook_extensions.test(surfaceless); - if (!surfaceless_enabled) { - return VK_ERROR_SURFACE_LOST_KHR; - } - // Support for VK_GOOGLE_surfaceless_query. The EGL loader - // unconditionally supports wide color formats, even if they will cause - // a SurfaceFlinger fallback. Based on that, wide_color_support will be - // set to true in this case. - wide_color_support = true; - - // TODO(b/203826952): research proper value; temporarily use the - // values seen on Pixel - consumer_usage = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY; - } else { - Surface& surface = *SurfaceFromHandle(surface_handle); - int err = native_window_get_wide_color_support(surface.window.get(), - &wide_color_support); - if (err) { - return VK_ERROR_SURFACE_LOST_KHR; - } - ALOGV("wide_color_support is: %d", wide_color_support); - - consumer_usage = surface.consumer_usage; + Surface& surface = *SurfaceFromHandle(surface_handle); + int err = native_window_get_wide_color_support(surface.window.get(), + &wide_color_support); + if (err) { + return VK_ERROR_SURFACE_LOST_KHR; } + ALOGV("wide_color_support is: %d", wide_color_support); wide_color_support = wide_color_support && instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); @@ -754,7 +711,8 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, desc.width = 1; desc.height = 1; desc.layers = 1; - desc.usage = consumer_usage | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | + desc.usage = surface.consumer_usage | + AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER; // We must support R8G8B8A8 @@ -770,10 +728,6 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT}); } - // NOTE: Any new formats that are added must be coordinated across different - // Android users. This includes the ANGLE team (a layered implementation of - // OpenGL-ES). - desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM; if (AHardwareBuffer_isSupported(&desc)) { all_formats.emplace_back(VkSurfaceFormatKHR{ @@ -912,51 +866,31 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, int err; int query_value; - std::vector present_modes; - if (surface == VK_NULL_HANDLE) { - const InstanceData& instance_data = GetData(pdev); - ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; - bool surfaceless_enabled = - instance_data.hook_extensions.test(surfaceless); - if (!surfaceless_enabled) { - return VK_ERROR_SURFACE_LOST_KHR; - } - // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this - // extension for this function is for - // VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR and - // VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR. We technically cannot - // know if VK_PRESENT_MODE_SHARED_MAILBOX_KHR is supported without a - // surface, and that cannot be relied upon. - present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); - present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); - } else { - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, - &query_value); - if (err != android::OK || query_value < 0) { - ALOGE( - "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " - "value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; - } - uint32_t min_undequeued_buffers = static_cast(query_value); - - err = - window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); - if (err != android::OK || query_value < 0) { - ALOGE( - "NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; - } - uint32_t max_buffer_count = static_cast(query_value); + err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, + &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " + "value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t min_undequeued_buffers = static_cast(query_value); - if (min_undequeued_buffers + 1 < max_buffer_count) - present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); - present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); + err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); + if (err != android::OK || query_value < 0) { + ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; } + uint32_t max_buffer_count = static_cast(query_value); + + std::vector present_modes; + if (min_undequeued_buffers + 1 < max_buffer_count) + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); VkPhysicalDevicePresentationPropertiesANDROID present_properties; QueryPresentationProperties(pdev, &present_properties); diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index cd25dd817c..6a73023193 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -27,7 +27,6 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_EXT_hdr_metadata', 'VK_EXT_swapchain_colorspace', 'VK_GOOGLE_display_timing', - 'VK_GOOGLE_surfaceless_query', 'VK_KHR_android_surface', 'VK_KHR_get_surface_capabilities2', 'VK_KHR_incremental_present', -- cgit v1.2.3-59-g8ed1b From 1ce053f1c755040cb6b80a0b09534d9e311ecbfe Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Wed, 16 Mar 2022 09:49:53 -0600 Subject: swapchain: Implement VK_GOOGLE_surfaceless_query This extension allows ANGLE to call Vulkan WSI queries before it has a VkSurfaceKHR. This version tries to address some subtle differences between upstream and downstream branches. Bug: 203826952 Test: Test with ANGLE EGLConfig-generation code Change-Id: I7eb013efbaa5dd19ebed045583616238cea57023 --- vulkan/libvulkan/driver.cpp | 4 + vulkan/libvulkan/driver_gen.cpp | 1 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/libvulkan/swapchain.cpp | 184 +++++++++++++++++++++++++------------ vulkan/scripts/driver_generator.py | 1 + 5 files changed, 132 insertions(+), 59 deletions(-) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index 6e54d6c0de..aee90cd661 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -634,6 +634,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: + case ProcHook::GOOGLE_surfaceless_query: hook_extensions_.set(ext_bit); // return now as these extensions do not require HAL support return; @@ -712,6 +713,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_surface: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: + case ProcHook::GOOGLE_surfaceless_query: case ProcHook::ANDROID_native_buffer: case ProcHook::EXTENSION_CORE_1_0: case ProcHook::EXTENSION_CORE_1_1: @@ -931,6 +933,8 @@ VkResult EnumerateInstanceExtensionProperties( loader_extensions.push_back( {VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION}); + loader_extensions.push_back({VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME, + VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION}); static const VkExtensionProperties loader_debug_report_extension = { VK_EXT_DEBUG_REPORT_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_SPEC_VERSION, diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index 5f37a50a03..f84fc8814c 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -565,6 +565,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata; if (strcmp(name, "VK_EXT_swapchain_colorspace") == 0) return ProcHook::EXT_swapchain_colorspace; if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing; + if (strcmp(name, "VK_GOOGLE_surfaceless_query") == 0) return ProcHook::GOOGLE_surfaceless_query; if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface; if (strcmp(name, "VK_KHR_get_surface_capabilities2") == 0) return ProcHook::KHR_get_surface_capabilities2; if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 819f6b211c..6a6c5b3d3c 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -41,6 +41,7 @@ struct ProcHook { EXT_hdr_metadata, EXT_swapchain_colorspace, GOOGLE_display_timing, + GOOGLE_surfaceless_query, KHR_android_surface, KHR_get_surface_capabilities2, KHR_incremental_present, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index 6dce394839..f42c4f026b 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -619,43 +619,65 @@ VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice /*pdev*/, VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice /*pdev*/, + VkPhysicalDevice pdev, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* capabilities) { ATRACE_CALL(); int err; - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - int width, height; - err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - int transform_hint; - err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, &transform_hint); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; - } - int max_buffer_count; - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, - &max_buffer_count); - if (err != android::OK) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", - strerror(-err), err); - return VK_ERROR_SURFACE_LOST_KHR; + if (surface == VK_NULL_HANDLE) { + const InstanceData& instance_data = GetData(pdev); + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + // It is an error to pass a surface==VK_NULL_HANDLE unless the + // VK_GOOGLE_surfaceless_query extension is enabled + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this + // extension for this function is for + // VkSurfaceProtectedCapabilitiesKHR::supportsProtected. The following + // four values cannot be known without a surface. Default values will + // be supplied anyway, but cannot be relied upon. + width = 1000; + height = 1000; + transform_hint = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; + max_buffer_count = 10; + } else { + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + + err = window->query(window, NATIVE_WINDOW_DEFAULT_WIDTH, &width); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + err = window->query(window, NATIVE_WINDOW_DEFAULT_HEIGHT, &height); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_DEFAULT_WIDTH query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + + err = window->query(window, NATIVE_WINDOW_TRANSFORM_HINT, + &transform_hint); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_TRANSFORM_HINT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } + + err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, + &max_buffer_count); + if (err != android::OK) { + ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d)", + strerror(-err), err); + return VK_ERROR_SURFACE_LOST_KHR; + } } capabilities->minImageCount = std::min(max_buffer_count, 3); capabilities->maxImageCount = static_cast(max_buffer_count); @@ -696,13 +718,34 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, const InstanceData& instance_data = GetData(pdev); bool wide_color_support = false; - Surface& surface = *SurfaceFromHandle(surface_handle); - int err = native_window_get_wide_color_support(surface.window.get(), - &wide_color_support); - if (err) { - return VK_ERROR_SURFACE_LOST_KHR; + uint64_t consumer_usage = 0; + if (surface_handle == VK_NULL_HANDLE) { + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The EGL loader + // unconditionally supports wide color formats, even if they will cause + // a SurfaceFlinger fallback. Based on that, wide_color_support will be + // set to true in this case. + wide_color_support = true; + + // TODO(b/203826952): research proper value; temporarily use the + // values seen on Pixel + consumer_usage = AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY; + } else { + Surface& surface = *SurfaceFromHandle(surface_handle); + int err = native_window_get_wide_color_support(surface.window.get(), + &wide_color_support); + if (err) { + return VK_ERROR_SURFACE_LOST_KHR; + } + ALOGV("wide_color_support is: %d", wide_color_support); + + consumer_usage = surface.consumer_usage; } - ALOGV("wide_color_support is: %d", wide_color_support); wide_color_support = wide_color_support && instance_data.hook_extensions.test(ProcHook::EXT_swapchain_colorspace); @@ -711,8 +754,7 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, desc.width = 1; desc.height = 1; desc.layers = 1; - desc.usage = surface.consumer_usage | - AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | + desc.usage = consumer_usage | AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE | AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER; // We must support R8G8B8A8 @@ -727,6 +769,10 @@ VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice pdev, VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT}); } + // NOTE: Any new formats that are added must be coordinated across different + // Android users. This includes the ANGLE team (a layered implementation of + // OpenGL-ES). + desc.format = AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM; if (AHardwareBuffer_isSupported(&desc)) { all_formats.emplace_back(VkSurfaceFormatKHR{ @@ -865,31 +911,51 @@ VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice pdev, int err; int query_value; - ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); + std::vector present_modes; + if (surface == VK_NULL_HANDLE) { + const InstanceData& instance_data = GetData(pdev); + ProcHook::Extension surfaceless = ProcHook::GOOGLE_surfaceless_query; + bool surfaceless_enabled = + instance_data.hook_extensions.test(surfaceless); + if (!surfaceless_enabled) { + return VK_ERROR_SURFACE_LOST_KHR; + } + // Support for VK_GOOGLE_surfaceless_query. The primary purpose of this + // extension for this function is for + // VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR and + // VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR. We technically cannot + // know if VK_PRESENT_MODE_SHARED_MAILBOX_KHR is supported without a + // surface, and that cannot be relied upon. + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); + } else { + ANativeWindow* window = SurfaceFromHandle(surface)->window.get(); - err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, - &query_value); - if (err != android::OK || query_value < 0) { - ALOGE( - "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " - "value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; - } - uint32_t min_undequeued_buffers = static_cast(query_value); + err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, + &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS query failed: %s (%d) " + "value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t min_undequeued_buffers = static_cast(query_value); + + err = + window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); + if (err != android::OK || query_value < 0) { + ALOGE( + "NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", + strerror(-err), err, query_value); + return VK_ERROR_SURFACE_LOST_KHR; + } + uint32_t max_buffer_count = static_cast(query_value); - err = window->query(window, NATIVE_WINDOW_MAX_BUFFER_COUNT, &query_value); - if (err != android::OK || query_value < 0) { - ALOGE("NATIVE_WINDOW_MAX_BUFFER_COUNT query failed: %s (%d) value=%d", - strerror(-err), err, query_value); - return VK_ERROR_SURFACE_LOST_KHR; + if (min_undequeued_buffers + 1 < max_buffer_count) + present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); + present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); } - uint32_t max_buffer_count = static_cast(query_value); - - std::vector present_modes; - if (min_undequeued_buffers + 1 < max_buffer_count) - present_modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); - present_modes.push_back(VK_PRESENT_MODE_FIFO_KHR); VkPhysicalDevicePresentationPropertiesANDROID present_properties; QueryPresentationProperties(pdev, &present_properties); diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index 6a73023193..cd25dd817c 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -27,6 +27,7 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_EXT_hdr_metadata', 'VK_EXT_swapchain_colorspace', 'VK_GOOGLE_display_timing', + 'VK_GOOGLE_surfaceless_query', 'VK_KHR_android_surface', 'VK_KHR_get_surface_capabilities2', 'VK_KHR_incremental_present', -- cgit v1.2.3-59-g8ed1b From bb67b24454fbb78e45e289816fa5fc731fa6411d Mon Sep 17 00:00:00 2001 From: Ian Elliott Date: Wed, 16 Mar 2022 09:52:28 -0600 Subject: swapchain: Implement VK_KHR_surface_protected_capabilities This version tries to address some subtle differences between upstream and downstream branches. Bug: 221490496 Test: Test with ANGLE EGLConfig-generation code Change-Id: I750f052e3560e76b2035ed3c92a3ec38745b9ef4 --- vulkan/libvulkan/driver.cpp | 5 +++++ vulkan/libvulkan/driver_gen.cpp | 1 + vulkan/libvulkan/driver_gen.h | 1 + vulkan/libvulkan/swapchain.cpp | 6 ++++++ vulkan/scripts/driver_generator.py | 1 + 5 files changed, 14 insertions(+) (limited to 'vulkan/libvulkan/driver.cpp') diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp index aee90cd661..766451824a 100644 --- a/vulkan/libvulkan/driver.cpp +++ b/vulkan/libvulkan/driver.cpp @@ -632,6 +632,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { switch (ext_bit) { case ProcHook::KHR_android_surface: case ProcHook::KHR_surface: + case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_swapchain_colorspace: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::GOOGLE_surfaceless_query: @@ -711,6 +712,7 @@ void CreateInfoWrapper::FilterExtension(const char* name) { case ProcHook::KHR_external_fence_capabilities: case ProcHook::KHR_get_surface_capabilities2: case ProcHook::KHR_surface: + case ProcHook::KHR_surface_protected_capabilities: case ProcHook::EXT_debug_report: case ProcHook::EXT_swapchain_colorspace: case ProcHook::GOOGLE_surfaceless_query: @@ -924,6 +926,9 @@ VkResult EnumerateInstanceExtensionProperties( std::vector loader_extensions; loader_extensions.push_back( {VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_SURFACE_SPEC_VERSION}); + loader_extensions.push_back( + {VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME, + VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION}); loader_extensions.push_back({ VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, VK_KHR_ANDROID_SURFACE_SPEC_VERSION}); diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp index f84fc8814c..b436db1de7 100644 --- a/vulkan/libvulkan/driver_gen.cpp +++ b/vulkan/libvulkan/driver_gen.cpp @@ -571,6 +571,7 @@ ProcHook::Extension GetProcHookExtension(const char* name) { if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present; if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image; if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface; + if (strcmp(name, "VK_KHR_surface_protected_capabilities") == 0) return ProcHook::KHR_surface_protected_capabilities; if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain; if (strcmp(name, "VK_ANDROID_external_memory_android_hardware_buffer") == 0) return ProcHook::ANDROID_external_memory_android_hardware_buffer; if (strcmp(name, "VK_KHR_bind_memory2") == 0) return ProcHook::KHR_bind_memory2; diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h index 6a6c5b3d3c..079f9cca39 100644 --- a/vulkan/libvulkan/driver_gen.h +++ b/vulkan/libvulkan/driver_gen.h @@ -47,6 +47,7 @@ struct ProcHook { KHR_incremental_present, KHR_shared_presentable_image, KHR_surface, + KHR_surface_protected_capabilities, KHR_swapchain, ANDROID_external_memory_android_hardware_buffer, KHR_bind_memory2, diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp index f42c4f026b..72696adcc8 100644 --- a/vulkan/libvulkan/swapchain.cpp +++ b/vulkan/libvulkan/swapchain.cpp @@ -860,6 +860,12 @@ VkResult GetPhysicalDeviceSurfaceCapabilities2KHR( .supportedUsageFlags; } break; + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: { + VkSurfaceProtectedCapabilitiesKHR* protected_caps = + reinterpret_cast(caps); + protected_caps->supportsProtected = VK_TRUE; + } break; + default: // Ignore all other extension structs break; diff --git a/vulkan/scripts/driver_generator.py b/vulkan/scripts/driver_generator.py index cd25dd817c..af56764a21 100644 --- a/vulkan/scripts/driver_generator.py +++ b/vulkan/scripts/driver_generator.py @@ -33,6 +33,7 @@ _INTERCEPTED_EXTENSIONS = [ 'VK_KHR_incremental_present', 'VK_KHR_shared_presentable_image', 'VK_KHR_surface', + 'VK_KHR_surface_protected_capabilities', 'VK_KHR_swapchain', ] -- cgit v1.2.3-59-g8ed1b