Buffer.hpp

#pragma once
#include "graphics/GPUTypes.hpp"
#include "Common.hpp"
 
class GPUBuffer;
 
class Buffer {
public:
 
    Buffer(size_t sizeInBytes, BufferType atype, const std::string & name);
 
    void upload(size_t sizeInBytes, unsigned char * data, size_t offset);
 
    template<typename T>
    void upload(const std::vector<T>& data, size_t offset = 0);
 
    void download(size_t sizeInBytes, unsigned char * data, size_t offset);
 
    void clean();
 
   const std::string & name() const;
 
    Buffer & operator=(const Buffer &) = delete;
 
    Buffer(const Buffer &) = delete;
 
    Buffer & operator=(Buffer &&) = delete;
 
    Buffer(Buffer &&) = delete;
 
    virtual ~Buffer();
 
    const BufferType type; 
 
protected:
 
    Buffer(BufferType atype, const std::string & name);
 
public:
 
    size_t size; 
    std::unique_ptr<GPUBuffer> gpu; 
 
private:
 
    std::string _name; 
 
};
 
template<typename T>
void Buffer::upload(const std::vector<T>& data, size_t offset){
    upload(sizeof(T) * data.size(), (unsigned char*)data.data(), offset);
}
 
class UniformBufferBase : public Buffer {
public:
 
    UniformBufferBase(size_t sizeInBytes, UniformFrequency use, const std::string& name);
 
    bool upload(unsigned char * data);
 
    void clean();
 
    size_t currentOffset() const { return _offset; }
 
    size_t baseSize() const { return _baseSize; }
 
    UniformBufferBase & operator=(const UniformBufferBase &) = delete;
 
    UniformBufferBase(const UniformBufferBase &) = delete;
 
    UniformBufferBase & operator=(UniformBufferBase &&) = delete;
 
    UniformBufferBase(UniformBufferBase &&) = delete;
 
    virtual ~UniformBufferBase();
 
private:
 
    const size_t _baseSize; 
    size_t _alignment = 0; 
    size_t _offset = 0; 
    bool _wrapAround = true; 
};
 
template<typename T>
class UniformBuffer : public UniformBufferBase {
public:
 
    UniformBuffer(size_t count, UniformFrequency usage, const std::string& name);
 
    T & operator[](size_t i){
        return data[i];
    }
 
    const T & operator[](size_t i) const {
        return data[i];
    }
 
    T & at(size_t i){
        return data[i];
    }
 
    const T & at(size_t i) const {
        return data[i];
    }
 
    size_t size() const {
        return data.size();
    }
 
    bool upload();
 
    UniformBuffer & operator=(const UniformBuffer &) = delete;
    
    UniformBuffer(const UniformBuffer &) = delete;
    
    UniformBuffer & operator=(UniformBuffer &&) = default;
    
    UniformBuffer(UniformBuffer &&) = default;
 
    ~UniformBuffer() = default;
 
    std::vector<T> data; 
    
};
 
template <typename T>
UniformBuffer<T>::UniformBuffer(size_t count, UniformFrequency usage, const std::string& name) :
    UniformBufferBase(count * sizeof(T), usage, name) {
    data.resize(count);
}
 
template <typename T>
bool UniformBuffer<T>::upload() {
    return UniformBufferBase::upload(reinterpret_cast<unsigned char*>(data.data()));
}