Add mipmap loading to Vulkan.

src/gpu/GrGpu.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGpu.h"
 
 #include "GrBuffer.h"
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrGpuResourcePriv.h"
 #include "GrMesh.h"
 #include "GrPathRendering.h"
 #include "GrPipeline.h"
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
 #include "GrRenderTargetPriv.h"
 #include "GrStencilAttachment.h"
 #include "GrSurfacePriv.h"
+#include "GrTexturePriv.h"
 #include "SkTypes.h"
 
 GrMesh& GrMesh::operator =(const GrMesh& di) {
     fPrimitiveType  = di.fPrimitiveType;
     fStartVertex    = di.fStartVertex;
     fStartIndex     = di.fStartIndex;
     fVertexCount    = di.fVertexCount;
     fIndexCount     = di.fIndexCount;
 
     fInstanceCount          = di.fInstanceCount;
@@ skipping 335 matching lines @@
         return false;
     }
     for (int currentMipLevel = 0; currentMipLevel < texels.count(); currentMipLevel++) {
         if (!texels[currentMipLevel].fPixels ) {
             return false;
         }
     }
 
     this->handleDirtyContext();
     if (this->onWritePixels(surface, left, top, width, height, config, texels)) {
+        SkIRect rect = SkIRect::MakeXYWH(left, top, width, height);
+        this->didWriteToSurface(surface, &rect, texels.count());
         fStats.incTextureUploads();
         return true;
     }
     return false;
 }
 
 bool GrGpu::writePixels(GrSurface* surface,
                         int left, int top, int width, int height,
                         GrPixelConfig config, const void* buffer,
                         size_t rowBytes) {
     GrMipLevel mipLevel;
     mipLevel.fPixels = buffer;
     mipLevel.fRowBytes = rowBytes;
     SkSTArray<1, GrMipLevel> texels;
     texels.push_back(mipLevel);
 
     return this->writePixels(surface, left, top, width, height, config, texels);
 }
 
 bool GrGpu::transferPixels(GrSurface* surface,
                            int left, int top, int width, int height,
                            GrPixelConfig config, GrBuffer* transferBuffer,
                            size_t offset, size_t rowBytes) {
     SkASSERT(transferBuffer);
 
     this->handleDirtyContext();
     if (this->onTransferPixels(surface, left, top, width, height, config,
                                transferBuffer, offset, rowBytes)) {
+        SkIRect rect = SkIRect::MakeXYWH(left, top, width, height);
+        this->didWriteToSurface(surface, &rect);
         fStats.incTransfersToTexture();
         return true;
     }
     return false;
 }
 
 void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
     SkASSERT(target);
     this->handleDirtyContext();
     this->onResolveRenderTarget(target);
 }
 
+void GrGpu::didWriteToSurface(GrSurface* surface, const SkIRect* bounds, uint32_t mipLevels) const {
+    SkASSERT(surface);
+    // Mark any MIP chain and resolve buffer as dirty if and only if there is a non-empty bounds.
+    if (nullptr == bounds || !bounds->isEmpty()) {
+        if (GrRenderTarget* target = surface->asRenderTarget()) {
+            target->flagAsNeedingResolve(bounds);
+        }
+        GrTexture* texture = surface->asTexture();
+        if (texture && 1 == mipLevels) {

[egdaniel, 2016/04/29 18:10:28]

just to clarify for myself here. The reason we make mipLevels == 1 as dirty is
because if we actually had someone pass in a whole mip chain to us we would
write all those levels and assume it is fine right?

[jvanverth1, 2016/04/29 18:16:10]

Yes, that's right.

+            texture->texturePriv().dirtyMipMaps(true);
+        }
+    }
+}
+
 inline static uint8_t multisample_specs_id(uint8_t numSamples, GrSurfaceOrigin origin,
                                            const GrCaps& caps) {
     if (!caps.sampleLocationsSupport()) {
         return numSamples;
     }
 
     SkASSERT(numSamples < 128);
     SkASSERT(kTopLeft_GrSurfaceOrigin == origin || kBottomLeft_GrSurfaceOrigin == origin);
     return (numSamples << 1) | (origin - 1);
 
@@ skipping 50 matching lines @@
                  int meshCount) {
     if (primProc.numAttribs() > this->caps()->maxVertexAttributes()) {
         fStats.incNumFailedDraws();
         return false;
     }
     this->handleDirtyContext();
 
     this->onDraw(pipeline, primProc, meshes, meshCount);
     return true;
 }