Vulkan: Simple buffer creation.

src/libANGLE/Buffer.cpp

@@ -9,6 +9,8 @@
 // [OpenGL ES 2.0.24] section 2.9 page 21.
 
 #include "libANGLE/Buffer.h"
+
+#include "libANGLE/Context.h"
 #include "libANGLE/renderer/BufferImpl.h"
 #include "libANGLE/renderer/GLImplFactory.h"
 
@@ -52,9 +54,13 @@ const std::string &Buffer::getLabel() const
     return mState.mLabel;
 }
 
-Error Buffer::bufferData(GLenum target, const void *data, GLsizeiptr size, GLenum usage)
+Error Buffer::bufferData(const Context *context,
+                         GLenum target,
+                         const void *data,
+                         GLsizeiptr size,
+                         GLenum usage)
 {
-    ANGLE_TRY(mImpl->setData(target, data, size, usage));
+    ANGLE_TRY(mImpl->setData(rx::SafeGetImpl(context), target, data, size, usage));
 
     mIndexRangeCache.clear();
     mState.mUsage = usage;
@@ -63,9 +69,13 @@ Error Buffer::bufferData(GLenum target, const void *data, GLsizeiptr size, GLenu
     return NoError();
 }
 
-Error Buffer::bufferSubData(GLenum target, const void *data, GLsizeiptr size, GLintptr offset)
+Error Buffer::bufferSubData(const Context *context,
+                            GLenum target,
+                            const void *data,
+                            GLsizeiptr size,
+                            GLintptr offset)
 {
-    ANGLE_TRY(mImpl->setSubData(target, data, size, offset));
+    ANGLE_TRY(mImpl->setSubData(rx::SafeGetImpl(context), target, data, size, offset));
 
     mIndexRangeCache.invalidateRange(static_cast<unsigned int>(offset), static_cast<unsigned int>(size));
 

src/libANGLE/Buffer.h

@@ -26,6 +26,7 @@ class GLImplFactory;
 namespace gl
 {
 class Buffer;
+class Context;
 
 class BufferState final : angle::NonCopyable
 {
@@ -68,9 +69,20 @@ class Buffer final : public RefCountObject, public LabeledObject
     void setLabel(const std::string &label) override;
     const std::string &getLabel() const override;
 
-    Error bufferData(GLenum target, const void *data, GLsizeiptr size, GLenum usage);
-    Error bufferSubData(GLenum target, const void *data, GLsizeiptr size, GLintptr offset);
-    Error copyBufferSubData(Buffer* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size);
+    Error bufferData(const Context *context,
+                     GLenum target,
+                     const void *data,
+                     GLsizeiptr size,
+                     GLenum usage);
+    Error bufferSubData(const Context *context,
+                        GLenum target,
+                        const void *data,
+                        GLsizeiptr size,
+                        GLintptr offset);
+    Error copyBufferSubData(Buffer *source,
+                            GLintptr sourceOffset,
+                            GLintptr destOffset,
+                            GLsizeiptr size);
     Error map(GLenum access);
     Error mapRange(GLintptr offset, GLsizeiptr length, GLbitfield access);
     Error unmap(GLboolean *result);
@@ -102,6 +114,6 @@ class Buffer final : public RefCountObject, public LabeledObject
     mutable IndexRangeCache mIndexRangeCache;
 };
 
-}
+}  // namespace gl
 
 #endif   // LIBANGLE_BUFFER_H_

src/libANGLE/Context.cpp

@@ -3577,7 +3577,7 @@ void Context::bufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLe
 {
     Buffer *buffer = mGLState.getTargetBuffer(target);
     ASSERT(buffer);
-    handleError(buffer->bufferData(target, data, size, usage));
+    handleError(buffer->bufferData(this, target, data, size, usage));
 }
 
 void Context::bufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
@@ -3589,7 +3589,7 @@ void Context::bufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, con
 
     Buffer *buffer = mGLState.getTargetBuffer(target);
     ASSERT(buffer);
-    handleError(buffer->bufferSubData(target, data, size, offset));
+    handleError(buffer->bufferSubData(this, target, data, size, offset));
 }
 
 void Context::attachShader(GLuint program, GLuint shader)

src/libANGLE/angletypes.h

@@ -294,8 +294,16 @@ inline DestT *SafeGetImplAs(SrcT *src)
 {
     return src != nullptr ? GetAs<DestT>(src->getImplementation()) : nullptr;
 }
+
+// In some cases we want to retrieve an Impl object, while handling nullptr cases trivially.
+template <typename ObjT>
+auto SafeGetImpl(ObjT *src) -> decltype(src->getImplementation())
+{
+    return src ? src->getImplementation() : nullptr;
 }
 
+}  // namespace rx
+
 #include "angletypes.inl"
 
 namespace angle

src/libANGLE/renderer/BufferImpl.h

@@ -22,6 +22,7 @@ class BufferState;
 
 namespace rx
 {
+class ContextImpl;
 
 class BufferImpl : angle::NonCopyable
 {
@@ -29,8 +30,16 @@ class BufferImpl : angle::NonCopyable
     BufferImpl(const gl::BufferState &state) : mState(state) {}
     virtual ~BufferImpl() { }
 
-    virtual gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage)     = 0;
-    virtual gl::Error setSubData(GLenum target, const void *data, size_t size, size_t offset) = 0;
+    virtual gl::Error setData(ContextImpl *context,
+                              GLenum target,
+                              const void *data,
+                              size_t size,
+                              GLenum usage) = 0;
+    virtual gl::Error setSubData(ContextImpl *context,
+                                 GLenum target,
+                                 const void *data,
+                                 size_t size,
+                                 size_t offset) = 0;
     virtual gl::Error copySubData(BufferImpl *source,
                                   GLintptr sourceOffset,
                                   GLintptr destOffset,

src/libANGLE/renderer/BufferImpl_mock.h

@@ -15,15 +15,14 @@
 
 namespace rx
 {
-
 class MockBufferImpl : public BufferImpl
 {
   public:
     MockBufferImpl() : BufferImpl(mMockState) {}
     ~MockBufferImpl() { destructor(); }
 
-    MOCK_METHOD4(setData, gl::Error(GLenum, const void *, size_t, GLenum));
-    MOCK_METHOD4(setSubData, gl::Error(GLenum, const void *, size_t, size_t));
+    MOCK_METHOD5(setData, gl::Error(ContextImpl *, GLenum, const void *, size_t, GLenum));
+    MOCK_METHOD5(setSubData, gl::Error(ContextImpl *, GLenum, const void *, size_t, size_t));
     MOCK_METHOD4(copySubData, gl::Error(BufferImpl *, GLintptr, GLintptr, GLsizeiptr));
     MOCK_METHOD2(map, gl::Error(GLenum, GLvoid **));
     MOCK_METHOD4(mapRange, gl::Error(size_t, size_t, GLbitfield, GLvoid **));

src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp

@@ -299,10 +299,14 @@ Buffer11::~Buffer11()
     mRenderer->onBufferDelete(this);
 }
 
-gl::Error Buffer11::setData(GLenum target, const void *data, size_t size, GLenum usage)
+gl::Error Buffer11::setData(ContextImpl *context,
+                            GLenum target,
+                            const void *data,
+                            size_t size,
+                            GLenum usage)
 {
     updateD3DBufferUsage(usage);
-    ANGLE_TRY(setSubData(target, data, size, 0));
+    ANGLE_TRY(setSubData(context, target, data, size, 0));
     return gl::NoError();
 }
 
@@ -324,7 +328,11 @@ gl::ErrorOrResult<Buffer11::SystemMemoryStorage *> Buffer11::getSystemMemoryStor
     return GetAs<SystemMemoryStorage>(storage);
 }
 
-gl::Error Buffer11::setSubData(GLenum target, const void *data, size_t size, size_t offset)
+gl::Error Buffer11::setSubData(ContextImpl * /*context*/,
+                               GLenum target,
+                               const void *data,
+                               size_t size,
+                               size_t offset)
 {
     size_t requiredSize = size + offset;
 

src/libANGLE/renderer/d3d/d3d11/Buffer11.h

@@ -74,8 +74,16 @@ class Buffer11 : public BufferD3D
     void invalidateStaticData() override;
 
     // BufferImpl implementation
-    gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override;
-    gl::Error setSubData(GLenum target, const void *data, size_t size, size_t offset) override;
+    gl::Error setData(ContextImpl *context,
+                      GLenum target,
+                      const void *data,
+                      size_t size,
+                      GLenum usage) override;
+    gl::Error setSubData(ContextImpl *context,
+                         GLenum target,
+                         const void *data,
+                         size_t size,
+                         size_t offset) override;
     gl::Error copySubData(BufferImpl *source,
                           GLintptr sourceOffset,
                           GLintptr destOffset,

src/libANGLE/renderer/d3d/d3d9/Buffer9.cpp

@@ -21,7 +21,11 @@ Buffer9::~Buffer9()
     mSize = 0;
 }
 
-gl::Error Buffer9::setData(GLenum /*target*/, const void *data, size_t size, GLenum usage)
+gl::Error Buffer9::setData(ContextImpl * /*context*/,
+                           GLenum /*target*/,
+                           const void *data,
+                           size_t size,
+                           GLenum usage)
 {
     if (size > mMemory.size())
     {
@@ -50,7 +54,11 @@ gl::Error Buffer9::getData(const uint8_t **outData)
     return gl::NoError();
 }
 
-gl::Error Buffer9::setSubData(GLenum /*target*/, const void *data, size_t size, size_t offset)
+gl::Error Buffer9::setSubData(ContextImpl * /*context*/,
+                              GLenum /*target*/,
+                              const void *data,
+                              size_t size,
+                              size_t offset)
 {
     if (offset + size > mMemory.size())
     {

src/libANGLE/renderer/d3d/d3d9/Buffer9.h

@@ -29,8 +29,16 @@ class Buffer9 : public BufferD3D
     gl::Error getData(const uint8_t **outData) override;
 
     // BufferImpl implementation
-    gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override;
-    gl::Error setSubData(GLenum target, const void *data, size_t size, size_t offset) override;
+    gl::Error setData(ContextImpl *context,
+                      GLenum target,
+                      const void *data,
+                      size_t size,
+                      GLenum usage) override;
+    gl::Error setSubData(ContextImpl *context,
+                         GLenum target,
+                         const void *data,
+                         size_t size,
+                         size_t offset) override;
     gl::Error copySubData(BufferImpl *source,
                           GLintptr sourceOffset,
                           GLintptr destOffset,

src/libANGLE/renderer/gl/BufferGL.cpp

@@ -55,7 +55,11 @@ BufferGL::~BufferGL()
     mBufferID = 0;
 }
 
-gl::Error BufferGL::setData(GLenum /*target*/, const void *data, size_t size, GLenum usage)
+gl::Error BufferGL::setData(ContextImpl * /*context*/,
+                            GLenum /*target*/,
+                            const void *data,
+                            size_t size,
+                            GLenum usage)
 {
     mStateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
     mFunctions->bufferData(DestBufferOperationTarget, size, data, usage);
@@ -78,7 +82,11 @@ gl::Error BufferGL::setData(GLenum /*target*/, const void *data, size_t size, GL
     return gl::NoError();
 }
 
-gl::Error BufferGL::setSubData(GLenum /*target*/, const void *data, size_t size, size_t offset)
+gl::Error BufferGL::setSubData(ContextImpl * /*context*/,
+                               GLenum /*target*/,
+                               const void *data,
+                               size_t size,
+                               size_t offset)
 {
     mStateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
     mFunctions->bufferSubData(DestBufferOperationTarget, offset, size, data);

src/libANGLE/renderer/gl/BufferGL.h

@@ -26,8 +26,16 @@ class BufferGL : public BufferImpl
              StateManagerGL *stateManager);
     ~BufferGL() override;
 
-    gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override;
-    gl::Error setSubData(GLenum target, const void *data, size_t size, size_t offset) override;
+    gl::Error setData(ContextImpl *context,
+                      GLenum target,
+                      const void *data,
+                      size_t size,
+                      GLenum usage) override;
+    gl::Error setSubData(ContextImpl *context,
+                         GLenum target,
+                         const void *data,
+                         size_t size,
+                         size_t offset) override;
     gl::Error copySubData(BufferImpl* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size) override;
     gl::Error map(GLenum access, GLvoid **mapPtr) override;
     gl::Error mapRange(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr) override;

src/libANGLE/renderer/null/BufferNULL.cpp

@@ -24,7 +24,11 @@ BufferNULL::~BufferNULL()
 {
 }
 
-gl::Error BufferNULL::setData(GLenum target, const void *data, size_t size, GLenum usage)
+gl::Error BufferNULL::setData(ContextImpl *context,
+                              GLenum target,
+                              const void *data,
+                              size_t size,
+                              GLenum usage)
 {
     mData.resize(size, 0);
     if (size > 0 && data != nullptr)
@@ -34,7 +38,11 @@ gl::Error BufferNULL::setData(GLenum target, const void *data, size_t size, GLen
     return gl::NoError();
 }
 
-gl::Error BufferNULL::setSubData(GLenum target, const void *data, size_t size, size_t offset)
+gl::Error BufferNULL::setSubData(ContextImpl *context,
+                                 GLenum target,
+                                 const void *data,
+                                 size_t size,
+                                 size_t offset)
 {
     if (size > 0)
     {

src/libANGLE/renderer/null/BufferNULL.h

@@ -21,8 +21,16 @@ class BufferNULL : public BufferImpl
     BufferNULL(const gl::BufferState &state);
     ~BufferNULL() override;
 
-    gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override;
-    gl::Error setSubData(GLenum target, const void *data, size_t size, size_t offset) override;
+    gl::Error setData(ContextImpl *context,
+                      GLenum target,
+                      const void *data,
+                      size_t size,
+                      GLenum usage) override;
+    gl::Error setSubData(ContextImpl *context,
+                         GLenum target,
+                         const void *data,
+                         size_t size,
+                         size_t offset) override;
     gl::Error copySubData(BufferImpl *source,
                           GLintptr sourceOffset,
                           GLintptr destOffset,

src/libANGLE/renderer/vulkan/BufferVk.cpp

@@ -10,11 +10,13 @@
 #include "libANGLE/renderer/vulkan/BufferVk.h"
 
 #include "common/debug.h"
+#include "libANGLE/renderer/vulkan/ContextVk.h"
+#include "libANGLE/renderer/vulkan/RendererVk.h"
 
 namespace rx
 {
 
-BufferVk::BufferVk(const gl::BufferState &state) : BufferImpl(state)
+BufferVk::BufferVk(const gl::BufferState &state) : BufferImpl(state), mRequiredSize(0)
 {
 }
 
@@ -22,16 +24,80 @@ BufferVk::~BufferVk()
 {
 }
 
-gl::Error BufferVk::setData(GLenum target, const void *data, size_t size, GLenum usage)
+gl::Error BufferVk::setData(ContextImpl *context,
+                            GLenum target,
+                            const void *data,
+                            size_t size,
+                            GLenum usage)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    ContextVk *contextVk = GetAs<ContextVk>(context);
+    auto device          = contextVk->getDevice();
+
+    // TODO(jmadill): Proper usage bit implementation. Likely will involve multiple backing buffers
+    // like in D3D11.
+    VkBufferCreateInfo createInfo;
+    createInfo.sType                 = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    createInfo.pNext                 = nullptr;
+    createInfo.flags                 = 0;
+    createInfo.size                  = size;
+    createInfo.usage                 = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
+    createInfo.sharingMode           = VK_SHARING_MODE_EXCLUSIVE;
+    createInfo.queueFamilyIndexCount = 0;
+    createInfo.pQueueFamilyIndices   = nullptr;
+
+    vk::Buffer newBuffer(device);
+    ANGLE_TRY(newBuffer.init(createInfo));
+
+    // Find a compatible memory pool index. If the index doesn't change, we could cache it.
+    // Not finding a valid memory pool means an out-of-spec driver, or internal error.
+    // TODO(jmadill): More efficient memory allocation.
+    VkMemoryRequirements memoryRequirements;
+    vkGetBufferMemoryRequirements(device, newBuffer.getHandle(), &memoryRequirements);
+
+    // The requirements size is not always equal to the specified API size.
+    ASSERT(memoryRequirements.size >= size);
+    mRequiredSize = static_cast<size_t>(memoryRequirements.size);
+
+    VkPhysicalDeviceMemoryProperties memoryProperties;
+    vkGetPhysicalDeviceMemoryProperties(contextVk->getRenderer()->getPhysicalDevice(),
+                                        &memoryProperties);
+
+    auto memoryTypeIndex =
+        FindMemoryType(memoryProperties, memoryRequirements,
+                       VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+    ANGLE_VK_CHECK(memoryTypeIndex.valid(), VK_ERROR_INCOMPATIBLE_DRIVER);
+
+    VkMemoryAllocateInfo allocInfo;
+    allocInfo.sType           = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+    allocInfo.pNext           = nullptr;
+    allocInfo.memoryTypeIndex = memoryTypeIndex.value();
+    allocInfo.allocationSize  = memoryRequirements.size;
+
+    ANGLE_TRY(newBuffer.getMemory().allocate(allocInfo));
+    ANGLE_TRY(newBuffer.bindMemory());
+
+    mBuffer = std::move(newBuffer);
+
+    if (data)
+    {
+        ANGLE_TRY(setDataImpl(static_cast<const uint8_t *>(data), size, 0));
+    }
+
+    return gl::NoError();
 }
 
-gl::Error BufferVk::setSubData(GLenum target, const void *data, size_t size, size_t offset)
+gl::Error BufferVk::setSubData(ContextImpl *context,
+                               GLenum target,
+                               const void *data,
+                               size_t size,
+                               size_t offset)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
+    ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
+
+    ANGLE_TRY(setDataImpl(static_cast<const uint8_t *>(data), size, offset));
+
+    return gl::NoError();
 }
 
 gl::Error BufferVk::copySubData(BufferImpl *source,
@@ -45,20 +111,33 @@ gl::Error BufferVk::copySubData(BufferImpl *source,
 
 gl::Error BufferVk::map(GLenum access, GLvoid **mapPtr)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
+    ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
+
+    ANGLE_TRY(
+        mBuffer.getMemory().map(0, mState.getSize(), 0, reinterpret_cast<uint8_t **>(mapPtr)));
+
+    return gl::NoError();
 }
 
 gl::Error BufferVk::mapRange(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
+    ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
+
+    ANGLE_TRY(mBuffer.getMemory().map(offset, length, 0, reinterpret_cast<uint8_t **>(mapPtr)));
+
+    return gl::NoError();
 }
 
 gl::Error BufferVk::unmap(GLboolean *result)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
+    ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
+
+    mBuffer.getMemory().unmap();
+
+    return gl::NoError();
 }
 
 gl::Error BufferVk::getIndexRange(GLenum type,
@@ -71,4 +150,17 @@ gl::Error BufferVk::getIndexRange(GLenum type,
     return gl::Error(GL_INVALID_OPERATION);
 }
 
+vk::Error BufferVk::setDataImpl(const uint8_t *data, size_t size, size_t offset)
+{
+    uint8_t *mapPointer = nullptr;
+    ANGLE_TRY(mBuffer.getMemory().map(offset, size, 0, &mapPointer));
+    ASSERT(mapPointer);
+
+    memcpy(mapPointer, data, size);
+
+    mBuffer.getMemory().unmap();
+
+    return vk::NoError();
+}
+
 }  // namespace rx

src/libANGLE/renderer/vulkan/BufferVk.h

@@ -11,6 +11,7 @@
 #define LIBANGLE_RENDERER_VULKAN_BUFFERVK_H_
 
 #include "libANGLE/renderer/BufferImpl.h"
+#include "libANGLE/renderer/vulkan/renderervk_utils.h"
 
 namespace rx
 {
@@ -21,8 +22,16 @@ class BufferVk : public BufferImpl
     BufferVk(const gl::BufferState &state);
     ~BufferVk() override;
 
-    gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override;
-    gl::Error setSubData(GLenum target, const void *data, size_t size, size_t offset) override;
+    gl::Error setData(ContextImpl *context,
+                      GLenum target,
+                      const void *data,
+                      size_t size,
+                      GLenum usage) override;
+    gl::Error setSubData(ContextImpl *context,
+                         GLenum target,
+                         const void *data,
+                         size_t size,
+                         size_t offset) override;
     gl::Error copySubData(BufferImpl *source,
                           GLintptr sourceOffset,
                           GLintptr destOffset,
@@ -36,6 +45,12 @@ class BufferVk : public BufferImpl
                             size_t count,
                             bool primitiveRestartEnabled,
                             gl::IndexRange *outRange) override;
+
+  private:
+    vk::Error setDataImpl(const uint8_t *data, size_t size, size_t offset);
+
+    vk::Buffer mBuffer;
+    size_t mRequiredSize;
 };
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -509,10 +509,15 @@ void RendererVk::ensureCapsInitialized() const
 
 void RendererVk::generateCaps(gl::Caps * /*outCaps*/,
                               gl::TextureCapsMap * /*outTextureCaps*/,
-                              gl::Extensions * /*outExtensions*/,
+                              gl::Extensions *outExtensions,
                               gl::Limitations * /* outLimitations */) const
 {
     // TODO(jmadill): Caps.
+
+    // Enable this for simple buffer readback testing, but some functionality is missing.
+    // TODO(jmadill): Support full mapBufferRange extension.
+    outExtensions->mapBuffer      = true;
+    outExtensions->mapBufferRange = true;
 }
 
 const gl::Caps &RendererVk::getNativeCaps() const

src/libANGLE/renderer/vulkan/renderervk_utils.cpp

@@ -763,6 +763,67 @@ Error StagingImage::init(uint32_t queueFamilyIndex,
     return NoError();
 }
 
+// Buffer implementation.
+Buffer::Buffer()
+{
+}
+
+Buffer::Buffer(VkDevice device) : WrappedObject(device), mMemory(device)
+{
+}
+
+Buffer::Buffer(Buffer &&other)
+    : WrappedObject(std::move(other)), mMemory(std::move(other.getMemory()))
+{
+}
+
+Buffer::~Buffer()
+{
+    if (mHandle != VK_NULL_HANDLE)
+    {
+        ASSERT(validDevice());
+        vkDestroyBuffer(mDevice, mHandle, nullptr);
+    }
+}
+
+Buffer &Buffer::operator=(Buffer &&other)
+{
+    assignOpBase(std::move(other));
+    std::swap(mMemory, other.mMemory);
+    return *this;
+}
+
+Error Buffer::init(const VkBufferCreateInfo &createInfo)
+{
+    ASSERT(validDevice() && !valid());
+    ANGLE_VK_TRY(vkCreateBuffer(mDevice, &createInfo, nullptr, &mHandle));
+    return NoError();
+}
+
+Error Buffer::bindMemory()
+{
+    ASSERT(valid() && mMemory.valid());
+    ANGLE_VK_TRY(vkBindBufferMemory(mDevice, mHandle, mMemory.getHandle(), 0));
+    return NoError();
+}
+
 }  // namespace vk
 
+Optional<uint32_t> FindMemoryType(const VkPhysicalDeviceMemoryProperties &memoryProps,
+                                  const VkMemoryRequirements &requirements,
+                                  uint32_t propertyFlagMask)
+{
+    for (uint32_t typeIndex = 0; typeIndex < memoryProps.memoryTypeCount; ++typeIndex)
+    {
+        if ((requirements.memoryTypeBits & (1u << typeIndex)) != 0 &&
+            ((memoryProps.memoryTypes[typeIndex].propertyFlags & propertyFlagMask) ==
+             propertyFlagMask))
+        {
+            return typeIndex;
+        }
+    }
+
+    return Optional<uint32_t>::Invalid();
+}
+
 }  // namespace rx

src/libANGLE/renderer/vulkan/renderervk_utils.h

@@ -12,6 +12,7 @@
 
 #include <vulkan/vulkan.h>
 
+#include "common/Optional.h"
 #include "libANGLE/Error.h"
 
 namespace gl
@@ -270,8 +271,31 @@ class StagingImage final : angle::NonCopyable
     VkDeviceSize mSize;
 };
 
+class Buffer final : public WrappedObject<VkBuffer>
+{
+  public:
+    Buffer();
+    Buffer(VkDevice device);
+    Buffer(Buffer &&other);
+    ~Buffer();
+    Buffer &operator=(Buffer &&other);
+
+    Error init(const VkBufferCreateInfo &createInfo);
+    Error bindMemory();
+
+    DeviceMemory &getMemory() { return mMemory; }
+    const DeviceMemory &getMemory() const { return mMemory; }
+
+  private:
+    DeviceMemory mMemory;
+};
+
 }  // namespace vk
 
+Optional<uint32_t> FindMemoryType(const VkPhysicalDeviceMemoryProperties &memoryProps,
+                                  const VkMemoryRequirements &requirements,
+                                  uint32_t propertyFlagMask);
+
 }  // namespace rx
 
 #define ANGLE_VK_TRY(command)                                          \

src/tests/gl_tests/D3D11EmulatedIndexedBufferTest.cpp

@@ -37,8 +37,8 @@ class D3D11EmulatedIndexedBufferTest : public ANGLETest
 
         mSourceBuffer      = new rx::Buffer11(mBufferState, mRenderer);
         GLfloat testData[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f };
-        gl::Error error =
-            mSourceBuffer->setData(GL_ARRAY_BUFFER, testData, sizeof(testData), GL_STATIC_DRAW);
+        gl::Error error    = mSourceBuffer->setData(nullptr, GL_ARRAY_BUFFER, testData,
+                                                 sizeof(testData), GL_STATIC_DRAW);
         ASSERT_FALSE(error.isError());
 
         mTranslatedAttribute.baseOffset            = 0;

src/tests/gl_tests/SimpleOperationTest.cpp

@@ -54,6 +54,13 @@ void SimpleOperationTest::verifyBuffer(const std::vector<uint8_t> &data, GLenum
 
 TEST_P(SimpleOperationTest, CompileVertexShader)
 {
+    if (IsVulkan())
+    {
+        // TODO(jmadill): Complete Vulkan implementation.
+        std::cout << "Test skipped on Vulkan." << std::endl;
+        return;
+    }
+
     const std::string source = SHADER_SOURCE
     (
         attribute vec4 a_input;
@@ -72,6 +79,13 @@ TEST_P(SimpleOperationTest, CompileVertexShader)
 
 TEST_P(SimpleOperationTest, CompileFragmentShader)
 {
+    if (IsVulkan())
+    {
+        // TODO(jmadill): Complete Vulkan implementation.
+        std::cout << "Test skipped on Vulkan." << std::endl;
+        return;
+    }
+
     const std::string source = SHADER_SOURCE
     (
         precision mediump float;
@@ -91,6 +105,13 @@ TEST_P(SimpleOperationTest, CompileFragmentShader)
 
 TEST_P(SimpleOperationTest, LinkProgram)
 {
+    if (IsVulkan())
+    {
+        // TODO(jmadill): Complete Vulkan implementation.
+        std::cout << "Test skipped on Vulkan." << std::endl;
+        return;
+    }
+
     const std::string vsSource = SHADER_SOURCE
     (
         void main()
@@ -116,6 +137,13 @@ TEST_P(SimpleOperationTest, LinkProgram)
 
 TEST_P(SimpleOperationTest, LinkProgramWithUniforms)
 {
+    if (IsVulkan())
+    {
+        // TODO(jmadill): Complete Vulkan implementation.
+        std::cout << "Test skipped on Vulkan." << std::endl;
+        return;
+    }
+
     const std::string vsSource = SHADER_SOURCE
     (
         void main()
@@ -147,6 +175,13 @@ TEST_P(SimpleOperationTest, LinkProgramWithUniforms)
 
 TEST_P(SimpleOperationTest, LinkProgramWithAttributes)
 {
+    if (IsVulkan())
+    {
+        // TODO(jmadill): Complete Vulkan implementation.
+        std::cout << "Test skipped on Vulkan." << std::endl;
+        return;
+    }
+
     const std::string vsSource = SHADER_SOURCE
     (
         attribute vec4 a_input;
@@ -231,6 +266,7 @@ ANGLE_INSTANTIATE_TEST(SimpleOperationTest,
                        ES2_OPENGL(),
                        ES3_OPENGL(),
                        ES2_OPENGLES(),
-                       ES3_OPENGLES());
+                       ES3_OPENGLES(),
+                       ES2_VULKAN());
 
 } // namespace

src/tests/perf_tests/IndexDataManagerTest.cpp

@@ -79,7 +79,11 @@ class MockBufferD3D : public rx::BufferD3D
     MockBufferD3D(rx::BufferFactoryD3D *factory) : BufferD3D(mockState, factory), mData() {}
 
     // BufferImpl
-    gl::Error setData(GLenum target, const void *data, size_t size, GLenum) override
+    gl::Error setData(rx::ContextImpl *context,
+                      GLenum target,
+                      const void *data,
+                      size_t size,
+                      GLenum) override
     {
         mData.resize(size);
         if (data && size > 0)
@@ -89,7 +93,7 @@ class MockBufferD3D : public rx::BufferD3D
         return gl::NoError();
     }
 
-    MOCK_METHOD4(setSubData, gl::Error(GLenum, const void *, size_t, size_t));
+    MOCK_METHOD5(setSubData, gl::Error(rx::ContextImpl *, GLenum, const void *, size_t, size_t));
     MOCK_METHOD4(copySubData, gl::Error(BufferImpl*, GLintptr, GLintptr, GLsizeiptr));
     MOCK_METHOD2(map, gl::Error(GLenum, GLvoid **));
     MOCK_METHOD4(mapRange, gl::Error(size_t, size_t, GLbitfield, GLvoid **));
@@ -162,8 +166,8 @@ IndexDataManagerPerfTest::IndexDataManagerPerfTest()
     {
         indexData[index] = static_cast<GLushort>(index);
     }
-    mIndexBuffer.bufferData(GL_ARRAY_BUFFER, &indexData[0], indexData.size() * sizeof(GLushort),
-                            GL_STATIC_DRAW);
+    mIndexBuffer.bufferData(nullptr, GL_ARRAY_BUFFER, &indexData[0],
+                            indexData.size() * sizeof(GLushort), GL_STATIC_DRAW);
 }
 
 void IndexDataManagerPerfTest::step()