vertex_buffer_layout.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <span>
#include <string>
#include <string_view>
#include <vector>
 
#include "shader_data_type.hpp"
 
namespace staplegl {
struct vertex_attribute {
    std::string name;
    std::size_t element_count { 1 };
    std::uint32_t offset {};
    shader_data_type::u_type type {};
 
    vertex_attribute() = default;
    ~vertex_attribute() = default;
 
    vertex_attribute(shader_data_type::u_type in_type, std::string_view in_name)
        : name { in_name }
        , type { in_type }
    {
    }
 
    vertex_attribute(shader_data_type::shader_array_type in_type, std::string_view in_name, size_t element_count)
        : name { in_name }
        , element_count { element_count }
        , type { static_cast<shader_data_type::u_type>(in_type) }
    {
    }
 
    vertex_attribute(const vertex_attribute&) noexcept = default;
    auto operator=(const vertex_attribute&) noexcept -> vertex_attribute& = default;
 
    vertex_attribute(vertex_attribute&&) noexcept = default;
    auto operator=(vertex_attribute&&) noexcept -> vertex_attribute& = default;
};
 
class vertex_buffer_layout {
 
private:
    std::vector<vertex_attribute> m_attributes;
    std::size_t m_stride {};
 
public:
    vertex_buffer_layout() = default;
    vertex_buffer_layout(std::initializer_list<vertex_attribute> attributes)
        : m_attributes { attributes }
    {
        for (auto& attribute : m_attributes) {
            attribute.offset = m_stride;
            m_stride += shader_data_type::size(attribute.type) * attribute.element_count;
        }
    }
 
    [[nodiscard]] constexpr auto stride() const noexcept -> std::size_t { return m_stride; }
 
    [[nodiscard]] constexpr auto stride_elements() const noexcept -> std::size_t { return m_stride / sizeof(float); }
 
    [[nodiscard]] auto get_attributes() const noexcept -> std::span<const vertex_attribute>
    {
        return { m_attributes };
    }
 
    [[nodiscard]] auto operator[](std::size_t index) const -> const vertex_attribute& { return m_attributes[index]; }
};
 
} // namespace staplegl