buffer.hpp

Go to the documentation of this file.

 
/*
 * COPYRIGHT (c) 2024 John Reppy (https://cs.uchicago.edu/~jhr)
 * All rights reserved.
 */
 
#ifndef _CS237_BUFFER_HPP_
#define _CS237_BUFFER_HPP_
 
#ifndef _CS237_HPP_
#error "cs237/buffer.hpp should not be included directly"
#endif
 
namespace cs237 {
 
class Buffer {
public:
    vk::Buffer vkBuffer () const { return this->_buf; }
 
    MemoryObj *memory () const { return this->_mem; }
 
    vk::MemoryRequirements requirements ()
    {
        vk::MemoryRequirements reqs;
        this->_app->_device.getBufferMemoryRequirements(this->_buf, &reqs);
        return reqs;
    }
 
protected:
    Application *_app;          
    vk::Buffer _buf;            
    MemoryObj *_mem;            
 
    Buffer (Application *app, vk::BufferUsageFlags usage, size_t sz)
      : _app(app)
    {
        vk::BufferCreateInfo info(
            {}, /* flags */
            sz,
            usage,
            vk::SharingMode::eExclusive, /* sharingMode */
            {}); /* queueFamilyIndices */
 
        this->_buf = app->_device.createBuffer (info);
        this->_mem = new MemoryObj(app, this->requirements());
 
        // bind the memory object to the buffer
        this->_app->_device.bindBufferMemory(this->_buf, this->_mem->_mem, 0);
 
    }
 
    ~Buffer ()
    {
        delete this->_mem;
        this->_app->_device.destroyBuffer (this->_buf, nullptr);
    }
 
    void _copyTo (const void *src, size_t offset, size_t sz)
    {
        this->_mem->copyTo(src, offset, sz);
    }
 
    void _copyTo (const void *src) { this->_mem->copyTo(src); }
 
};
 
template <typename V>
class VertexBuffer : public Buffer {
public:
 
    using VertexType = V;
 
    VertexBuffer (Application *app, uint32_t nVerts)
      : Buffer (app, vk::BufferUsageFlagBits::eVertexBuffer, nVerts*sizeof(V))
    { }
 
    VertexBuffer (Application *app, vk::ArrayProxy<V> const &src)
      : VertexBuffer(app, src.size())
    {
        this->copyTo(src);
    }
 
    void copyTo (vk::ArrayProxy<V> const &src)
    {
        assert ((src.size() * sizeof(V) <= this->_mem->size()) && "src is too large");
        this->_copyTo(src.data(), 0, src.size()*sizeof(V));
    }
 
    void copyTo (vk::ArrayProxy<V> const &src, uint32_t offset)
    {
        assert (((src.size()+offset) * sizeof(V) <= this->_mem->size())
            && "src is too large");
        this->_copyTo(src.data(), offset*sizeof(V), src.size()*sizeof(V));
    }
 
};
 
template <typename I>
class IndexBuffer : public Buffer {
public:
 
    using IndexType = I;
 
    IndexBuffer (Application *app, uint32_t nIndices)
      : Buffer (app, vk::BufferUsageFlagBits::eIndexBuffer, nIndices*sizeof(I)),
        _nIndices(nIndices)
    { }
 
    IndexBuffer (Application *app, vk::ArrayProxy<I> const &src)
      : IndexBuffer(app, src.size())
    {
        this->copyTo(src);
    }
 
    uint32_t nIndices () const { return this->_nIndices; }
 
    void copyTo (vk::ArrayProxy<I> const &src)
    {
        assert ((src.size() * sizeof(I) <= this->_mem->size()) && "src is too large");
        this->_copyTo(src.data(), 0, src.size()*sizeof(I));
    }
 
    void copyTo (vk::ArrayProxy<I> const &src, uint32_t offset)
    {
        assert (((src.size()+offset) * sizeof(I) <= this->_mem->size())
            && "src is too large");
        this->_copyTo(src.data(), offset*sizeof(I), src.size()*sizeof(I));
    }
 
private:
    uint32_t _nIndices;
 
};
 
template <typename UB>
class UniformBuffer : public Buffer {
public:
 
    using BufferType = UB;
 
    UniformBuffer (Application *app)
      : Buffer (app, vk::BufferUsageFlagBits::eUniformBuffer, sizeof(UB))
    { }
 
    UniformBuffer (Application *app, UB const &src)
      : UniformBuffer(app)
    {
        this->copyTo(src);
    }
 
    void copyTo (UB const &src)
    {
        this->_copyTo(&src, 0, sizeof(UB));
    }
 
    vk::DescriptorBufferInfo descInfo ()
    {
        return vk::DescriptorBufferInfo(this->_buf, 0, sizeof(UB));
    }
 
};
 
template <typename SV>
class StorageVertexBuffer : public Buffer {
public:
 
    using BufferType = SV;
 
    StorageVertexBuffer (Application *app, uint32_t nVerts)
    : Buffer (app, vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eVertexBuffer, nVerts*sizeof(SV))
    { }
 
    StorageVertexBuffer (Application *app, vk::ArrayProxy<SV> const &src)
    : StorageVertexBuffer(app, src.size())
    {
        this->copyTo(src);
    }
 
    void copyTo (vk::ArrayProxy<SV> const &src)
    {
        assert ((src.size() * sizeof(SV) <= this->_mem->size()) && "src is too large");
        this->_copyTo(src.data(), 0, src.size()*sizeof(SV));
    }
 
    void copyTo (vk::ArrayProxy<SV> const &src, uint32_t offset)
    {
        assert (((src.size()+offset) * sizeof(SV) <= this->_mem->size())
            && "src is too large");
        this->_copyTo(src.data(), offset*sizeof(SV), src.size()*sizeof(SV));
    }
 
    vk::DescriptorBufferInfo descInfo ()
    {
        return vk::DescriptorBufferInfo(this->_buf, 0, sizeof(SV));
    }
 
};
 
template <typename S>
class StorageBuffer : public Buffer {
public:
 
    using BufferType = S;
 
    StorageBuffer (Application *app)
    : Buffer (app, vk::BufferUsageFlagBits::eStorageBuffer, sizeof(S))
    { }
 
    StorageBuffer (Application *app, S const &src)
    : StorageBuffer(app)
    {
        this->copyTo(src);
    }
 
    StorageBuffer (Application *app, vk::ArrayProxy<S> const &src)
    : Buffer (app, vk::BufferUsageFlagBits::eStorageBuffer, src.size()*sizeof(S))
    {
        this->copyTo(src.data());
    }
 
 
    void copyTo (S const &src)
    {
        this->_copyTo(&src, 0, sizeof(S));
    }
 
    vk::DescriptorBufferInfo descInfo ()
    {
        return vk::DescriptorBufferInfo(this->_buf, 0, sizeof(S));
    }
 
    void copyTo (vk::ArrayProxy<S> const &src)
    {
        assert ((src.size() * sizeof(S) <= this->_mem->size()) && "src is too large");
        this->_copyTo(src.data(), 0, src.size()*sizeof(S));
    }
 
    void copyTo (vk::ArrayProxy<S> const &src, uint32_t offset)
    {
        assert (((src.size()+offset) * sizeof(S) <= this->_mem->size())
            && "src is too large");
        this->_copyTo(src.data(), offset*sizeof(S), src.size()*sizeof(S));
    }
 
};
 
} // namespace cs237
 
#endif // !_CS237_BUFFER_HPP_