Add OpenGL context to 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 "GrRenderTarget.h"
 #include "SkSurface.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)
 
 namespace sk_app {
 
 VulkanWindowContext::VulkanWindowContext(void* platformData, const DisplayParams& params)
-    : fSurface(VK_NULL_HANDLE)
+    : WindowContext()
+    , fSurface(VK_NULL_HANDLE)
     , fSwapchain(VK_NULL_HANDLE)
+    , fImages(nullptr)
+    , fImageLayouts(nullptr)
+    , fSurfaces(nullptr)
     , fCommandPool(VK_NULL_HANDLE)
     , fBackbuffers(nullptr) {
 
     // any config code here (particularly for msaa)?
 
     this->initializeContext(platformData, params);
 }
 
 void VulkanWindowContext::initializeContext(void* platformData, const DisplayParams& params) {
 
@@ skipping 203 matching lines @@
 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];
+    fRenderTargets = new sk_sp<GrRenderTarget>[fImageCount];
     fSurfaces = new sk_sp<SkSurface>[fImageCount];
     for (uint32_t i = 0; i < fImageCount; ++i) {
         fImageLayouts[i] = VK_IMAGE_LAYOUT_UNDEFINED;
 
         GrBackendRenderTargetDesc desc;
         GrVkImageInfo info;
         info.fImage = fImages[i];
         info.fAlloc = VK_NULL_HANDLE;
         info.fImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
         info.fImageTiling = VK_IMAGE_TILING_OPTIMAL;
         info.fFormat = format;
         info.fLevelCount = 1;
         desc.fWidth = fWidth;
         desc.fHeight = fHeight;
         desc.fConfig = fPixelConfig;
         desc.fOrigin = kTopLeft_GrSurfaceOrigin;
         desc.fSampleCnt = 0;
         desc.fStencilBits = 0;
         desc.fRenderTargetHandle = (GrBackendObject) &info;
-        SkSurfaceProps props(GrPixelConfigIsSRGB(fPixelConfig)
-                             ? SkSurfaceProps::kGammaCorrect_Flag : 0,
-                             kUnknown_SkPixelGeometry);
-        fSurfaces[i] = SkSurface::MakeFromBackendRenderTarget(fContext, desc, &props);
+        fRenderTargets[i].reset(fContext->textureProvider()->wrapBackendRenderTarget(desc));
+
+        fSurfaces[i] = this->createRenderSurface(fRenderTargets[i], 24);
     }
 
     // create the command pool for the command buffers
     if (VK_NULL_HANDLE == fCommandPool) {
         VkCommandPoolCreateInfo commandPoolInfo;
         memset(&commandPoolInfo, 0, sizeof(VkCommandPoolCreateInfo));
         commandPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
         // this needs to be on the render queue
         commandPoolInfo.queueFamilyIndex = fBackendContext->fGraphicsQueueIndex;
         commandPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
@@ skipping 68 matching lines @@
             GR_VK_CALL(fBackendContext->fInterface,
                        DestroyFence(fBackendContext->fDevice, fBackbuffers[i].fUsageFences[0], 0));
             GR_VK_CALL(fBackendContext->fInterface,
                        DestroyFence(fBackendContext->fDevice, fBackbuffers[i].fUsageFences[1], 0));
         }
     }
 
     delete[] fBackbuffers;
     fBackbuffers = nullptr;
 
+    // Does this actually free the surfaces?
     delete[] fSurfaces;
     fSurfaces = nullptr;
+    delete[] fRenderTargets;
+    fRenderTargets = nullptr;
     delete[] fImageLayouts;
     fImageLayouts = nullptr;
     delete[] fImages;
     fImages = nullptr;
 }
 
 VulkanWindowContext::~VulkanWindowContext() {
     this->destroyContext();
 }
 
@@ skipping 15 matching lines @@
     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;
+    fContext->abandonContext();
+    fContext->unref();
 
     fBackendContext.reset(nullptr);
 }
 
 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* VulkanWindowContext::getBackbufferSurface() {
+sk_sp<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,
@@ skipping 70 matching lines @@
     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,
                                     backbuffer->fUsageFences[0]));
 
-    return fSurfaces[backbuffer->fImageIndex].get();
+    return sk_ref_sp(fSurfaces[backbuffer->fImageIndex].get());
 }
 
-
 void VulkanWindowContext::swapBuffers() {
 
     BackbufferInfo* backbuffer = fBackbuffers + fCurrentBackbufferIndex;
 
+    this->presentRenderSurface(fSurfaces[backbuffer->fImageIndex],
+                               fRenderTargets[backbuffer->fImageIndex], 24);
+
     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 = {
         VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,   // sType
         NULL,                                     // pNext
         srcAccessMask,                            // outputMask
@@ skipping 50 matching lines @@
         &fSwapchain, // pSwapchains
         &backbuffer->fImageIndex, // pImageIndices
         NULL // pResults
     };
 
     fQueuePresentKHR(fPresentQueue, &presentInfo);
 
 }
 
 }   //namespace sk_app