Apply setImageLayout() to all of a VkImage's subresources.

src/gpu/vk/GrVkImage.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 "GrVkImage.h"
 #include "GrVkMemory.h"
@@ skipping 13 matching lines @@
             return VK_IMAGE_ASPECT_COLOR_BIT;
     }
 }
 
 void GrVkImage::setImageLayout(const GrVkGpu* gpu, VkImageLayout newLayout,
                                VkAccessFlags srcAccessMask,
                                VkAccessFlags dstAccessMask,
                                VkPipelineStageFlags srcStageMask,
                                VkPipelineStageFlags dstStageMask,
                                bool byRegion) {
-    SkASSERT(VK_IMAGE_LAYOUT_GENERAL != newLayout || VK_IMAGE_LAYOUT_PREINITIALIZED != newLayout);
+    SkASSERT(VK_IMAGE_LAYOUT_UNDEFINED != newLayout &&
+             VK_IMAGE_LAYOUT_PREINITIALIZED != newLayout);
     // Is this reasonable? Could someone want to keep the same layout but use the masks to force

[jvanverth1, 2016/05/03 16:34:23]

As a side note, I think this is reasonable. If they want to just set a barrier
they can use the GrVkGpu calls.

     // a barrier on certain things?
     if (newLayout == fCurrentLayout) {
         return;
     }
     VkImageAspectFlags aspectFlags = vk_format_to_aspect_flags(fResource->fFormat);
     VkImageMemoryBarrier imageMemoryBarrier = {
-        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,   // sType
-        NULL,                                     // pNext
-        srcAccessMask,                            // outputMask
-        dstAccessMask,                            // inputMask
-        fCurrentLayout,                           // oldLayout
-        newLayout,                                // newLayout
-        VK_QUEUE_FAMILY_IGNORED,                  // srcQueueFamilyIndex
-        VK_QUEUE_FAMILY_IGNORED,                  // dstQueueFamilyIndex
-        fResource->fImage,                        // image
-        { aspectFlags, 0, 1, 0, 1 }               // subresourceRange
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,          // sType
+        NULL,                                            // pNext
+        srcAccessMask,                                   // outputMask
+        dstAccessMask,                                   // inputMask
+        fCurrentLayout,                                  // oldLayout
+        newLayout,                                       // newLayout
+        VK_QUEUE_FAMILY_IGNORED,                         // srcQueueFamilyIndex
+        VK_QUEUE_FAMILY_IGNORED,                         // dstQueueFamilyIndex
+        fResource->fImage,                               // image
+        { aspectFlags, 0, fResource->fLevelCount, 0, 1 } // subresourceRange
     };
 
     // TODO: restrict to area of image we're interested in
     gpu->addImageMemoryBarrier(srcStageMask, dstStageMask, byRegion, &imageMemoryBarrier);
 
     fCurrentLayout = newLayout;
 }
 
 const GrVkImage::Resource* GrVkImage::CreateResource(const GrVkGpu* gpu,
                                                      const ImageDesc& imageDesc) {
@@ skipping 35 matching lines @@
 
     if (!GrVkMemory::AllocAndBindImageMemory(gpu, image, imageDesc.fMemProps, &alloc)) {
         VK_CALL(gpu, DestroyImage(gpu->device(), image, nullptr));
         return nullptr;
     }
 
     GrVkImage::Resource::Flags flags =
         (VK_IMAGE_TILING_LINEAR == imageDesc.fImageTiling) ? Resource::kLinearTiling_Flag
                                                            : Resource::kNo_Flags;
 
-    return (new GrVkImage::Resource(image, alloc, flags, imageDesc.fFormat));
+    return (new GrVkImage::Resource(image, alloc, imageDesc.fFormat, imageDesc.fLevels, flags));
 }
 
 GrVkImage::~GrVkImage() {
     // should have been released or abandoned first
     SkASSERT(!fResource);
 }
 
 void GrVkImage::releaseImage(const GrVkGpu* gpu) {
     if (fResource) {
         fResource->unref(gpu);
         fResource = nullptr;
     }
 }
 
 void GrVkImage::abandonImage() {
     if (fResource) {
         fResource->unrefAndAbandon();
         fResource = nullptr;
     }
 }
 
 void GrVkImage::Resource::freeGPUData(const GrVkGpu* gpu) const {
     VK_CALL(gpu, DestroyImage(gpu->device(), fImage, nullptr));
     VK_CALL(gpu, FreeMemory(gpu->device(), fAlloc, nullptr));
 }
 
 void GrVkImage::BorrowedResource::freeGPUData(const GrVkGpu* gpu) const {
 }