Revise WSI setup.

src/gpu/vk/GrVkBackendContext.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "vk/GrVkBackendContext.h"
 #include "vk/GrVkExtensions.h"
 #include "vk/GrVkInterface.h"
@@ skipping 17 matching lines @@
     //"VK_LAYER_LUNARG_api_dump",
     //"VK_LAYER_LUNARG_vktrace",
     //"VK_LAYER_LUNARG_screenshot",
 };
 #endif
 
 // the minimum version of Vulkan supported
 const uint32_t kGrVkMinimumVersion = VK_MAKE_VERSION(1, 0, 8);
 
 // Create the base Vulkan objects needed by the GrVkGpu object
-const GrVkBackendContext* GrVkBackendContext::Create() {
+const GrVkBackendContext* GrVkBackendContext::Create(uint32_t* presentQueueIndexPtr,
+                             bool(*canPresent)(VkInstance, VkPhysicalDevice, uint32_t queueIndex)) {
     VkPhysicalDevice physDev;
     VkDevice device;
     VkInstance inst;
     VkResult err;
 
     const VkApplicationInfo app_info = {
         VK_STRUCTURE_TYPE_APPLICATION_INFO, // sType
         nullptr,                            // pNext
         "vktest",                           // pApplicationName
         0,                                  // applicationVersion
@@ skipping 85 matching lines @@
     vkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, nullptr);
     SkASSERT(queueCount >= 1);
 
     SkAutoMalloc queuePropsAlloc(queueCount * sizeof(VkQueueFamilyProperties));
     // now get the actual queue props
     VkQueueFamilyProperties* queueProps = (VkQueueFamilyProperties*)queuePropsAlloc.get();
 
     vkGetPhysicalDeviceQueueFamilyProperties(physDev, &queueCount, queueProps);
 
     // iterate to find the graphics queue
-    uint32_t graphicsQueueIndex = -1;
+    uint32_t graphicsQueueIndex = queueCount;
     for (uint32_t i = 0; i < queueCount; i++) {
         if (queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
             graphicsQueueIndex = i;
             break;
         }
     }
     SkASSERT(graphicsQueueIndex < queueCount);
 
+    // iterate to find the present queue, if needed
+    uint32_t presentQueueIndex = graphicsQueueIndex;
+    if (presentQueueIndexPtr && canPresent) {
+        for (uint32_t i = 0; i < queueCount; i++) {
+            if (canPresent(inst, physDev, i)) {
+                presentQueueIndex = i;
+                break;
+            }
+        }
+        SkASSERT(presentQueueIndex < queueCount);
+        *presentQueueIndexPtr = presentQueueIndex;
+    }
+
     extensions.initDevice(kGrVkMinimumVersion, inst, physDev);
 
     SkTArray<const char*> deviceLayerNames;
     SkTArray<const char*> deviceExtensionNames;
 #ifdef ENABLE_VK_LAYERS
     for (size_t i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
         if (extensions.hasDeviceLayer(kDebugLayerNames[i])) {
             deviceLayerNames.push_back(kDebugLayerNames[i]);
         }
     }
@@ skipping 21 matching lines @@
     if (deviceFeatures.dualSrcBlend) {
         featureFlags |= kDualSrcBlend_GrVkFeatureFlag;
     }
     if (deviceFeatures.sampleRateShading) {
         featureFlags |= kSampleRateShading_GrVkFeatureFlag;
     }
 
     float queuePriorities[1] = { 0.0 };
     // Here we assume no need for swapchain queue
     // If one is needed, the client will need its own setup code
-    const VkDeviceQueueCreateInfo queueInfo = {
-        VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
-        nullptr,                                    // pNext
-        0,                                          // VkDeviceQueueCreateFlags
-        graphicsQueueIndex,                         // queueFamilyIndex
-        1,                                          // queueCount
-        queuePriorities,                            // pQueuePriorities
+    const VkDeviceQueueCreateInfo queueInfo[2] = {
+        {
+            VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
+            nullptr,                                    // pNext
+            0,                                          // VkDeviceQueueCreateFlags
+            graphicsQueueIndex,                         // queueFamilyIndex
+            1,                                          // queueCount
+            queuePriorities,                            // pQueuePriorities
+        },
+        {
+            VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
+            nullptr,                                    // pNext
+            0,                                          // VkDeviceQueueCreateFlags
+            presentQueueIndex,                          // queueFamilyIndex
+            1,                                          // queueCount
+            queuePriorities,                            // pQueuePriorities
+        }
     };
+    uint32_t queueInfoCount = (presentQueueIndex != graphicsQueueIndex) ? 2 : 1;
+
     const VkDeviceCreateInfo deviceInfo = {
         VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,    // sType
         nullptr,                                 // pNext
         0,                                       // VkDeviceCreateFlags
-        1,                                       // queueCreateInfoCount
-        &queueInfo,                              // pQueueCreateInfos
+        queueInfoCount,                          // queueCreateInfoCount
+        queueInfo,                               // pQueueCreateInfos
         (uint32_t) deviceLayerNames.count(),     // layerCount
         deviceLayerNames.begin(),                // ppEnabledLayerNames
         (uint32_t) deviceExtensionNames.count(), // extensionCount
         deviceExtensionNames.begin(),            // ppEnabledExtensionNames
         &deviceFeatures                          // ppEnabledFeatures
     };
 
     err = vkCreateDevice(physDev, &deviceInfo, nullptr, &device);
     if (err) {
         SkDebugf("CreateDevice failed: %d\n", err);
         vkDestroyInstance(inst, nullptr);
         return nullptr;
     }
 
     VkQueue queue;
     vkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);
 
     GrVkBackendContext* ctx = new GrVkBackendContext();
     ctx->fInstance = inst;
     ctx->fPhysicalDevice = physDev;
     ctx->fDevice = device;
     ctx->fQueue = queue;
-    ctx->fQueueFamilyIndex = graphicsQueueIndex;
+    ctx->fGraphicsQueueIndex = graphicsQueueIndex;
     ctx->fMinAPIVersion = kGrVkMinimumVersion;
     ctx->fExtensions = extensionFlags;
     ctx->fFeatures = featureFlags;
     ctx->fInterface.reset(GrVkCreateInterface(inst, device, extensionFlags));
 
     return ctx;
 }
 
 GrVkBackendContext::~GrVkBackendContext() {
     vkDeviceWaitIdle(fDevice);
     vkDestroyDevice(fDevice, nullptr);
     fDevice = VK_NULL_HANDLE;
     vkDestroyInstance(fInstance, nullptr);
     fInstance = VK_NULL_HANDLE;
 }