Add mipmap loading to Vulkan.

src/gpu/vk/GrVkTexture.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 "GrVkTexture.h"
 #include "GrVkGpu.h"
 #include "GrVkImageView.h"
 #include "GrTexturePriv.h"
 #include "GrVkUtil.h"
-#include "SkMipMap.h"
 
 #include "vk/GrVkTypes.h"
 
 #define VK_CALL(GPU, X) GR_VK_CALL(GPU->vkInterface(), X)
 
 // Because this class is virtually derived from GrSurface we must explicitly call its constructor.
 GrVkTexture::GrVkTexture(GrVkGpu* gpu,
                          SkBudgeted budgeted,
                          const GrSurfaceDesc& desc,
                          const GrVkImage::Resource* imageResource,
                          const GrVkImageView* view)
     : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
-    , INHERITED(gpu, desc, kSampler2D_GrSLType,
-                false) // false because we don't upload MIP data in Vk yet
+    , INHERITED(gpu, desc, kSampler2D_GrSLType, desc.fIsMipMapped) 
     , fTextureView(view) {
     this->registerWithCache(budgeted);
 }
 
 GrVkTexture::GrVkTexture(GrVkGpu* gpu,
                          Wrapped,
                          const GrSurfaceDesc& desc,
                          const GrVkImage::Resource* imageResource,
                          const GrVkImageView* view)
     : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
-    , INHERITED(gpu, desc, kSampler2D_GrSLType,
-                false) // false because we don't upload MIP data in Vk yet
+    , INHERITED(gpu, desc, kSampler2D_GrSLType, desc.fIsMipMapped)
     , fTextureView(view) {
     this->registerWithCacheWrapped();
 }
 
 // Because this class is virtually derived from GrSurface we must explicitly call its constructor.
 GrVkTexture::GrVkTexture(GrVkGpu* gpu,
                          const GrSurfaceDesc& desc,
                          const GrVkImage::Resource* imageResource,
                          const GrVkImageView* view)
     : GrSurface(gpu, desc)
     , GrVkImage(imageResource)
-    , INHERITED(gpu, desc, kSampler2D_GrSLType,
-                false) // false because we don't upload MIP data in Vk yet
+    , INHERITED(gpu, desc, kSampler2D_GrSLType, desc.fIsMipMapped)
     , fTextureView(view) {}
 
 
 template<typename ResourceType>
 GrVkTexture* GrVkTexture::Create(GrVkGpu* gpu,
                                  ResourceType type,
                                  const GrSurfaceDesc& desc,
-                                 VkFormat format,
+                                 VkFormat format, uint32_t levels, 
                                  const GrVkImage::Resource* imageResource) {
     VkImage image = imageResource->fImage;
 
-    uint32_t mipLevels = 1;
-    // TODO: enable when mipLevel loading is implemented in GrVkGpu
-    //if (desc.fIsMipMapped) {
-    //    mipLevels = SkMipMap::ComputeLevelCount(this->width(), this->height());
-    //}
     const GrVkImageView* imageView = GrVkImageView::Create(gpu, image, format,
-                                                           GrVkImageView::kColor_Type, mipLevels);
+                                                           GrVkImageView::kColor_Type, 
+                                                           levels);
     if (!imageView) {
         return nullptr;
     }
 
     return new GrVkTexture(gpu, type, desc, imageResource, imageView);
 }
 
 GrVkTexture* GrVkTexture::CreateNewTexture(GrVkGpu* gpu, SkBudgeted budgeted,
                                            const GrSurfaceDesc& desc,
                                            const GrVkImage::ImageDesc& imageDesc) {
     SkASSERT(imageDesc.fUsageFlags & VK_IMAGE_USAGE_SAMPLED_BIT);
 
     const GrVkImage::Resource* imageResource = GrVkImage::CreateResource(gpu, imageDesc);
     if (!imageResource) {
         return nullptr;
     }
 
-    GrVkTexture* texture = Create(gpu, budgeted, desc, imageDesc.fFormat, imageResource);
+    GrVkTexture* texture = Create(gpu, budgeted, desc, imageDesc.fFormat, imageDesc.fLevels,
+                                  imageResource);
     // Create() will increment the refCount of the image resource if it succeeds
     imageResource->unref(gpu);
 
     return texture;
 }
 
 GrVkTexture* GrVkTexture::CreateWrappedTexture(GrVkGpu* gpu,
                                                const GrSurfaceDesc& desc,
                                                GrWrapOwnership ownership,
                                                VkFormat format,
@@ skipping 11 matching lines @@
                                                         info->fAlloc,
                                                         flags,
                                                         info->fFormat);
     } else {
         imageResource = new GrVkImage::Resource(info->fImage, info->fAlloc, flags, info->fFormat);
     }
     if (!imageResource) {
         return nullptr;
     }
 
-    GrVkTexture* texture = Create(gpu, kWrapped, desc, format, imageResource);
+    // We have no other information so we have to assume that wrapped textures have only one level
+    GrVkTexture* texture = Create(gpu, kWrapped, desc, format, 1, imageResource);
     if (texture) {
         texture->fCurrentLayout = info->fImageLayout;
     }
     // Create() will increment the refCount of the image resource if it succeeds
     imageResource->unref(gpu);
 
     return texture;
 }
 
 GrVkTexture::~GrVkTexture() {
@@ skipping 26 matching lines @@
 GrBackendObject GrVkTexture::getTextureHandle() const {
     // Currently just passing back the pointer to the Resource as the handle
     return (GrBackendObject)&fResource;
 }
 
 GrVkGpu* GrVkTexture::getVkGpu() const {
     SkASSERT(!this->wasDestroyed());
     return static_cast<GrVkGpu*>(this->getGpu());
 }
 
-bool GrVkTexture::reallocForMipmap(const GrVkGpu* gpu) {
+bool GrVkTexture::reallocForMipmap(const GrVkGpu* gpu, uint32_t mipLevels) {
+    if (mipLevels == 1) {
+        // don't need to do anything for a 1x1 texture
+        return false;
+    }
+
     const GrVkImage::Resource* oldResource = fResource;
 
+    // We shouldn't realloc something that doesn't belong to us
+    if (GrVkImage::Resource::kBorrowed_Flag & oldResource->fFlags) {
+        return false;
+    }
+
     // Does this even make sense for rendertargets?
     bool renderTarget = SkToBool(fDesc.fFlags & kRenderTarget_GrSurfaceFlag);
 
     VkImageUsageFlags usageFlags = VK_IMAGE_USAGE_SAMPLED_BIT;
     if (renderTarget) {
         usageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
     }
     usageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
-    uint32_t mipLevels = SkMipMap::ComputeLevelCount(this->width(), this->height());
-    if (mipLevels == 1) {
-        // don't need to do anything for a 1x1 texture
-        return false;
-    }
-
     GrVkImage::ImageDesc imageDesc;
     imageDesc.fImageType = VK_IMAGE_TYPE_2D;
     imageDesc.fFormat = oldResource->fFormat;
     imageDesc.fWidth = fDesc.fWidth;
     imageDesc.fHeight = fDesc.fHeight;
     imageDesc.fLevels = mipLevels;
     imageDesc.fSamples = 1;
     imageDesc.fImageTiling = VK_IMAGE_TILING_OPTIMAL;
     imageDesc.fUsageFlags = usageFlags;
     imageDesc.fMemProps = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
@@ skipping 14 matching lines @@
     }
 
     oldResource->unref(gpu);
     oldView->unref(gpu);
     fResource = imageResource;
     fTextureView = textureView;
     this->texturePriv().setMaxMipMapLevel(mipLevels);
 
     return true;
 }