Add offset to memory allocations

src/gpu/vk/GrVkImage.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrVkImage_DEFINED
 #define GrVkImage_DEFINED
 
@@ skipping 15 matching lines @@
     enum Wrapped {
         kNot_Wrapped,
         kAdopted_Wrapped,
         kBorrowed_Wrapped,
     };
 
     GrVkImage(const GrVkImageInfo& info, Wrapped wrapped)
         : fInfo(info)
         , fIsBorrowed(kBorrowed_Wrapped == wrapped) {
         if (kBorrowed_Wrapped == wrapped) {
-            fResource = new BorrowedResource(info.fImage, info.fAlloc);
+            fResource = new BorrowedResource(info.fImage, info.fAlloc, info.fOffset);
         } else {
-            fResource = new Resource(info.fImage, info.fAlloc);
+            fResource = new Resource(info.fImage, info.fAlloc, info.fOffset);
         }
     }
     virtual ~GrVkImage();
 
     VkImage image() const { return fInfo.fImage; }
     VkDeviceMemory memory() const { return fInfo.fAlloc; }
+    VkDeviceSize offset() const { return fInfo.fOffset; }
     VkFormat imageFormat() const { return fInfo.fFormat; }
     const Resource* resource() const { return fResource; }
     bool isLinearTiled() const {
         return SkToBool(VK_IMAGE_TILING_LINEAR == fInfo.fImageTiling);
     }
 
     VkImageLayout currentLayout() const { return fInfo.fImageLayout; }
 
     void setImageLayout(const GrVkGpu* gpu,
                         VkImageLayout newLayout,
@@ skipping 25 matching lines @@
     };
 
     static bool InitImageInfo(const GrVkGpu* gpu, const ImageDesc& imageDesc, GrVkImageInfo*);
     // Destroys the internal VkImage and VkDeviceMemory in the GrVkImageInfo
     static void DestroyImageInfo(const GrVkGpu* gpu, GrVkImageInfo*);
 
 protected:
     void releaseImage(const GrVkGpu* gpu);
     void abandonImage();
 
-    void setNewResource(VkImage image, VkDeviceMemory alloc);
+    void setNewResource(VkImage image, VkDeviceMemory alloc, VkDeviceSize offset);
 
     GrVkImageInfo   fInfo;
     bool            fIsBorrowed;
 
 private:
     // unlike GrVkBuffer, this needs to be public so GrVkStencilAttachment can use it
     class Resource : public GrVkResource {
     public:
         Resource()
             : INHERITED()
             , fImage(VK_NULL_HANDLE)
-            , fAlloc(VK_NULL_HANDLE) {
+            , fAlloc(VK_NULL_HANDLE)
+            , fOffset(0) {
         }
 
-        Resource(VkImage image, VkDeviceMemory alloc) : fImage(image), fAlloc(alloc) {}
+        Resource(VkImage image, VkDeviceMemory alloc, VkDeviceSize offset) 
+            : fImage(image), fAlloc(alloc), fOffset(offset) {}
 
         ~Resource() override {}
 
     private:
         void freeGPUData(const GrVkGpu* gpu) const override;
 
         VkImage                  fImage;
         VkDeviceMemory           fAlloc;
+        VkDeviceSize             fOffset;
 
         typedef GrVkResource INHERITED;
     };
 
     // for wrapped textures
     class BorrowedResource : public Resource {
     public:
-        BorrowedResource(VkImage image, VkDeviceMemory alloc) : Resource(image, alloc) {
+        BorrowedResource(VkImage image, VkDeviceMemory alloc, VkDeviceSize offset) 
+            : Resource(image, alloc, offset) {
         }
     private:
         void freeGPUData(const GrVkGpu* gpu) const override;
     };
 
     const Resource* fResource;
 
     friend class GrVkRenderTarget;
 };
 
 #endif