uniform_buffer.h

#pragma once
 
#include "context.h"
#include "vertex_buffer.h"
 
namespace cgv {
namespace render {
 
template<class T>
class uniform_buffer : public vertex_buffer {
public:
    uniform_buffer(VertexBufferUsage usage = VertexBufferUsage::VBU_STREAM_COPY) : vertex_buffer(VertexBufferType::VBT_UNIFORM, usage) {}
 
    bool create(const context& ctx) {
        return vertex_buffer::create(ctx, sizeof(T));
    }
 
    bool create(const context& ctx, size_t array_size) {
        return vertex_buffer::create(ctx, sizeof(T) * array_size);
    }
 
    bool resize(const context& ctx, size_t array_size) {
        return vertex_buffer::resize(ctx, sizeof(T) * array_size);
    }
 
    bool resize(const context& ctx, const T& data) {
        return vertex_buffer::resize(ctx, reinterpret_cast<const uint8_t*>(&data), sizeof(T));
    }
 
    bool resize(const context& ctx, const std::vector<T>& array) {
        return vertex_buffer::resize(ctx, reinterpret_cast<const uint8_t*>(array.data()), sizeof(T) * array.size());
    }
 
    bool replace(const context& ctx, const T& data) {
        return vertex_buffer::replace(ctx, 0, reinterpret_cast<const uint8_t*>(&data), sizeof(T));
    }
 
    bool replace(const context& ctx, const std::vector<T>& array) {
        return vertex_buffer::replace(ctx, 0, reinterpret_cast<const uint8_t*>(array.data()), sizeof(T) * array.size());
    }
 
    bool resize_or_replace(const context& ctx, const T& data) {
        return size_in_bytes != sizeof(T) ? resize(ctx, data) : replace(ctx, data);
    }
 
    bool resize_or_replace(const context& ctx, std::vector<T>& array) {
        return size_in_bytes != sizeof(T) ? resize(ctx, array) : replace(ctx, array);
    }
 
    bool create_or_resize() = delete;
};
 
} // namespace render
} // namespace cgv