More refactoring for Viewer

tools/viewer/sk_app/VulkanWindowContext.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"
-#include "VulkanTestContext.h"
+#include "VulkanWindowContext.h"
 
 #include "vk/GrVkInterface.h"
 #include "vk/GrVkUtil.h"
 #include "vk/GrVkTypes.h"
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 // windows wants to define this as CreateSemaphoreA or CreateSemaphoreW
 #undef CreateSemaphore
 #endif
 
 #define GET_PROC(F) f ## F = (PFN_vk ## F) vkGetInstanceProcAddr(instance, "vk" #F)
 #define GET_DEV_PROC(F) f ## F = (PFN_vk ## F) vkGetDeviceProcAddr(device, "vk" #F)
 
-VulkanTestContext::VulkanTestContext(void* platformData, int msaaSampleCount) 
-                                 : fSurface(VK_NULL_HANDLE)
-                                 , fSwapchain(VK_NULL_HANDLE)
-                                 , fCommandPool(VK_NULL_HANDLE)
-                                 , fBackbuffers(nullptr) {
+namespace sk_app {
+
+VulkanWindowContext::VulkanWindowContext(void* platformData, int msaaSampleCount)
+    : fSurface(VK_NULL_HANDLE)
+    , fSwapchain(VK_NULL_HANDLE)
+    , fCommandPool(VK_NULL_HANDLE)
+    , fBackbuffers(nullptr) {
 
     // any config code here (particularly for msaa)?
 
     this->initializeContext(platformData);
 }
 
-void VulkanTestContext::initializeContext(void* platformData) {
+void VulkanWindowContext::initializeContext(void* platformData) {
 
     fBackendContext.reset(GrVkBackendContext::Create(&fPresentQueueIndex, canPresent));
     if (!(fBackendContext->fExtensions & kKHR_surface_GrVkExtensionFlag) ||
         !(fBackendContext->fExtensions & kKHR_swapchain_GrVkExtensionFlag)) {
         fBackendContext.reset(nullptr);
         return;
     }
 
     VkInstance instance = fBackendContext->fInstance;
     VkDevice device = fBackendContext->fDevice;
     GET_PROC(DestroySurfaceKHR);
     GET_PROC(GetPhysicalDeviceSurfaceSupportKHR);
     GET_PROC(GetPhysicalDeviceSurfaceCapabilitiesKHR);
     GET_PROC(GetPhysicalDeviceSurfaceFormatsKHR);
     GET_PROC(GetPhysicalDeviceSurfacePresentModesKHR);
     GET_DEV_PROC(CreateSwapchainKHR);
     GET_DEV_PROC(DestroySwapchainKHR);
     GET_DEV_PROC(GetSwapchainImagesKHR);
     GET_DEV_PROC(AcquireNextImageKHR);
     GET_DEV_PROC(QueuePresentKHR);
 
-    fContext = GrContext::Create(kVulkan_GrBackend, (GrBackendContext)fBackendContext.get());
+    fContext = GrContext::Create(kVulkan_GrBackend, (GrBackendContext) fBackendContext.get());
 
     fSurface = createVkSurface(instance, platformData);
     if (VK_NULL_HANDLE == fSurface) {
         fBackendContext.reset(nullptr);
         return;
     }
 
     VkBool32 supported;
     VkResult res = fGetPhysicalDeviceSurfaceSupportKHR(fBackendContext->fPhysicalDevice,
                                                        fPresentQueueIndex, fSurface,
                                                        &supported);
     if (VK_SUCCESS != res) {
         this->destroyContext();
         return;
     }
 
     if (!this->createSwapchain(-1, -1)) {
         this->destroyContext();
         return;
     }
 
     // create presentQueue
     vkGetDeviceQueue(fBackendContext->fDevice, fPresentQueueIndex, 0, &fPresentQueue);
 }
 
-bool VulkanTestContext::createSwapchain(uint32_t width, uint32_t height)
-{
+bool VulkanWindowContext::createSwapchain(uint32_t width, uint32_t height) {
     // check for capabilities
     VkSurfaceCapabilitiesKHR caps;
     VkResult res = fGetPhysicalDeviceSurfaceCapabilitiesKHR(fBackendContext->fPhysicalDevice,
                                                             fSurface, &caps);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     uint32_t surfaceFormatCount;
     res = fGetPhysicalDeviceSurfaceFormatsKHR(fBackendContext->fPhysicalDevice, fSurface,
@@ skipping 13 matching lines @@
     uint32_t presentModeCount;
     res = fGetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice, fSurface,
                                                    &presentModeCount, nullptr);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     SkAutoMalloc presentModeAlloc(presentModeCount * sizeof(VkPresentModeKHR));
     VkPresentModeKHR* presentModes = (VkPresentModeKHR*)presentModeAlloc.get();
     res = fGetPhysicalDeviceSurfacePresentModesKHR(fBackendContext->fPhysicalDevice, fSurface,
-                                                    &presentModeCount, presentModes);
+                                                   &presentModeCount, presentModes);
     if (VK_SUCCESS != res) {
         return false;
     }
 
     VkExtent2D extent = caps.currentExtent;
     // use the hints
     if (extent.width == (uint32_t)-1) {
         extent.width = width;
         extent.height = height;
     }
@@ skipping 86 matching lines @@
         this->destroyBuffers();
 
         fDestroySwapchainKHR(fBackendContext->fDevice, swapchainCreateInfo.oldSwapchain, nullptr);
     }
 
     this->createBuffers(swapchainCreateInfo.imageFormat);
 
     return true;
 }
 
-void VulkanTestContext::createBuffers(VkFormat format) {
+void VulkanWindowContext::createBuffers(VkFormat format) {
     GrVkFormatToPixelConfig(format, &fPixelConfig);
 
     fGetSwapchainImagesKHR(fBackendContext->fDevice, fSwapchain, &fImageCount, nullptr);
     SkASSERT(fImageCount);
     fImages = new VkImage[fImageCount];
     fGetSwapchainImagesKHR(fBackendContext->fDevice, fSwapchain, &fImageCount, fImages);
 
     // set up initial image layouts and create surfaces
     fImageLayouts = new VkImageLayout[fImageCount];
     fSurfaces = new sk_sp<SkSurface>[fImageCount];
@@ skipping 67 matching lines @@
         GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                             CreateFence(fBackendContext->fDevice, &fenceInfo, nullptr,
                                         &fBackbuffers[i].fUsageFences[0]));
         GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                             CreateFence(fBackendContext->fDevice, &fenceInfo, nullptr,
                                         &fBackbuffers[i].fUsageFences[1]));
     }
     fCurrentBackbufferIndex = fImageCount;
 }
 
-void VulkanTestContext::destroyBuffers() {
+void VulkanWindowContext::destroyBuffers() {
 
     if (fBackbuffers) {
         for (uint32_t i = 0; i < fImageCount + 1; ++i) {
             GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
-                                WaitForFences(fBackendContext->fDevice, 2, 
+                                WaitForFences(fBackendContext->fDevice, 2,
                                               fBackbuffers[i].fUsageFences,
-                                true, UINT64_MAX));
+                                              true, UINT64_MAX));
             fBackbuffers[i].fImageIndex = -1;
             GR_VK_CALL(fBackendContext->fInterface,
                        DestroySemaphore(fBackendContext->fDevice,
                                         fBackbuffers[i].fAcquireSemaphore,
                                         nullptr));
             GR_VK_CALL(fBackendContext->fInterface,
                        DestroySemaphore(fBackendContext->fDevice,
                                         fBackbuffers[i].fRenderSemaphore,
                                         nullptr));
             GR_VK_CALL(fBackendContext->fInterface,
@@ skipping 10 matching lines @@
     fBackbuffers = nullptr;
 
     delete[] fSurfaces;
     fSurfaces = nullptr;
     delete[] fImageLayouts;
     fImageLayouts = nullptr;
     delete[] fImages;
     fImages = nullptr;
 }
 
-VulkanTestContext::~VulkanTestContext() {
+VulkanWindowContext::~VulkanWindowContext() {
     this->destroyContext();
 }
 
-void VulkanTestContext::destroyContext() {
+void VulkanWindowContext::destroyContext() {
     if (!fBackendContext.get()) {
         return;
     }
 
     GR_VK_CALL(fBackendContext->fInterface, DeviceWaitIdle(fBackendContext->fDevice));
 
     this->destroyBuffers();
 
     if (VK_NULL_HANDLE != fCommandPool) {
         GR_VK_CALL(fBackendContext->fInterface, DestroyCommandPool(fBackendContext->fDevice,
                                                                    fCommandPool, nullptr));
         fCommandPool = VK_NULL_HANDLE;
     }
 
     if (VK_NULL_HANDLE != fSwapchain) {
         fDestroySwapchainKHR(fBackendContext->fDevice, fSwapchain, nullptr);
         fSwapchain = VK_NULL_HANDLE;
     }
 
     if (VK_NULL_HANDLE != fSurface) {
         fDestroySurfaceKHR(fBackendContext->fInstance, fSurface, nullptr);
         fSurface = VK_NULL_HANDLE;
     }
 
     delete fContext;
 
     fBackendContext.reset(nullptr);
 }
 
-VulkanTestContext::BackbufferInfo* VulkanTestContext::getAvailableBackbuffer() {
+VulkanWindowContext::BackbufferInfo* VulkanWindowContext::getAvailableBackbuffer() {
     SkASSERT(fBackbuffers);
 
     ++fCurrentBackbufferIndex;
     if (fCurrentBackbufferIndex > fImageCount) {
         fCurrentBackbufferIndex = 0;
     }
 
     BackbufferInfo* backbuffer = fBackbuffers + fCurrentBackbufferIndex;
 
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         WaitForFences(fBackendContext->fDevice, 2, backbuffer->fUsageFences,
                                       true, UINT64_MAX));
     return backbuffer;
 }
 
-SkSurface* VulkanTestContext::getBackbufferSurface() {
+SkSurface* VulkanWindowContext::getBackbufferSurface() {
     BackbufferInfo* backbuffer = this->getAvailableBackbuffer();
     SkASSERT(backbuffer);
 
     // reset the fence
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         ResetFences(fBackendContext->fDevice, 2, backbuffer->fUsageFences));
     // semaphores should be in unsignaled state
 
     // acquire the image
     VkResult res = fAcquireNextImageKHR(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) {
         // tear swapchain down and try again
         if (!this->createSwapchain(0, 0)) {
             return nullptr;
         }
 
         // acquire the image
-        res = fAcquireNextImageKHR(fBackendContext->fDevice,  fSwapchain, UINT64_MAX,
+        res = fAcquireNextImageKHR(fBackendContext->fDevice, fSwapchain, UINT64_MAX,
                                    backbuffer->fAcquireSemaphore, VK_NULL_HANDLE,
                                    &backbuffer->fImageIndex);
 
         if (VK_SUCCESS != res) {
             return nullptr;
         }
     }
 
     // set up layout transfer from initial to color attachment
     VkImageLayout layout = fImageLayouts[backbuffer->fImageIndex];
     VkPipelineStageFlags srcStageMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout) ?
                                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT :
                                         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
     VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-    VkAccessFlags srcAccessMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout) ? 
+    VkAccessFlags srcAccessMask = (VK_IMAGE_LAYOUT_UNDEFINED == layout) ?
                                   0 : VK_ACCESS_MEMORY_READ_BIT;
     VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 
     VkImageMemoryBarrier imageMemoryBarrier = {
         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,   // sType
         NULL,                                     // pNext
         srcAccessMask,                            // outputMask
         dstAccessMask,                            // inputMask
         layout,                                   // oldLayout
         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // newLayout
         fPresentQueueIndex,                       // srcQueueFamilyIndex
         fBackendContext->fGraphicsQueueIndex,     // dstQueueFamilyIndex
         fImages[backbuffer->fImageIndex],         // image
         { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 } // subresourceRange
     };
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         ResetCommandBuffer(backbuffer->fTransitionCmdBuffers[0], 0));
     VkCommandBufferBeginInfo info;
     memset(&info, 0, sizeof(VkCommandBufferBeginInfo));
     info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     info.flags = 0;
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         BeginCommandBuffer(backbuffer->fTransitionCmdBuffers[0], &info));
 
-    GR_VK_CALL(fBackendContext->fInterface, 
-                CmdPipelineBarrier(backbuffer->fTransitionCmdBuffers[0], 
-                                    srcStageMask, dstStageMask, 0,
-                                    0, nullptr,
-                                    0, nullptr,
-                                    1, &imageMemoryBarrier));
+    GR_VK_CALL(fBackendContext->fInterface,
+               CmdPipelineBarrier(backbuffer->fTransitionCmdBuffers[0],
+                                  srcStageMask, dstStageMask, 0,
+                                  0, nullptr,
+                                  0, nullptr,
+                                  1, &imageMemoryBarrier));
 
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
-                        EndCommandBuffer(backbuffer->fTransitionCmdBuffers[0]));  
+                        EndCommandBuffer(backbuffer->fTransitionCmdBuffers[0]));
 
     VkPipelineStageFlags waitDstStageFlags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
     // insert the layout transfer into the queue and wait on the acquire
     VkSubmitInfo submitInfo;
     memset(&submitInfo, 0, sizeof(VkSubmitInfo));
     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submitInfo.waitSemaphoreCount = 1;
     submitInfo.pWaitSemaphores = &backbuffer->fAcquireSemaphore;
     submitInfo.pWaitDstStageMask = &waitDstStageFlags;
     submitInfo.commandBufferCount = 1;
     submitInfo.pCommandBuffers = &backbuffer->fTransitionCmdBuffers[0];
     submitInfo.signalSemaphoreCount = 0;
-    
+
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
-                        QueueSubmit(fBackendContext->fQueue, 1, &submitInfo, 
+                        QueueSubmit(fBackendContext->fQueue, 1, &submitInfo,
                                     backbuffer->fUsageFences[0]));
 
     return fSurfaces[backbuffer->fImageIndex].get();
 }
 
 
-void VulkanTestContext::swapBuffers() {
+void VulkanWindowContext::swapBuffers() {
 
     BackbufferInfo* backbuffer = fBackbuffers + fCurrentBackbufferIndex;
 
     VkImageLayout layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
     VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
     VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
     VkAccessFlags srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
     VkAccessFlags dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
 
     VkImageMemoryBarrier imageMemoryBarrier = {
@@ skipping 10 matching lines @@
     };
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         ResetCommandBuffer(backbuffer->fTransitionCmdBuffers[1], 0));
     VkCommandBufferBeginInfo info;
     memset(&info, 0, sizeof(VkCommandBufferBeginInfo));
     info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     info.flags = 0;
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         BeginCommandBuffer(backbuffer->fTransitionCmdBuffers[1], &info));
     GR_VK_CALL(fBackendContext->fInterface,
-                CmdPipelineBarrier(backbuffer->fTransitionCmdBuffers[1],
-                srcStageMask, dstStageMask, 0,
-                0, nullptr,
-                0, nullptr,
-                1, &imageMemoryBarrier));
+               CmdPipelineBarrier(backbuffer->fTransitionCmdBuffers[1],
+                                  srcStageMask, dstStageMask, 0,
+                                  0, nullptr,
+                                  0, nullptr,
+                                  1, &imageMemoryBarrier));
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
                         EndCommandBuffer(backbuffer->fTransitionCmdBuffers[1]));
 
     fImageLayouts[backbuffer->fImageIndex] = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
 
     // insert the layout transfer into the queue and wait on the acquire
     VkSubmitInfo submitInfo;
     memset(&submitInfo, 0, sizeof(VkSubmitInfo));
     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submitInfo.waitSemaphoreCount = 0;
     submitInfo.pWaitDstStageMask = 0;
     submitInfo.commandBufferCount = 1;
     submitInfo.pCommandBuffers = &backbuffer->fTransitionCmdBuffers[1];
     submitInfo.signalSemaphoreCount = 1;
     submitInfo.pSignalSemaphores = &backbuffer->fRenderSemaphore;
 
     GR_VK_CALL_ERRCHECK(fBackendContext->fInterface,
-                        QueueSubmit(fBackendContext->fQueue, 1, &submitInfo, 
+                        QueueSubmit(fBackendContext->fQueue, 1, &submitInfo,
                                     backbuffer->fUsageFences[1]));
 
     // Submit present operation to present queue
     const VkPresentInfoKHR presentInfo =
     {
         VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, // sType
         NULL, // pNext
         1, // waitSemaphoreCount
         &backbuffer->fRenderSemaphore, // pWaitSemaphores
         1, // swapchainCount
         &fSwapchain, // pSwapchains
         &backbuffer->fImageIndex, // pImageIndices
         NULL // pResults
     };
 
     fQueuePresentKHR(fPresentQueue, &presentInfo);
 
 }
+
+}   //namespace sk_app