Implement VK_EXT_headless_surface

src/Vulkan/VkGetProcAddress.cpp

@@ -147,6 +147,7 @@ static const std::unordered_map<std::string, PFN_vkVoidFunction> instanceFunctio
 	MAKE_VULKAN_INSTANCE_ENTRY(vkCreateWin32SurfaceKHR),
 	MAKE_VULKAN_INSTANCE_ENTRY(vkGetPhysicalDeviceWin32PresentationSupportKHR),
 #endif
+	MAKE_VULKAN_INSTANCE_ENTRY(vkCreateHeadlessSurfaceEXT),
 };
 #undef MAKE_VULKAN_INSTANCE_ENTRY
 

src/Vulkan/libVulkan.cpp

@@ -73,6 +73,8 @@
 #	include "WSI/Win32SurfaceKHR.hpp"
 #endif
 
+#include "WSI/HeadlessSurfaceKHR.hpp"
+
 #ifdef __ANDROID__
 #	include "commit.h"
 #	include "System/GrallocAndroid.hpp"
@@ -3740,6 +3742,14 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(Vk
 }
 #endif
 
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface)
+{
+	TRACE("(VkInstance instance = %p, VkHeadlessSurfaceCreateInfoEXT* pCreateInfo = %p, VkAllocationCallbacks* pAllocator = %p, VkSurface* pSurface = %p)",
+	      instance, pCreateInfo, pAllocator, pSurface);
+
+	return vk::HeadlessSurfaceKHR::Create(pAllocator, pCreateInfo, pSurface);
+}
+
 #ifndef __ANDROID__
 VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
 {

src/Vulkan/vk_swiftshader.def

@@ -231,3 +231,5 @@ EXPORTS
 	vkGetPhysicalDeviceWin32PresentationSupportKHR
 	; VK_EXT_host_query_reset
 	vkResetQueryPool
+	; VK_EXT_headless_surface
+	vkCreateHeadlessSurfaceEXT

src/Vulkan/vk_swiftshader.lds

@@ -228,6 +228,8 @@ global:
 	vkGetPhysicalDeviceSurfacePresentModesKHR;
 	# VK_EXT_host_query_reset
 	vkResetQueryPool;
+	# VK_EXT_headless_surface
+	vkCreateHeadlessSurfaceEXT;
 
 	# Android HAL module info object
 	HMI;

src/WSI/BUILD.gn

@@ -25,6 +25,8 @@ config("WSI_metal_weak_framework") {
 
 swiftshader_source_set("WSI") {
   sources = [
+    "HeadlessSurfaceKHR.cpp",
+    "HeadlessSurfaceKHR.hpp",
     "VkSurfaceKHR.cpp",
     "VkSurfaceKHR.hpp",
     "VkSwapchainKHR.cpp",

src/WSI/CMakeLists.txt

@@ -18,6 +18,8 @@ set(ROOT_PROJECT_COMPILE_OPTIONS
 )
 
 set(WSI_SRC_FILES
+    HeadlessSurfaceKHR.cpp
+    HeadlessSurfaceKHR.hpp
     VkSurfaceKHR.cpp
     VkSurfaceKHR.hpp
     VkSwapchainKHR.cpp

src/WSI/HeadlessSurfaceKHR.cpp

+// Copyright 2021 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "HeadlessSurfaceKHR.hpp"
+
+namespace vk {
+
+HeadlessSurfaceKHR::HeadlessSurfaceKHR(const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, void *mem)
+{
+}
+
+size_t HeadlessSurfaceKHR::ComputeRequiredAllocationSize(const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo)
+{
+	return 0;
+}
+
+void HeadlessSurfaceKHR::destroySurface(const VkAllocationCallbacks *pAllocator)
+{
+}
+
+void HeadlessSurfaceKHR::getSurfaceCapabilities(VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const
+{
+	SurfaceKHR::getSurfaceCapabilities(pSurfaceCapabilities);
+	// We could return {0,0} here, but as this type of surface is useful for testing, we return a more
+	// common size here so that buffers like Swapchain images get created with reasonable sizes, and
+	// so that drawing actually exercises common code paths.
+	VkExtent2D extent{ 1280, 720 };
+	pSurfaceCapabilities->currentExtent = extent;
+	pSurfaceCapabilities->minImageExtent = extent;
+	pSurfaceCapabilities->maxImageExtent = extent;
+}
+
+void HeadlessSurfaceKHR::attachImage(PresentImage *image)
+{
+}
+
+void HeadlessSurfaceKHR::detachImage(PresentImage *image)
+{
+}
+
+VkResult HeadlessSurfaceKHR::present(PresentImage *image)
+{
+	return VK_SUCCESS;
+}
+
+}  // namespace vk
\ No newline at end of file

src/WSI/HeadlessSurfaceKHR.hpp

+// Copyright 2021 The SwiftShader Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SWIFTSHADER_HEADLESSSURFACEKHR_HPP
+#define SWIFTSHADER_HEADLESSSURFACEKHR_HPP
+
+#include "VkSurfaceKHR.hpp"
+
+namespace vk {
+
+class HeadlessSurfaceKHR : public SurfaceKHR, public ObjectBase<HeadlessSurfaceKHR, VkSurfaceKHR>
+{
+public:
+	HeadlessSurfaceKHR(const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo, void *mem);
+
+	static size_t ComputeRequiredAllocationSize(const VkHeadlessSurfaceCreateInfoEXT *pCreateInfo);
+
+	void destroySurface(const VkAllocationCallbacks *pAllocator) override;
+	void getSurfaceCapabilities(VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const override;
+	void attachImage(PresentImage *image) override;
+	void detachImage(PresentImage *image) override;
+	VkResult present(PresentImage *image) override;
+};
+
+}  // namespace vk
+#endif  //SWIFTSHADER_HEADLESSSURFACEKHR_HPP