Add offset to memory allocations

src/gpu/vk/GrVkMemory.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 "GrVkMemory.h"
 
 #include "GrVkGpu.h"
@@ skipping 43 matching lines @@
                                                                  memory));
     if (err) {
         return false;
     }
     return true;
 }
 
 bool GrVkMemory::AllocAndBindBufferMemory(const GrVkGpu* gpu,
                                           VkBuffer buffer,
                                           const VkMemoryPropertyFlags flags,
-                                          VkDeviceMemory* memory) {
+                                          GrVkAlloc* alloc) {
     const GrVkInterface* iface = gpu->vkInterface();
     VkDevice device = gpu->device();
 
     VkMemoryRequirements memReqs;
     GR_VK_CALL(iface, GetBufferMemoryRequirements(device, buffer, &memReqs));
 
-    if (!alloc_device_memory(gpu, &memReqs, flags, memory)) {
+    if (!alloc_device_memory(gpu, &memReqs, flags, &alloc->fMemory)) {
         return false;
     }
+    // for now, offset is always 0
+    alloc->fOffset = 0;
 
-    // Bind Memory to queue
-    VkResult err = GR_VK_CALL(iface, BindBufferMemory(device, buffer, *memory, 0));
+    // Bind Memory to device
+    VkResult err = GR_VK_CALL(iface, BindBufferMemory(device, buffer, 
+                                                      alloc->fMemory, alloc->fOffset));
     if (err) {
-        GR_VK_CALL(iface, FreeMemory(device, *memory, nullptr));
+        GR_VK_CALL(iface, FreeMemory(device, alloc->fMemory, nullptr));
         return false;
     }
     return true;
 }
 
+void GrVkMemory::FreeBufferMemory(const GrVkGpu* gpu, const GrVkAlloc& alloc) {
+    const GrVkInterface* iface = gpu->vkInterface();
+    GR_VK_CALL(iface, FreeMemory(gpu->device(), alloc.fMemory, nullptr));
+}
+
 bool GrVkMemory::AllocAndBindImageMemory(const GrVkGpu* gpu,
                                          VkImage image,
                                          const VkMemoryPropertyFlags flags,
-                                         VkDeviceMemory* memory) {
+                                         GrVkAlloc* alloc) {
     const GrVkInterface* iface = gpu->vkInterface();
     VkDevice device = gpu->device();
 
     VkMemoryRequirements memReqs;
     GR_VK_CALL(iface, GetImageMemoryRequirements(device, image, &memReqs));
 
-    if (!alloc_device_memory(gpu, &memReqs, flags, memory)) {
+    if (!alloc_device_memory(gpu, &memReqs, flags, &alloc->fMemory)) {
         return false;
     }
+    // for now, offset is always 0
+    alloc->fOffset = 0;
 
-    // Bind Memory to queue
-    VkResult err = GR_VK_CALL(iface, BindImageMemory(device, image, *memory, 0));
+    // Bind Memory to device
+    VkResult err = GR_VK_CALL(iface, BindImageMemory(device, image,
+                              alloc->fMemory, alloc->fOffset));
     if (err) {
-        GR_VK_CALL(iface, FreeMemory(device, *memory, nullptr));
+        GR_VK_CALL(iface, FreeMemory(device, alloc->fMemory, nullptr));
         return false;
     }
     return true;
 }
 
+void GrVkMemory::FreeImageMemory(const GrVkGpu* gpu, const GrVkAlloc& alloc) {
+    const GrVkInterface* iface = gpu->vkInterface();
+    GR_VK_CALL(iface, FreeMemory(gpu->device(), alloc.fMemory, nullptr));
+}
+
 VkPipelineStageFlags GrVkMemory::LayoutToPipelineStageFlags(const VkImageLayout layout) {
     if (VK_IMAGE_LAYOUT_GENERAL == layout) {
         return VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
     } else if (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == layout ||
                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == layout) {
         return VK_PIPELINE_STAGE_TRANSFER_BIT;
     } else if (VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL == layout ||
                VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL == layout ||
                VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL == layout ||
                VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == layout) {
@@ skipping 29 matching lines @@
         flags = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
     } else if (VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL == layout) {
         flags = VK_ACCESS_TRANSFER_WRITE_BIT;
     } else if (VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL == layout) {
         flags = VK_ACCESS_TRANSFER_READ_BIT;
     } else if (VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL == layout) {
         flags = VK_ACCESS_SHADER_READ_BIT;
     }
     return flags;
 }