Add offsets to GrVkBuffer.

src/gpu/vk/GrVkBuffer.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 "GrVkBuffer.h"
 #include "GrVkGpu.h"
 #include "GrVkMemory.h"
@@ skipping 114 matching lines @@
     VALIDATE();
     SkASSERT(!this->vkIsMapped());
     if (!fResource->unique()) {
         // in use by the command buffer, so we need to create a new one
         fResource->unref(gpu);
         fResource = Create(gpu, fDesc);
     }
 
     if (fDesc.fDynamic) {
         const GrVkAlloc& alloc = this->alloc();
-        VkResult err = VK_CALL(gpu, MapMemory(gpu->device(), alloc.fMemory, alloc.fOffset,
-                                              VK_WHOLE_SIZE, 0, &fMapPtr));
+        VkResult err = VK_CALL(gpu, MapMemory(gpu->device(), alloc.fMemory,
+                                              alloc.fOffset + fOffset,
+                                              fDesc.fSizeInBytes, 0, &fMapPtr));
         if (err) {
             fMapPtr = nullptr;
         }
     } else {
         fMapPtr = new unsigned char[this->size()];
     }
 
     VALIDATE();
     return fMapPtr;
 }
 
 void GrVkBuffer::vkUnmap(GrVkGpu* gpu) {
     VALIDATE();
     SkASSERT(this->vkIsMapped());
 
     if (fDesc.fDynamic) {
         VK_CALL(gpu, UnmapMemory(gpu->device(), this->alloc().fMemory));
     } else {
-        gpu->updateBuffer(this, fMapPtr, this->size());
+        gpu->updateBuffer(this, fMapPtr, this->offset(), this->size());
         delete [] (unsigned char*)fMapPtr;
     }
 
     fMapPtr = nullptr;
 }
 
 bool GrVkBuffer::vkIsMapped() const {
     VALIDATE();
     return SkToBool(fMapPtr);
 }
 
 bool GrVkBuffer::vkUpdateData(GrVkGpu* gpu, const void* src, size_t srcSizeInBytes,
                               bool* createdNewBuffer) {
     SkASSERT(!this->vkIsMapped());
     VALIDATE();
     if (srcSizeInBytes > fDesc.fSizeInBytes) {
         return false;
     }
 
+    // TODO: update data based on buffer offset
     if (!fDesc.fDynamic) {
-        return gpu->updateBuffer(this, src, srcSizeInBytes);
+        return gpu->updateBuffer(this, src, fOffset, srcSizeInBytes);
     }
 
     if (!fResource->unique()) {
         // in use by the command buffer, so we need to create a new one
         fResource->unref(gpu);
         fResource = Create(gpu, fDesc);
         if (createdNewBuffer) {
             *createdNewBuffer = true;
         }
     }
 
     void* mapPtr;
     const GrVkAlloc& alloc = this->alloc();
-    VkResult err = VK_CALL(gpu, MapMemory(gpu->device(), alloc.fMemory, alloc.fOffset,
+    VkResult err = VK_CALL(gpu, MapMemory(gpu->device(), alloc.fMemory,
+                                          alloc.fOffset + fOffset,
                                           srcSizeInBytes, 0, &mapPtr));
 
     if (VK_SUCCESS != err) {
         return false;
     }
 
     memcpy(mapPtr, src, srcSizeInBytes);
 
     VK_CALL(gpu, UnmapMemory(gpu->device(), alloc.fMemory));
 
     return true;
 }
 
 void GrVkBuffer::validate() const {
     SkASSERT(!fResource || kVertex_Type == fDesc.fType || kIndex_Type == fDesc.fType
              || kCopyRead_Type == fDesc.fType || kCopyWrite_Type == fDesc.fType
              || kUniform_Type == fDesc.fType);
 }