Vulkan: Add 565 and validate pixel formats: Windows

src/libANGLE/renderer/vulkan/win32/DisplayVkWin32.cpp

@@ -8,8 +8,11 @@
 //
 
 #include "libANGLE/renderer/vulkan/win32/DisplayVkWin32.h"
+#include "libANGLE/renderer/vulkan/DisplayVk.h"
+#include "libANGLE/renderer/vulkan/RendererVk.h"
 
 #include <vulkan/vulkan.h>
+#include <windows.h>
 
 #include "libANGLE/renderer/vulkan/vk_caps_utils.h"
 #include "libANGLE/renderer/vulkan/win32/WindowSurfaceVkWin32.h"
@@ -17,7 +20,31 @@
 namespace rx
 {
 
-DisplayVkWin32::DisplayVkWin32(const egl::DisplayState &state) : DisplayVk(state) {}
+DisplayVkWin32::DisplayVkWin32(const egl::DisplayState &state)
+    : DisplayVk(state), mWindowClass(NULL), mDummyWindow(nullptr)
+{}
+
+DisplayVkWin32::~DisplayVkWin32() {}
+
+void DisplayVkWin32::terminate()
+{
+    if (mDummyWindow)
+    {
+        DestroyWindow(mDummyWindow);
+        mDummyWindow = nullptr;
+    }
+    if (mWindowClass)
+    {
+        if (!UnregisterClassA(reinterpret_cast<const char *>(mWindowClass),
+                              GetModuleHandle(nullptr)))
+        {
+            WARN() << "Failed to unregister ANGLE window class: " << gl::FmtHex(mWindowClass);
+        }
+        mWindowClass = NULL;
+    }
+
+    DisplayVk::terminate();
+}
 
 bool DisplayVkWin32::isValidNativeWindow(EGLNativeWindowType window) const
 {
@@ -30,17 +57,109 @@ SurfaceImpl *DisplayVkWin32::createWindowSurfaceVk(const egl::SurfaceState &stat
     return new WindowSurfaceVkWin32(state, window);
 }
 
+egl::Error DisplayVkWin32::initialize(egl::Display *display)
+{
+    ANGLE_TRY(DisplayVk::initialize(display));
+
+    HINSTANCE hinstance = GetModuleHandle(nullptr);
+
+    std::ostringstream stream;
+    stream << "ANGLE DisplayVkWin32 " << gl::FmtHex(display) << " Intermediate Window Class";
+
+    const LPSTR idcArrow  = MAKEINTRESOURCEA(32512);
+    std::string className = stream.str();
+    WNDCLASSA wndClass;
+    if (!GetClassInfoA(hinstance, className.c_str(), &wndClass))
+    {
+        WNDCLASSA intermediateClassDesc     = {};
+        intermediateClassDesc.style         = CS_OWNDC;
+        intermediateClassDesc.lpfnWndProc   = DefWindowProcA;
+        intermediateClassDesc.cbClsExtra    = 0;
+        intermediateClassDesc.cbWndExtra    = 0;
+        intermediateClassDesc.hInstance     = GetModuleHandle(nullptr);
+        intermediateClassDesc.hIcon         = nullptr;
+        intermediateClassDesc.hCursor       = LoadCursorA(nullptr, idcArrow);
+        intermediateClassDesc.hbrBackground = 0;
+        intermediateClassDesc.lpszMenuName  = nullptr;
+        intermediateClassDesc.lpszClassName = className.c_str();
+        mWindowClass                        = RegisterClassA(&intermediateClassDesc);
+        if (!mWindowClass)
+        {
+            return egl::EglNotInitialized()
+                   << "Failed to register intermediate OpenGL window class \"" << className.c_str()
+                   << "\":" << gl::FmtErr(HRESULT_CODE(GetLastError()));
+        }
+    }
+
+    mDummyWindow =
+        CreateWindowExA(0, reinterpret_cast<const char *>(mWindowClass), "ANGLE Dummy Window",
+                        WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+                        CW_USEDEFAULT, nullptr, nullptr, nullptr, nullptr);
+    if (!mDummyWindow)
+    {
+        return egl::EglNotInitialized() << "Failed to create dummy OpenGL window.";
+    }
+
+    VkSurfaceKHR surfaceVk;
+    VkWin32SurfaceCreateInfoKHR info = {VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, nullptr, 0,
+                                        GetModuleHandle(nullptr), mDummyWindow};
+
+    VkInstance instance         = mRenderer->getInstance();
+    VkPhysicalDevice physDevice = mRenderer->getPhysicalDevice();
+
+    if (vkCreateWin32SurfaceKHR(instance, &info, nullptr, &surfaceVk) != VK_SUCCESS)
+    {
+        return egl::EglNotInitialized() << "vkCreateWin32SurfaceKHR failed";
+    }
+    uint32_t surfaceFormatCount;
+
+    if (vkGetPhysicalDeviceSurfaceFormatsKHR(physDevice, surfaceVk, &surfaceFormatCount, nullptr) !=
+        VK_SUCCESS)
+    {
+        return egl::EglNotInitialized() << "vkGetPhysicalDeviceSurfaceFormatsKHR failed";
+    }
+    mSurfaceFormats.resize(surfaceFormatCount);
+    if (vkGetPhysicalDeviceSurfaceFormatsKHR(physDevice, surfaceVk, &surfaceFormatCount,
+                                             mSurfaceFormats.data()) != VK_SUCCESS)
+    {
+        return egl::EglNotInitialized() << "vkGetPhysicalDeviceSurfaceFormatsKHR (2nd) failed";
+    }
+    vkDestroySurfaceKHR(instance, surfaceVk, nullptr);
+
+    DestroyWindow(mDummyWindow);
+    mDummyWindow = nullptr;
+
+    return egl::NoError();
+}
+
 egl::ConfigSet DisplayVkWin32::generateConfigs()
 {
-    constexpr GLenum kColorFormats[] = {GL_BGRA8_EXT, GL_BGRX8_ANGLEX};
+    constexpr GLenum kColorFormats[] = {GL_RGB565, GL_BGRA8_EXT, GL_BGRX8_ANGLEX};
     return egl_vk::GenerateConfigs(kColorFormats, egl_vk::kConfigDepthStencilFormats, this);
 }
 
 bool DisplayVkWin32::checkConfigSupport(egl::Config *config)
 {
-    // TODO(geofflang): Test for native support and modify the config accordingly.
-    // anglebug.com/2692
-    return true;
+    const vk::Format &formatVk = this->getRenderer()->getFormat(config->renderTargetFormat);
+    VkFormat nativeFormat      = formatVk.vkImageFormat;
+
+    // If the format list includes just one entry of VK_FORMAT_UNDEFINED,
+    // the surface has no preferred format.  Otherwise, at least one
+    // supported format will be returned.
+    if (mSurfaceFormats.size() == 1u && mSurfaceFormats[0].format == VK_FORMAT_UNDEFINED)
+    {
+        return true;
+    }
+
+    for (const VkSurfaceFormatKHR &surfaceFormat : mSurfaceFormats)
+    {
+        if (surfaceFormat.format == nativeFormat)
+        {
+            return true;
+        }
+    }
+
+    return false;
 }
 
 const char *DisplayVkWin32::getWSIExtension() const

src/libANGLE/renderer/vulkan/win32/DisplayVkWin32.h

@@ -18,6 +18,10 @@ class DisplayVkWin32 : public DisplayVk
 {
   public:
     DisplayVkWin32(const egl::DisplayState &state);
+    ~DisplayVkWin32() override;
+
+    egl::Error initialize(egl::Display *display) override;
+    void terminate() override;
 
     bool isValidNativeWindow(EGLNativeWindowType window) const override;
 
@@ -28,6 +32,11 @@ class DisplayVkWin32 : public DisplayVk
     bool checkConfigSupport(egl::Config *config) override;
 
     const char *getWSIExtension() const override;
+
+  private:
+    ATOM mWindowClass;
+    HWND mDummyWindow;
+    std::vector<VkSurfaceFormatKHR> mSurfaceFormats;
 };
 
 }  // namespace rx