Vulkan: Add support for headless surface

src/libANGLE/Display.cpp

@@ -367,11 +367,10 @@ rx::DisplayImpl *CreateDisplayFromAttribs(EGLAttrib displayType,
             {
                 impl = rx::CreateVulkanSimpleDisplay(state);
             }
-            else if (platformType == EGL_PLATFORM_VULKAN_DISPLAY_MODE_HEADLESS_ANGLE)
+            else if (platformType == EGL_PLATFORM_VULKAN_DISPLAY_MODE_HEADLESS_ANGLE &&
+                     rx::IsVulkanHeadlessDisplayAvailable())
             {
-                // TODO: anglebug.com/5260
-                // Add support for headless rendering
-                UNIMPLEMENTED();
+                impl = rx::CreateVulkanHeadlessDisplay(state);
             }
             else
             {

src/libANGLE/renderer/vulkan/BUILD.gn

@@ -107,6 +107,10 @@ if (is_linux) {
     "display/DisplayVkSimple.h",
     "display/WindowSurfaceVkSimple.cpp",
     "display/WindowSurfaceVkSimple.h",
+    "headless/DisplayVkHeadless.cpp",
+    "headless/DisplayVkHeadless.h",
+    "headless/WindowSurfaceVkHeadless.cpp",
+    "headless/WindowSurfaceVkHeadless.h",
   ]
 }
 

src/libANGLE/renderer/vulkan/DisplayVk_api.h

@@ -25,6 +25,9 @@ DisplayImpl *CreateVulkanXcbDisplay(const egl::DisplayState &state);
 
 bool IsVulkanSimpleDisplayAvailable();
 DisplayImpl *CreateVulkanSimpleDisplay(const egl::DisplayState &state);
+
+bool IsVulkanHeadlessDisplayAvailable();
+DisplayImpl *CreateVulkanHeadlessDisplay(const egl::DisplayState &state);
 #endif  // defined(ANGLE_PLATFORM_LINUX)
 
 #if defined(ANGLE_PLATFORM_ANDROID)

src/libANGLE/renderer/vulkan/headless/DisplayVkHeadless.cpp

+//
+// Copyright 2020 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// DisplayVkHeadless.cpp:
+//    Implements the class methods for DisplayVkHeadless.
+//
+
+#include "DisplayVkHeadless.h"
+#include "WindowSurfaceVkHeadless.h"
+
+#include "libANGLE/Display.h"
+#include "libANGLE/renderer/vulkan/RendererVk.h"
+#include "libANGLE/renderer/vulkan/vk_caps_utils.h"
+
+namespace rx
+{
+
+DisplayVkHeadless::DisplayVkHeadless(const egl::DisplayState &state) : DisplayVk(state) {}
+
+void DisplayVkHeadless::terminate()
+{
+    DisplayVk::terminate();
+}
+
+bool DisplayVkHeadless::isValidNativeWindow(EGLNativeWindowType window) const
+{
+    return true;
+}
+
+SurfaceImpl *DisplayVkHeadless::createWindowSurfaceVk(const egl::SurfaceState &state,
+                                                      EGLNativeWindowType window)
+{
+    return new WindowSurfaceVkHeadless(state, window);
+}
+
+egl::ConfigSet DisplayVkHeadless::generateConfigs()
+{
+    constexpr GLenum kColorFormats[] = {GL_RGBA8, GL_BGRA8_EXT, GL_RGB565, GL_RGB8};
+
+    return egl_vk::GenerateConfigs(kColorFormats, egl_vk::kConfigDepthStencilFormats, this);
+}
+
+void DisplayVkHeadless::checkConfigSupport(egl::Config *config) {}
+
+const char *DisplayVkHeadless::getWSIExtension() const
+{
+    return VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME;
+}
+
+bool IsVulkanHeadlessDisplayAvailable()
+{
+    return true;
+}
+
+DisplayImpl *CreateVulkanHeadlessDisplay(const egl::DisplayState &state)
+{
+    return new DisplayVkHeadless(state);
+}
+
+}  // namespace rx

src/libANGLE/renderer/vulkan/headless/DisplayVkHeadless.h

+//
+// Copyright 2020 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// DisplayVkHeadless.h:
+//    Defines the class interface for DisplayVkHeadless, implementing
+//    DisplayVk for Linux via VK_EXT_headless_surface.
+//
+
+#ifndef LIBANGLE_RENDERER_VULKAN_DISPLAY_DISPLAYVKHEADLESS_H_
+#define LIBANGLE_RENDERER_VULKAN_DISPLAY_DISPLAYVKHEADLESS_H_
+
+#include "libANGLE/renderer/vulkan/DisplayVk.h"
+
+namespace rx
+{
+
+class DisplayVkHeadless : public DisplayVk
+{
+  public:
+    DisplayVkHeadless(const egl::DisplayState &state);
+    void terminate() override;
+
+    bool isValidNativeWindow(EGLNativeWindowType window) const override;
+
+    SurfaceImpl *createWindowSurfaceVk(const egl::SurfaceState &state,
+                                       EGLNativeWindowType window) override;
+
+    egl::ConfigSet generateConfigs() override;
+    void checkConfigSupport(egl::Config *config) override;
+
+    const char *getWSIExtension() const override;
+
+  private:
+    std::vector<VkSurfaceFormatKHR> mSurfaceFormats;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_VULKAN_DISPLAY_DISPLAYVKHEADLESS_H_

src/libANGLE/renderer/vulkan/headless/WindowSurfaceVkHeadless.cpp

+//
+// Copyright 2020 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// WindowSurfaceVkHeadless.cpp:
+//    Implements the class methods for WindowSurfaceVkHeadless.
+//
+
+#include "WindowSurfaceVkHeadless.h"
+#include "libANGLE/renderer/vulkan/RendererVk.h"
+
+namespace rx
+{
+
+WindowSurfaceVkHeadless::WindowSurfaceVkHeadless(const egl::SurfaceState &surfaceState,
+                                                 EGLNativeWindowType window)
+    : WindowSurfaceVk(surfaceState, window)
+{}
+
+WindowSurfaceVkHeadless::~WindowSurfaceVkHeadless() {}
+
+angle::Result WindowSurfaceVkHeadless::createSurfaceVk(vk::Context *context,
+                                                       gl::Extents *extentsOut)
+{
+    RendererVk *renderer = context->getRenderer();
+    ASSERT(renderer != nullptr);
+    VkInstance instance = renderer->getInstance();
+
+    VkHeadlessSurfaceCreateInfoEXT createInfo = {};
+    createInfo.sType                          = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT;
+
+    ANGLE_VK_TRY(context, vkCreateHeadlessSurfaceEXT(instance, &createInfo, nullptr, &mSurface));
+
+    return getCurrentWindowSize(context, extentsOut);
+}
+
+angle::Result WindowSurfaceVkHeadless::getCurrentWindowSize(vk::Context *context,
+                                                            gl::Extents *extentsOut)
+{
+    const VkPhysicalDevice &physicalDevice = context->getRenderer()->getPhysicalDevice();
+    ANGLE_VK_TRY(context, vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, mSurface,
+                                                                    &mSurfaceCaps));
+
+    // Spec: "For headless surfaces, currentExtent is the reserved value (0xFFFFFFFF, 0xFFFFFFFF).
+    // Whatever the application sets a swapchain's imageExtent to will be the size of the surface,
+    // after the first image is presented."
+    // For ANGLE, in headless mode, we share the same 'SimpleDisplayWindow' structure with front
+    // EGL window info to define the vulkan backend surface/image extents.
+    angle::vk::SimpleDisplayWindow *simpleWindow =
+        reinterpret_cast<angle::vk::SimpleDisplayWindow *>(mNativeWindowType);
+
+    // Update surface extent before output the new extent.
+    mSurfaceCaps.currentExtent.width  = simpleWindow->width;
+    mSurfaceCaps.currentExtent.height = simpleWindow->height;
+
+    *extentsOut =
+        gl::Extents(mSurfaceCaps.currentExtent.width, mSurfaceCaps.currentExtent.height, 1);
+
+    return angle::Result::Continue;
+}
+
+}  // namespace rx

src/libANGLE/renderer/vulkan/headless/WindowSurfaceVkHeadless.h

+//
+// Copyright 2020 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// WindowSurfaceVkHeadless.h:
+//    Defines the class interface for WindowSurfaceVkHeadless, implementing WindowSurfaceVk.
+//
+
+#ifndef LIBANGLE_RENDERER_VULKAN_DISPLAY_WINDOWSURFACEVKHEADLESS_H_
+#define LIBANGLE_RENDERER_VULKAN_DISPLAY_WINDOWSURFACEVKHEADLESS_H_
+
+#include "libANGLE/renderer/vulkan/SurfaceVk.h"
+
+namespace rx
+{
+
+class WindowSurfaceVkHeadless : public WindowSurfaceVk
+{
+  public:
+    WindowSurfaceVkHeadless(const egl::SurfaceState &surfaceState, EGLNativeWindowType window);
+    ~WindowSurfaceVkHeadless() final;
+
+  private:
+    angle::Result createSurfaceVk(vk::Context *context, gl::Extents *extentsOut) override;
+    angle::Result getCurrentWindowSize(vk::Context *context, gl::Extents *extentsOut) override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_VULKAN_DISPLAY_WINDOWSURFACEVKHEADLESS_H_