vertex_array.hpp

Go to the documentation of this file.

 
#pragma once
#include "gl_functions.hpp"
#include "index_buffer.hpp"
#include "vertex_buffer.hpp"
#include "vertex_buffer_inst.hpp"
 
#include <cstdint>
#include <list>
#include <optional>
 
namespace staplegl {
 
class vertex_array {
public:
    vertex_array() noexcept;
    ~vertex_array();
 
    vertex_array(const vertex_array&) = delete;
    auto operator=(const vertex_array&) -> vertex_array& = delete;
 
    vertex_array(vertex_array&& other) noexcept
        : m_id(other.m_id)
        , m_vertex_buffers(std::move(other.m_vertex_buffers))
        , m_instanced_vbo(std::move(other.m_instanced_vbo))
        , m_index_buffer(std::move(other.m_index_buffer))
        , attrib_index(other.attrib_index)
    {
        other.m_id = 0;
    }
 
    auto operator=(vertex_array&& other) noexcept -> vertex_array&
    {
        if (this != &other) {
            m_id = other.m_id;
            m_vertex_buffers = std::move(other.m_vertex_buffers);
            m_instanced_vbo = std::move(other.m_instanced_vbo);
            m_index_buffer = std::move(other.m_index_buffer);
            attrib_index = other.attrib_index;
 
            other.m_id = 0;
        }
        return *this;
    }
 
    using iterator_t = std::list<vertex_buffer>::iterator;
 
    void bind() const;
 
    static void unbind();
 
    auto add_vertex_buffer(vertex_buffer&& vbo) -> vertex_array::iterator_t;
 
    void set_instance_buffer(vertex_buffer_inst&& vbo);
 
    void clear_instance_buffer() { m_instanced_vbo.reset(); }
 
    void set_index_buffer(index_buffer&& ibo);
 
    // utility functions
 
    [[nodiscard]] constexpr auto id() const -> uint32_t { return m_id; }
 
    [[nodiscard]] constexpr auto buffers_data() -> std::list<vertex_buffer>& { return m_vertex_buffers; }
 
    [[nodiscard]] constexpr auto instanced_data() -> std::optional<vertex_buffer_inst>& { return m_instanced_vbo; }
 
    [[nodiscard]] constexpr auto index_data() -> index_buffer& { return m_index_buffer; }
 
private:
    std::uint32_t m_id {};
    std::list<vertex_buffer> m_vertex_buffers;
    std::optional<vertex_buffer_inst> m_instanced_vbo;
    index_buffer m_index_buffer;
 
    uint32_t attrib_index {};
};
 
/*
 
        IMPLEMENTATIONS
 
*/
 
inline vertex_array::vertex_array() noexcept
{
    glGenVertexArrays(1, &m_id);
}
 
inline vertex_array::~vertex_array()
{
    glDeleteVertexArrays(1, &m_id);
}
 
inline void vertex_array::bind() const
{
    glBindVertexArray(m_id);
}
 
inline void vertex_array::unbind()
{
    glBindVertexArray(0);
}
 
inline auto vertex_array::add_vertex_buffer(vertex_buffer&& vbo) -> vertex_array::iterator_t
{
    m_vertex_buffers.push_back(std::move(vbo));
    glBindVertexArray(m_id);
 
    // get a reference to the newly added vertex buffer from the variant in the vector
    vertex_buffer const& vbo_ref = m_vertex_buffers.back();
 
    vbo_ref.bind();
 
    for (const auto& [name, element_count, offset, type] : vbo_ref.layout().get_attributes()) {
        glEnableVertexAttribArray(attrib_index);
        glVertexAttribPointer(
            attrib_index++,
            static_cast<int32_t>(shader_data_type::component_count(type) * element_count),
            shader_data_type::to_opengl_underlying_type(type),
            GL_FALSE,
            static_cast<int32_t>(vbo_ref.layout().stride()),
            reinterpret_cast<const void*>(offset)); // NOLINT (reinterpret-cast)
    }
 
    return std::prev(m_vertex_buffers.end());
}
 
inline void vertex_array::set_instance_buffer(vertex_buffer_inst&& vbo)
{
    m_instanced_vbo = std::move(vbo);
 
    glBindVertexArray(m_id);
    m_instanced_vbo->bind();
 
    for (const auto& [name, element_count, offset, type] : m_instanced_vbo->layout().get_attributes()) {
        glEnableVertexAttribArray(attrib_index);
        glVertexAttribPointer(
            attrib_index++,
            static_cast<int32_t>(shader_data_type::component_count(type) * element_count),
            shader_data_type::to_opengl_underlying_type(type),
            GL_FALSE,
            static_cast<int32_t>(m_instanced_vbo->layout().stride()),
            reinterpret_cast<const void*>(offset)); // NOLINT (reinterpret-cast)
        glVertexAttribDivisor(attrib_index - 1, 1);
    }
}
 
inline void vertex_array::set_index_buffer(index_buffer&& ibo)
{
    m_index_buffer = std::move(ibo);
 
    glBindVertexArray(m_id);
    m_index_buffer.bind();
}
}