shader.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "gl_functions.hpp"
#include "utility.hpp"
#include <cstdint>
#include <exception>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace staplegl {
 
enum class shader_type {
    vertex,
    fragment,
    tess_control,
    tess_eval,
    geometry
};
 
inline std::string shader_type_to_string(shader_type type) noexcept;
 
struct shader {
    shader_type type;
    std::string source;
};
 
class shader_program {
public:
    shader_program() = default;
 
    shader_program(std::string_view name, std::string_view path) noexcept;
 
    shader_program(std::string_view name, std::initializer_list<std::pair<shader_type, std::string_view>> shaders) noexcept;
 
    shader_program(std::string_view path) noexcept;
 
    shader_program(const shader_program&) = default;
    auto operator=(const shader_program&) -> shader_program& = default;
 
    shader_program(shader_program&& other) noexcept
        : m_shaders { std::move(other.m_shaders) }
        , m_uniform_cache { std::move(other.m_uniform_cache) }
        , m_id { other.m_id }
        , m_name { std::move(other.m_name) }
    {
        other.m_id = 0;
    }
 
    auto operator=(shader_program&& other) noexcept -> shader_program&
    {
        if (this != &other) {
            m_shaders = std::move(other.m_shaders);
            m_uniform_cache = std::move(other.m_uniform_cache);
            m_id = other.m_id;
            m_name = std::move(other.m_name);
            other.m_id = 0;
        }
        return *this;
    }
 
    ~shader_program();
 
public:
    void bind() const;
 
    void unbind() const;
 
    void upload_uniform1i(std::string_view name, int val);
 
    void upload_uniform1f(std::string_view name, float val);
 
    void upload_uniform2f(std::string_view name, float val0, float val1);
 
    void upload_uniform3f(std::string_view name, float val0, float val1, float val2);
 
    void upload_uniform4f(std::string_view name, float val0, float val1, float val2, float val3);
 
    void upload_uniform_mat4f(std::string_view name, float const* mat);
 
    void upload_uniform_mat3f(std::string_view name, float const* mat);
 
    [[nodiscard]] auto constexpr program_id() const -> std::uint32_t;
 
    [[nodiscard]] auto constexpr name() const -> std::string;
 
public:
    auto operator[](std::size_t index) -> shader&;
 
    auto operator[](std::size_t index) const -> const shader&;
 
    [[nodiscard]] static auto is_valid(std::uint32_t id) -> bool;
 
private:
    [[nodiscard]] auto create_program() const -> std::uint32_t;
 
    [[nodiscard]] auto compile(shader_type shader_type, std::string_view source) const -> std::uint32_t;
 
    [[nodiscard]] auto parse_shaders(std::string_view source) const -> std::vector<shader>;
 
private:
    [[nodiscard]] auto uniform_location(std::string_view name) -> int;
 
private:
    static constexpr auto to_gl_type(shader_type shader_type) -> std::uint32_t;
 
    [[nodiscard]] static auto string_to_shader_type(std::string_view str) -> std::optional<shader_type>;
 
private:
    std::vector<shader> m_shaders;
    std::unordered_map<std::string_view, int> m_uniform_cache;
    std::uint32_t m_id {};
    std::string m_name;
};
 
/*
 
        IMPLEMENTATIONS
 
*/
 
inline shader_program::shader_program(std::string_view name, std::string_view path) noexcept
    : m_shaders { parse_shaders(util::read_file(path)) }
    , m_uniform_cache {}
    , m_id(create_program())
    , m_name { name }
{
}
 
inline shader_program::shader_program(std::string_view name,
    std::initializer_list<std::pair<shader_type, std::string_view>> shaders) noexcept
    : m_id(create_program())
    , m_name { name }
{
    for (const auto& [type, path] : shaders)
        m_shaders.push_back({ type, util::read_file(path) });
}
 
inline shader_program::shader_program(std::string_view path) noexcept
    : shader_program { util::get_file_name(path), path }
{
}
 
inline shader_program::~shader_program()
{
    glDeleteProgram(m_id);
}
 
inline void shader_program::bind() const
{
    glUseProgram(m_id);
}
 
inline void shader_program::unbind() const
{
    glUseProgram(0);
}
 
inline void shader_program::upload_uniform1i(std::string_view name, int val)
{
    glUniform1i(uniform_location(name), val);
}
 
inline void shader_program::upload_uniform1f(std::string_view name, float val)
{
    glUniform1f(uniform_location(name), val);
}
 
inline void shader_program::upload_uniform2f(std::string_view name, float val0, float val1)
{
    glUniform2f(uniform_location(name), val0, val1);
}
 
inline void shader_program::upload_uniform3f(std::string_view name, float val0, float val1, float val2)
{
    glUniform3f(uniform_location(name), val0, val1, val2);
}
 
inline void shader_program::upload_uniform4f(std::string_view name, float val0, float val1, float val2, float val3)
{
    glUniform4f(uniform_location(name), val0, val1, val2, val3);
}
 
inline void shader_program::upload_uniform_mat4f(std::string_view name, float const* mat)
{
    glUniformMatrix4fv(uniform_location(name), 1, GL_FALSE, mat);
}
 
inline void shader_program::upload_uniform_mat3f(std::string_view name, float const* mat)
{
    glUniformMatrix3fv(uniform_location(name), 1, GL_FALSE, mat);
}
 
inline constexpr auto shader_program::program_id() const -> std::uint32_t
{
    return m_id;
}
 
inline constexpr auto shader_program::name() const -> std::string
{
    return m_name;
}
 
inline auto shader_program::operator[](std::size_t index) -> shader&
{
    return m_shaders[index];
}
 
inline auto shader_program::operator[](std::size_t index) const -> const shader&
{
    return m_shaders[index];
}
 
inline auto shader_program::create_program() const -> std::uint32_t
{
    const std::uint32_t program { glCreateProgram() };
    std::vector<std::uint32_t> shader_ids;
 
    shader_ids.reserve(m_shaders.size());
    for (const auto& [type, src] : m_shaders) {
        shader_ids.push_back(compile(type, src));
    }
 
    for (const auto& id : shader_ids) {
        glAttachShader(program, id);
    }
    glLinkProgram(program);
 
    int link_success = 0;
    glGetProgramiv(program, GL_LINK_STATUS, &link_success);
 
    if (!link_success) [[unlikely]] {
#ifdef STAPLEGL_DEBUG
        int max_length {};
        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &max_length);
        std::vector<char> error_log(max_length);
        glGetProgramInfoLog(program, max_length, &max_length, &error_log[0]);
        std::fprintf(stderr, STAPLEGL_LINEINFO ", failed to link shader program: %s\n",
            error_log.data());
#endif // STAPLEGL_DEBUG
        glDeleteProgram(program);
        return 0;
    }
 
    // Detach and delete shaders after linking the program.
    for (const auto& id : shader_ids) {
        glDetachShader(program, id);
        glDeleteShader(id);
    }
 
    glValidateProgram(program);
 
    int success = 0;
    glGetProgramiv(program, GL_VALIDATE_STATUS, &success);
    if (!success) [[unlikely]] {
#ifdef STAPLEGL_DEBUG
        int max_length {};
        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &max_length);
        std::string error_log(max_length, '\0');
        glGetProgramInfoLog(program, max_length, &max_length, &error_log[0]);
        std::fprintf(stderr, STAPLEGL_LINEINFO ", failed to validate shader program: %s\n",
            error_log.data());
#endif // STAPLEGL_DEBUG
        glDeleteProgram(program);
        return 0;
    }
 
    return program;
}
 
inline auto shader_program::compile(shader_type shader_type, std::string_view source) const -> std::uint32_t
{
    const std::uint32_t id { glCreateShader(to_gl_type(shader_type)) };
 
    // taking a pointer to this temporary allows us to get its address, without this intermediate
    // variable we are forced to use the address of the temporary, which is not allowed.
    // if anyone knows a better way to do this, please let me know.
    const char* src { source.data() };
 
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);
 
    int comp_ok {};
    glGetShaderiv(id, GL_COMPILE_STATUS, &comp_ok);
 
    if (comp_ok == GL_FALSE) [[unlikely]] {
#ifdef STAPLEGL_DEBUG
        int max_length {};
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &max_length);
        std::string error_log(max_length, '\0');
        glGetShaderInfoLog(id, max_length, &max_length, &error_log[0]);
        int32_t type_id {};
        glGetShaderiv(id, GL_SHADER_TYPE, &type_id);
        std::string shader_type_str = shader_type_to_string(static_cast<staplegl::shader_type>(type_id));
        std::fprintf(stderr, STAPLEGL_LINEINFO ", failed to compile %s shader: \n%s\n",
            shader_type_str.data(), error_log.data());
#endif // STAPLEGL_DEBUG
        glDeleteShader(id);
        return 0;
    }
 
    return id;
}
 
inline auto shader_program::parse_shaders(std::string_view source) const -> std::vector<shader>
{
    std::vector<shader> shaders;
    std::string_view const type_token { "#type" };
 
    std::size_t pos { source.find(type_token, 0) };
    while (pos != std::string::npos) {
        const std::size_t eol { source.find_first_of("\r\n", pos) };
        const std::size_t begin { pos + type_token.size() + 1 };
        const std::size_t next_line_pos { source.find_first_not_of("\r\n", eol) };
        std::string const type { source.substr(begin, eol - begin) };
 
        auto const shader_type { string_to_shader_type(type) };
 
        // With C++23 we could drastically simplify this thanks to std::optional's monadic operations.
        if (!shader_type.has_value()) [[unlikely]] {
 
#ifdef STAPLEGL_DEBUG
            std::fprintf(stderr, STAPLEGL_LINEINFO ", invalid shader type \"%s\"\n",
                type.data());
#endif // STAPLEGL_DEBUG
            return {};
        }
 
        pos = source.find(type_token, next_line_pos);
        shaders.push_back({ shader_type.value(),
            (pos == std::string::npos)
                ? std::string(source.substr(next_line_pos))
                : std::string(source.substr(next_line_pos, pos - next_line_pos)) });
    }
 
    return shaders;
}
 
inline auto shader_program::uniform_location(std::string_view name) -> int
{
    if (m_uniform_cache.find(name) != m_uniform_cache.end()) [[likely]] {
        return m_uniform_cache[name];
    } else {
        const int location { glGetUniformLocation(m_id, name.data()) };
#ifdef STAPLEGL_DEBUG
        if (location == -1) {
            std::fprintf(stderr, STAPLEGL_LINEINFO ", uniform \"%s\" not found in shader program \"%s\"\n",
                name.data(), m_name.data());
        }
#endif // STAPLEGL_DEBUG
        m_uniform_cache[name] = location;
        return location;
    }
}
 
inline auto shader_program::is_valid(std::uint32_t id) -> bool
{
    int link_ok {};
    glGetProgramiv(id, GL_LINK_STATUS, &link_ok);
 
    if (link_ok == GL_FALSE) [[unlikely]] {
 
#ifdef STAPLEGL_DEBUG
        int max_length {};
        glGetProgramiv(id, GL_INFO_LOG_LENGTH, &max_length);
        std::string error_log(max_length, '\0');
        glGetProgramInfoLog(id, max_length, &max_length, &error_log[0]);
        std::fprintf(stderr, STAPLEGL_LINEINFO ", failed to link shader program: %s\n",
            error_log.data());
#endif // STAPLEGL_DEBUG
 
        glDeleteProgram(id);
        return false;
    }
 
    glValidateProgram(id);
 
    int success = 0;
    glGetProgramiv(id, GL_VALIDATE_STATUS, &success);
    if (!success) [[unlikely]] {
#ifdef STAPLEGL_DEBUG
        int max_length {};
        glGetProgramiv(id, GL_INFO_LOG_LENGTH, &max_length);
        std::string error_log(max_length, '\0');
        glGetProgramInfoLog(id, max_length, &max_length, &error_log[0]);
        std::fprintf(stderr, STAPLEGL_LINEINFO ", failed to validate shader program: %s\n",
            error_log.data());
#endif // STAPLEGL_DEBUG
        glDeleteProgram(id);
        return false;
    }
 
    return true;
}
 
inline constexpr auto shader_program::to_gl_type(shader_type shader_type) -> std::uint32_t
{
    switch (shader_type) {
    case shader_type::vertex:
        return GL_VERTEX_SHADER;
    case shader_type::fragment:
        return GL_FRAGMENT_SHADER;
    case shader_type::tess_control:
        return GL_TESS_CONTROL_SHADER;
    case shader_type::tess_eval:
        return GL_TESS_EVALUATION_SHADER;
    case shader_type::geometry:
        return GL_GEOMETRY_SHADER;
    default:
#ifdef STAPLEGL_DEBUG
        std::fprintf(stderr, STAPLEGL_LINEINFO ", invalid shader type enum %d, \n",
            static_cast<int>(shader_type));
#endif // STAPLEGL_DEBUG
        std::terminate();
    }
}
 
inline auto shader_program::string_to_shader_type(std::string_view str) -> std::optional<shader_type>
{
    static std::unordered_map<std::string_view, shader_type> map {
        { "vertex", shader_type::vertex },
        { "fragment", shader_type::fragment },
        { "tess_control", shader_type::tess_control },
        { "tess_eval", shader_type::tess_eval },
        { "geometry", shader_type::geometry }
    };
 
    if (map.find(str) != map.end()) [[likely]] {
        return map[str];
    }
 
    return std::nullopt;
}
}
 
std::string staplegl::shader_type_to_string(shader_type type) noexcept
{
    switch (type) {
    case shader_type::vertex:
        return "vertex";
    case shader_type::fragment:
        return "fragment";
    case shader_type::tess_control:
        return "tess_control";
    case shader_type::tess_eval:
        return "tess_eval";
    case shader_type::geometry:
        return "geometry";
    default:
        return "unknown";
    }
}