Add addtional resolve calls to vulkan backend

src/gpu/vk/GrVkGpu.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 "GrVkGpu.h"
 
 #include "GrContextOptions.h"
@@ skipping 266 matching lines @@
     tempDrawInfo->fTempSurfaceDesc.fConfig = srcConfig;
     tempDrawInfo->fTempSurfaceDesc.fWidth = width;
     tempDrawInfo->fTempSurfaceDesc.fHeight = height;
     tempDrawInfo->fTempSurfaceDesc.fSampleCnt = 0;
     tempDrawInfo->fTempSurfaceDesc.fOrigin = kTopLeft_GrSurfaceOrigin;
 
     if (dstSurface->config() == srcConfig) {
         return true;
     }
 
-    if (renderTarget && this->vkCaps().isConfigRenderable(renderTarget->config(), false)) {
+    if (renderTarget && this->vkCaps().isConfigRenderable(renderTarget->config(),
+                                                          renderTarget->numColorSamples() > 1)) {
         ElevateDrawPreference(drawPreference, kRequireDraw_DrawPreference);
 
         bool configsAreRBSwaps = GrPixelConfigSwapRAndB(srcConfig) == dstSurface->config();
 
         if (!this->vkCaps().isConfigTexturable(srcConfig) && configsAreRBSwaps) {
             if (!this->vkCaps().isConfigTexturable(dstSurface->config())) {
                 return false;
             }
             tempDrawInfo->fTempSurfaceDesc.fConfig = dstSurface->config();
             tempDrawInfo->fSwizzle = GrSwizzle::BGRA();
@@ skipping 61 matching lines @@
                 }
             }
             success = this->uploadTexDataOptimal(vkTex, left, top, width, height, config, texels);
         }
     }
 
     return success;
 }
 
 void GrVkGpu::onResolveRenderTarget(GrRenderTarget* target) {
-    if (target->needsResolve() && target->numColorSamples() > 1) {
+    if (target->needsResolve()) {
+        SkASSERT(target->numColorSamples() > 1);

[egdaniel, 2016/08/05 19:07:15]

going back to this. Returning getResolveType as auto for non-msaa cases seems to
fix the problem of us trying to resolve non-msaa RTs

         GrVkRenderTarget* rt = static_cast<GrVkRenderTarget*>(target);
         SkASSERT(rt->msaaImage());
 
         // Flip rect if necessary
         SkIRect srcVkRect = rt->getResolveRect();
 
         if (kBottomLeft_GrSurfaceOrigin == rt->origin()) {
             srcVkRect.fTop = rt->height() - rt->getResolveRect().fBottom;
             srcVkRect.fBottom =  rt->height() - rt->getResolveRect().fTop;
         }
@@ skipping 430 matching lines @@
     return tgt;
 }
 
 void GrVkGpu::generateMipmap(GrVkTexture* tex) {
     // don't do anything for linearly tiled textures (can't have mipmaps)
     if (tex->isLinearTiled()) {
         SkDebugf("Trying to create mipmap for linear tiled texture");
         return;
     }
 
-    // We currently don't support generating mipmaps for images that are multisampled.
-    // TODO: Add support for mipmapping the resolve target of a multisampled image
-    if (tex->asRenderTarget() && tex->asRenderTarget()->numColorSamples() > 1) {
-        return;
-    }
-
     // determine if we can blit to and from this format
     const GrVkCaps& caps = this->vkCaps();
     if (!caps.configCanBeDstofBlit(tex->config(), false) ||
         !caps.configCanBeSrcofBlit(tex->config(), false) ||
         !caps.mipMapSupport()) {
         return;
     }
 
+    // We may need to resolve the texture first if it is also a render target
+    GrVkRenderTarget* texRT = static_cast<GrVkRenderTarget*>(tex->asRenderTarget());
+    if (texRT) {
+        this->onResolveRenderTarget(texRT);
+    }
+
     int width = tex->width();
     int height = tex->height();
     VkImageBlit blitRegion;
     memset(&blitRegion, 0, sizeof(VkImageBlit));
 
     // SkMipMap doesn't include the base level in the level count so we have to add 1
     uint32_t levelCount = SkMipMap::ComputeLevelCount(tex->width(), tex->height()) + 1;
     if (levelCount != tex->mipLevels()) {
         const GrVkResource* oldResource = tex->resource();
         oldResource->ref();
@@ skipping 411 matching lines @@
     SkIRect dstRect = SkIRect::MakeXYWH(dstPoint.fX, dstPoint.fY,
                                         srcRect.width(), srcRect.height());
     this->didWriteToSurface(dst, &dstRect);
 }
 
 inline bool can_copy_as_blit(const GrSurface* dst,
                              const GrSurface* src,
                              const GrVkImage* dstImage,
                              const GrVkImage* srcImage,
                              const GrVkGpu* gpu) {
-    // We require that all vulkan GrSurfaces have been created with transfer_dst and transfer_src 
+    // We require that all vulkan GrSurfaces have been created with transfer_dst and transfer_src
     // as image usage flags.
     const GrVkCaps& caps = gpu->vkCaps();
     if (!caps.configCanBeDstofBlit(dst->config(), dstImage->isLinearTiled()) ||
         !caps.configCanBeSrcofBlit(src->config(), srcImage->isLinearTiled())) {
         return false;
     }
 
     // We cannot blit images that are multisampled. Will need to figure out if we can blit the
     // resolved msaa though.
     if ((dst->asRenderTarget() && dst->asRenderTarget()->numColorSamples() > 1) ||
@@ skipping 161 matching lines @@
     // from will be srcConfig and we will read readConfig pixels from it.
     // Not that if we require a draw and return a non-renderable format for the temp surface the
     // base class will fail for us.
     tempDrawInfo->fTempSurfaceDesc.fConfig = srcSurface->config();
     tempDrawInfo->fReadConfig = readConfig;
 
     if (srcSurface->config() == readConfig) {
         return true;
     }
 
-    if (this->vkCaps().isConfigRenderable(readConfig, false)) {
+    if (this->vkCaps().isConfigRenderable(readConfig, srcSurface->desc().fSampleCnt > 1)) {
         ElevateDrawPreference(drawPreference, kRequireDraw_DrawPreference);
         tempDrawInfo->fTempSurfaceDesc.fConfig = readConfig;
         tempDrawInfo->fReadConfig = readConfig;
         return true;
     }
 
     return false;
 }
 
 bool GrVkGpu::onReadPixels(GrSurface* surface,
                            int left, int top, int width, int height,
                            GrPixelConfig config,
                            void* buffer,
                            size_t rowBytes) {
     VkFormat pixelFormat;
     if (!GrPixelConfigToVkFormat(config, &pixelFormat)) {
         return false;
     }
 
-    GrVkTexture* tgt = static_cast<GrVkTexture*>(surface->asTexture());
-    if (!tgt) {
+    GrVkImage* image = nullptr;
+    GrVkRenderTarget* rt = static_cast<GrVkRenderTarget*>(surface->asRenderTarget());

[Brian Osman, 2016/08/18 13:28:22]

This is the only place where you're doing the extra checking for resolve type
before calling onResolveRenderTarget. I'm guessing that the other call-sites
won't ever encounter a non-msaa RT? Or would it just be safer to put this logic
in onResolveRenderTarget, so we can always call it blindly?

[egdaniel, 2016/08/18 13:31:39]

Yeah I can move it up there. I was actually just copying how our GL side is set
up.

[egdaniel, 2016/08/18 13:36:23]

Actually I see the reasoning now. onResolveRenderTarget is a virtual that
currently has no return type. onReadPixels is the only place where it matters if
we were able to actually resolve or not (returning a bool itself). Thus the
extra check there.

+    if (rt) {
+        // resolve the render target if necessary
+        switch (rt->getResolveType()) {
+            case GrVkRenderTarget::kCantResolve_ResolveType:
+                return false;
+            case GrVkRenderTarget::kAutoResolves_ResolveType:
+                break;
+            case GrVkRenderTarget::kCanResolve_ResolveType:
+                this->onResolveRenderTarget(rt);
+                break;
+            default:
+                SkFAIL("Unknown resolve type");
+        }
+        image = rt;
+    } else {
+        image = static_cast<GrVkTexture*>(surface->asTexture());
+    }
+
+    if (!image) {
         return false;
     }
 
     // Change layout of our target so it can be used as copy
-    tgt->setImageLayout(this,
-                        VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-                        VK_ACCESS_TRANSFER_READ_BIT,
-                        VK_PIPELINE_STAGE_TRANSFER_BIT,
-                        false);
+    image->setImageLayout(this,
+                          VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                          VK_ACCESS_TRANSFER_READ_BIT,
+                          VK_PIPELINE_STAGE_TRANSFER_BIT,
+                          false);
 
     GrVkTransferBuffer* transferBuffer =
         static_cast<GrVkTransferBuffer*>(this->createBuffer(rowBytes * height,
                                                             kXferGpuToCpu_GrBufferType,
                                                             kStream_GrAccessPattern));
 
     bool flipY = kBottomLeft_GrSurfaceOrigin == surface->origin();
     VkOffset3D offset = {
         left,
         flipY ? surface->height() - top - height : top,
         0
     };
 
     // Copy the image to a buffer so we can map it to cpu memory
     VkBufferImageCopy region;
     memset(&region, 0, sizeof(VkBufferImageCopy));
     region.bufferOffset = transferBuffer->offset();
     region.bufferRowLength = 0; // Forces RowLength to be width. We handle the rowBytes below.
     region.bufferImageHeight = 0; // Forces height to be tightly packed. Only useful for 3d images.
     region.imageSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
     region.imageOffset = offset;
     region.imageExtent = { (uint32_t)width, (uint32_t)height, 1 };
 
     fCurrentCmdBuffer->copyImageToBuffer(this,
-                                         tgt,
+                                         image,
                                          VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                                          transferBuffer,
                                          1,
                                          &region);
 
     // make sure the copy to buffer has finished
     transferBuffer->addMemoryBarrier(this,
                                      VK_ACCESS_TRANSFER_WRITE_BIT,
                                      VK_ACCESS_HOST_READ_BIT,
                                      VK_PIPELINE_STAGE_TRANSFER_BIT,
@@ skipping 87 matching lines @@
                                      target->width(), target->height());
         pBounds = &adjustedBounds;
     }
 
     // Currently it is fine for us to always pass in 1 for the clear count even if no attachment
     // uses it. In the current state, we also only use the LOAD_OP_CLEAR for the color attachment
     // which is always at the first attachment.
     fCurrentCmdBuffer->beginRenderPass(this, renderPass, 1, colorClear, *target, *pBounds, true);
     fCurrentCmdBuffer->executeCommands(this, buffer);
     fCurrentCmdBuffer->endRenderPass(this);
+
+    this->didWriteToSurface(target, pBounds);
 }