Add static buffer support

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 11 matching lines @@
     VkBuffer       buffer;
     GrVkAlloc      alloc;
 
     // create the buffer object
     VkBufferCreateInfo bufInfo;
     memset(&bufInfo, 0, sizeof(VkBufferCreateInfo));
     bufInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
     bufInfo.flags = 0;
     bufInfo.size = desc.fSizeInBytes;
     switch (desc.fType) {
     case kVertex_Type:

[egdaniel, 2016/06/30 13:51:19]

nit (from not your change), should these case's all be indented in

[jvanverth1, 2016/06/30 14:56:38]

Done.

         bufInfo.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
         break;
     case kIndex_Type:
         bufInfo.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
         break;
     case kUniform_Type:
         bufInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
         break;
     case kCopyRead_Type:
         bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
         break;
     case kCopyWrite_Type:
         bufInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
         break;
+    }
+    if (!desc.fDynamic) {
+        bufInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
+    }
 
-    }
     bufInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
     bufInfo.queueFamilyIndexCount = 0;
     bufInfo.pQueueFamilyIndices = nullptr;
 
     VkResult err;
     err = VK_CALL(gpu, CreateBuffer(gpu->device(), &bufInfo, nullptr, &buffer));
     if (err) {
         return nullptr;
     }
 
     if (!GrVkMemory::AllocAndBindBufferMemory(gpu,
                                               buffer,
                                               desc.fType,
+                                              desc.fDynamic,
                                               &alloc)) {
         return nullptr;
     }
 
     const GrVkBuffer::Resource* resource = new GrVkBuffer::Resource(buffer, alloc, desc.fType);
     if (!resource) {
         VK_CALL(gpu, DestroyBuffer(gpu->device(), buffer, nullptr));
         GrVkMemory::FreeBufferMemory(gpu, desc.fType, alloc);
         return nullptr;
     }
@@ skipping 41 matching lines @@
 void GrVkBuffer::vkAbandon() {
     fResource->unrefAndAbandon();
     fResource = nullptr;
     fMapPtr = nullptr;
     VALIDATE();
 }
 
 void* GrVkBuffer::vkMap(const GrVkGpu* gpu) {
     VALIDATE();
     SkASSERT(!this->vkIsMapped());
+    if (!fDesc.fDynamic) {
+        return nullptr;
+    }
 
     if (!fResource->unique()) {
         // in use by the command buffer, so we need to create a new one
         fResource->unref(gpu);
         fResource = Create(gpu, fDesc);
     }
 
     const GrVkAlloc& alloc = this->alloc();
     VkResult err = VK_CALL(gpu, MapMemory(gpu->device(), alloc.fMemory, alloc.fOffset,
                                           VK_WHOLE_SIZE, 0, &fMapPtr));
     if (err) {
         fMapPtr = nullptr;
     }
 
     VALIDATE();
     return fMapPtr;
 }
 
 void GrVkBuffer::vkUnmap(const GrVkGpu* gpu) {
     VALIDATE();
     SkASSERT(this->vkIsMapped());
+    SkASSERT(fDesc.fDynamic);
 
     VK_CALL(gpu, UnmapMemory(gpu->device(), this->alloc().fMemory));
 
     fMapPtr = nullptr;
 }
 
 bool GrVkBuffer::vkIsMapped() const {
     VALIDATE();
     return SkToBool(fMapPtr);
 }
 
-bool GrVkBuffer::vkUpdateData(const GrVkGpu* gpu, const void* src, size_t srcSizeInBytes,
+bool GrVkBuffer::vkUpdateData(GrVkGpu* gpu, const void* src, size_t srcSizeInBytes,
                               bool* createdNewBuffer) {
     SkASSERT(!this->vkIsMapped());
     VALIDATE();
     if (srcSizeInBytes > fDesc.fSizeInBytes) {
         return false;
     }
 
+    if (!fDesc.fDynamic) {
+        return gpu->updateBuffer(this, src, 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;
@@ skipping 10 matching lines @@
     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);
 }