Some more improvements/fixes to the VulkanViewer

tools/vulkan/VulkanTestContext.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 "GrContext.h"
 #include "SkSurface.h"
@@ skipping 48 matching lines @@
                                                       queueProps));
 
     // iterate to find the present queue
     fPresentQueueIndex = -1;
     for (uint32_t i = 0; i < queueCount; i++) {
         if ((queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) && canPresent(i)) {
             fPresentQueueIndex = i;
             break;
         }
     }
-    SkASSERT(0 <= fPresentQueueIndex && fPresentQueueIndex < queueCount);
+    SkASSERT(fPresentQueueIndex < queueCount);
 
     VkBool32 supported;
     VkResult res = GR_VK_CALL(fBackendContext->fInterface,
                               GetPhysicalDeviceSurfaceSupportKHR(fBackendContext->fPhysicalDevice,
                                                                  fPresentQueueIndex,
                                                                  fSurface,
                                                                  &supported));
     if (VK_SUCCESS != res) {
         this->destroyContext();
         return;
@@ skipping 97 matching lines @@
                                    VK_IMAGE_USAGE_TRANSFER_DST_BIT;
     SkASSERT((caps.supportedUsageFlags & usageFlags) == usageFlags);
     SkASSERT(caps.supportedTransforms & caps.currentTransform);
     SkASSERT(caps.supportedCompositeAlpha & (VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR |
                                              VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR));
     VkCompositeAlphaFlagBitsKHR composite_alpha =
         (caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) ?
                                         VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR :
                                         VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
 
-    // FIFO is the only mode universally supported
+    // If mailbox mode is available, use it, as it is the lowest-latency non-
+    // tearing mode. If not, fall back to FIFO which is always available.
     VkPresentModeKHR mode = VK_PRESENT_MODE_FIFO_KHR;
-    bool vsync = false;
     for (uint32_t i = 0; i < presentModeCount; ++i) {
-        if ((vsync && VK_PRESENT_MODE_MAILBOX_KHR == presentModes[i]) ||
-            (!vsync && VK_PRESENT_MODE_IMMEDIATE_KHR == presentModes[i])) {
+        // use mailbox
+        if (VK_PRESENT_MODE_MAILBOX_KHR == presentModes[i]) {
             mode = presentModes[i];
+            break;
         }
     }
 
     VkSwapchainCreateInfoKHR swapchainCreateInfo;
     memset(&swapchainCreateInfo, 0, sizeof(VkSwapchainCreateInfoKHR));
     swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
     swapchainCreateInfo.surface = fSurface;
     swapchainCreateInfo.minImageCount = imageCount;
     swapchainCreateInfo.imageFormat = surfaceFormats[0].format;       // for now, use the first one
     swapchainCreateInfo.imageColorSpace = surfaceFormats[0].colorSpace;
@@ skipping 236 matching lines @@
     // acquire the image
     VkResult res = GR_VK_CALL(fBackendContext->fInterface,
                               AcquireNextImageKHR(fBackendContext->fDevice, 
                                                   fSwapchain,
                                                   UINT64_MAX,
                                                   backbuffer->fAcquireSemaphore,
                                                   VK_NULL_HANDLE,
                                                   &backbuffer->fImageIndex));
     if (VK_ERROR_SURFACE_LOST_KHR == res) {
         // need to figure out how to create a new vkSurface without the platformData*
+        // maybe use attach somehow? but need a Window
         return nullptr;
     }
-    if (VK_ERROR_OUT_OF_DATE_KHR == res || VK_ERROR_SURFACE_LOST_KHR == res) {
+    if (VK_ERROR_OUT_OF_DATE_KHR == res) {
         // tear swapchain down and try again
         if (!this->createSwapchain(0, 0)) {
             return nullptr;
         }
 
         // acquire the image
         res = GR_VK_CALL(fBackendContext->fInterface,
                          AcquireNextImageKHR(fBackendContext->fDevice,
                                              fSwapchain,
                                              UINT64_MAX,
@@ skipping 132 matching lines @@
         1, // swapchainCount
         &fSwapchain, // pSwapchains
         &backbuffer->fImageIndex, // pImageIndices
         NULL // pResults
     };
 
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         QueuePresentKHR(fPresentQueue, &presentInfo));
 
 }