Add automatic generation of mipmaps to Vulkan

src/gpu/vk/GrVkTextureRenderTarget.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 "GrVkTextureRenderTarget.h"
 
 #include "GrRenderTargetPriv.h"
 #include "GrVkGpu.h"
 #include "GrVkImageView.h"
 #include "GrVkUtil.h"
 
+#include "SkMipmap.h"
+
 #include "vk/GrVkTypes.h"
 
 #define VK_CALL(GPU, X) GR_VK_CALL(GPU->vkInterface(), X)
 
 template<typename ResourceType>
 GrVkTextureRenderTarget* GrVkTextureRenderTarget::Create(GrVkGpu* gpu,
                                                          ResourceType resourceType,
                                                          const GrSurfaceDesc& desc,
                                                          VkFormat format,
                                                          const GrVkImage::Resource* imageResource) {
     VkImage image = imageResource->fImage;
     // Create the texture ImageView
+    uint32_t mipLevels = 1;
+    //TODO: does a mipmapped textureRenderTarget make sense?
+    //if (desc.fIsMipMapped) {
+    //    mipLevels = SkMipMap::ComputeLevelCount(this->width(), this->height());
+    //}
     const GrVkImageView* imageView = GrVkImageView::Create(gpu, image, format,
-                                                           GrVkImageView::kColor_Type);
+                                                           GrVkImageView::kColor_Type, mipLevels);
     if (!imageView) {
         return nullptr;
     }
 
     VkFormat pixelFormat;
     GrPixelConfigToVkFormat(desc.fConfig, &pixelFormat);
 
     VkImage colorImage;
 
     // create msaa surface if necessary
@@ skipping 21 matching lines @@
         // Set color attachment image
         colorImage = msaaImageResource->fImage;
 
         // Create resolve attachment view if necessary.
         // If the format matches, this is the same as the texture imageView.
         if (pixelFormat == format) {
             resolveAttachmentView = imageView;
             resolveAttachmentView->ref();
         } else {
             resolveAttachmentView = GrVkImageView::Create(gpu, image, pixelFormat,
-                                                          GrVkImageView::kColor_Type);
+                                                          GrVkImageView::kColor_Type, 1);
             if (!resolveAttachmentView) {
                 msaaImageResource->unref(gpu);
                 imageView->unref(gpu);
                 return nullptr;
             }
         }
     } else {
         // Set color attachment image
         colorImage = imageResource->fImage;
     }
 
     const GrVkImageView* colorAttachmentView;
     // Get color attachment view.
     // If the format matches and there's no multisampling,
     // this is the same as the texture imageView
     if (pixelFormat == format && !resolveAttachmentView) {
         colorAttachmentView = imageView;
         colorAttachmentView->ref();
     } else {
         colorAttachmentView = GrVkImageView::Create(gpu, colorImage, pixelFormat,
-                                                    GrVkImageView::kColor_Type);
+                                                    GrVkImageView::kColor_Type, 1);
         if (!colorAttachmentView) {
             if (msaaImageResource) {
                 resolveAttachmentView->unref(gpu);
                 msaaImageResource->unref(gpu);
             }
             imageView->unref(gpu);
             return nullptr;
         }
     }
     GrVkTextureRenderTarget* texRT;
@@ skipping 60 matching lines @@
     }
     GrVkTextureRenderTarget* trt = Create(gpu, kWrapped, desc, format, imageResource);
     if (trt) {
         trt->fCurrentLayout = info->fImageLayout;
     }
     // Create() will increment the refCount of the image resource if it succeeds
     imageResource->unref(gpu);
 
     return trt;
 }