vertex_buffer.hpp

Go to the documentation of this file.

 
#pragma once
#include "gl_functions.hpp"
#include "vertex_buffer_layout.hpp"
#include <concepts>
#include <functional>
#include <span>
#include <utility>
 
namespace staplegl {
 
template <typename T>
concept plain_old_data = std::is_standard_layout_v<T> && std::is_trivial_v<T>;
 
enum driver_draw_hint {
    STATIC_DRAW = GL_STATIC_DRAW,
    DYNAMIC_DRAW = GL_DYNAMIC_DRAW,
    STREAM_DRAW = GL_STREAM_DRAW
};
 
enum driver_access_specifier {
    READ_ONLY = GL_READ_ONLY,
    WRITE_ONLY = GL_WRITE_ONLY,
    READ_WRITE = GL_READ_WRITE
};
 
class vertex_buffer {
public:
    vertex_buffer(std::span<const float> vertices) noexcept;
    vertex_buffer(std::span<const float> vertices, driver_draw_hint hint) noexcept;
    vertex_buffer(std::span<const float> vertices, vertex_buffer_layout&& layout) noexcept;
    vertex_buffer(std::span<const float> vertices, vertex_buffer_layout&& layout,
        driver_draw_hint hint) noexcept;
    ~vertex_buffer();
 
    // delete copy and assignment, only move is allowed
    vertex_buffer(const vertex_buffer&) = delete;
    auto operator=(const vertex_buffer&) -> vertex_buffer& = delete;
 
    vertex_buffer(vertex_buffer&& other) noexcept;
    auto operator=(vertex_buffer&& other) noexcept -> vertex_buffer&;
 
    void bind() const;
 
    static void unbind();
 
    void set_layout(const vertex_buffer_layout& layout);
    [[nodiscard]] constexpr auto layout() const -> const vertex_buffer_layout&;
 
    void set_data(std::span<const float> vertices) const noexcept;
 
    void set_data(std::span<const float> vertices, driver_draw_hint hint) const noexcept;
 
    // UTILITIES
 
    [[nodiscard]] constexpr auto id() const noexcept -> std::uint32_t { return m_id; }
 
    [[nodiscard]] constexpr auto size() const noexcept -> std::size_t { return m_size; }
 
    [[nodiscard]] constexpr auto draw_hint() const noexcept -> driver_draw_hint { return m_hint; }
 
    [[nodiscard]] constexpr auto size_bytes() const noexcept -> std::size_t { return m_size * m_layout.stride(); }
 
    // APPLY FUNCTION
 
    template <plain_old_data T>
    void apply(const std::function<void(std::span<T> vertices)>& func, driver_access_specifier access_specifier = staplegl::READ_WRITE) noexcept;
 
protected:
    std::uint32_t m_id {};
    staplegl::driver_draw_hint m_hint {};
    vertex_buffer_layout m_layout;
    std::size_t m_size {};
};
 
/*
 
        IMPLEMENTATIONS
 
*/
 
inline vertex_buffer::vertex_buffer(std::span<const float> vertices, vertex_buffer_layout&& layout,
    driver_draw_hint hint) noexcept
    : m_hint(hint)
    , m_layout(std::move(layout))
    , m_size((m_layout.stride()) ? vertices.size_bytes() / m_layout.stride() : static_cast<size_t>(0))
{
    glGenBuffers(1, &m_id);
    glBindBuffer(GL_ARRAY_BUFFER, m_id);
    glBufferData(GL_ARRAY_BUFFER, static_cast<ptrdiff_t>(vertices.size_bytes()), vertices.data(), hint);
}
 
inline vertex_buffer::vertex_buffer(std::span<const float> vertices, driver_draw_hint hint) noexcept
    : vertex_buffer(vertices, vertex_buffer_layout {}, hint)
{
}
 
inline vertex_buffer::vertex_buffer(std::span<const float> vertices, vertex_buffer_layout&& layout) noexcept
    : vertex_buffer(vertices, std::move(layout), driver_draw_hint::STATIC_DRAW)
{
}
 
inline vertex_buffer::vertex_buffer(std::span<const float> vertices) noexcept
    : vertex_buffer(vertices, vertex_buffer_layout {}, driver_draw_hint::STATIC_DRAW)
{
}
 
inline vertex_buffer::~vertex_buffer()
{
    if (m_id != 0) {
        glDeleteBuffers(1, &m_id);
    }
}
 
inline vertex_buffer::vertex_buffer(vertex_buffer&& other) noexcept
    : m_id { other.m_id }
    , m_hint { other.m_hint }
    , m_layout { std::move(other.m_layout) }
    , m_size { other.m_size }
{
    other.m_id = 0;
}
 
inline auto vertex_buffer::operator=(vertex_buffer&& other) noexcept -> vertex_buffer&
{
    if (this != &other) {
        glDeleteBuffers(1, &m_id);
        m_id = other.m_id;
        m_layout = other.m_layout;
        m_hint = other.m_hint;
        m_size = other.m_size;
 
        other.m_id = 0;
    }
 
    return *this;
}
 
inline void vertex_buffer::bind() const
{
    glBindBuffer(GL_ARRAY_BUFFER, m_id);
}
 
inline void vertex_buffer::unbind()
{
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}
 
inline void vertex_buffer::set_layout(const vertex_buffer_layout& layout)
{
    m_layout = layout;
}
 
[[nodiscard]] constexpr auto vertex_buffer::layout() const -> const vertex_buffer_layout&
{
    return m_layout;
}
 
inline void vertex_buffer::set_data(std::span<const float> vertices) const noexcept
{
 
    this->set_data(vertices, m_hint);
}
 
inline void vertex_buffer::set_data(std::span<const float> vertices, driver_draw_hint hint) const noexcept
{
    glBindBuffer(GL_ARRAY_BUFFER, m_id);
    glBufferData(GL_ARRAY_BUFFER, static_cast<ptrdiff_t>(vertices.size_bytes()), vertices.data(), hint);
}
 
template <plain_old_data T>
void vertex_buffer::apply(const std::function<void(std::span<T> vertices)>& func, driver_access_specifier access_specifier) noexcept
{
    glBindBuffer(GL_ARRAY_BUFFER, m_id);
 
    func(std::span { reinterpret_cast<T*>(glMapBuffer(GL_ARRAY_BUFFER, access_specifier)), // NOLINT (reinterpret-cast)
        m_size });
 
    glUnmapBuffer(GL_ARRAY_BUFFER);
}
 
} // namespace staplegl