Shader.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_GRAPHICS_GL_SHADER_HPP_
#define GALAXY_GRAPHICS_GL_SHADER_HPP_
 
#include <ankerl/unordered_dense.h>
#include <entt/core/compressed_pair.hpp>
#include <glad/glad.h>
#include <glm/gtc/type_ptr.hpp>
 
#include "galaxy/graphics/Colour.hpp"
#include "galaxy/logging/Log.hpp"
#include "galaxy/math/Math.hpp"
 
namespace galaxy
{
    class Shader final
    {
    public:
        Shader() noexcept;
 
        Shader(Shader&&) noexcept;
 
        Shader& operator=(Shader&&) noexcept;
 
        ~Shader() noexcept;
 
        [[nodiscard]]
        bool load(const std::string& file) noexcept;
 
        [[nodiscard]]
        bool load(const std::string& vertex, const std::string& frag) noexcept;
 
        [[nodiscard]]
        bool parse(const std::string& src) noexcept;
 
        [[nodiscard]]
        bool parse(const std::string& vertex, const std::string& frag) noexcept;
 
        void compile();
 
        void destroy();
 
        void bind() const;
 
        void unbind() const;
 
        template<typename... Uniforms>
        void set_uniform(const std::string& name, const Uniforms&... args);
 
        [[nodiscard]]
        unsigned int id() const noexcept;
 
    private:
        Shader(const Shader&) = delete;
 
        Shader& operator=(const Shader&) = delete;
 
        [[nodiscard]]
        bool preprocess(const std::string& src) noexcept;
 
        [[nodiscard]]
        int get_uniform_location(const std::string& name);
 
    private:
        unsigned int m_id;
 
        ankerl::unordered_dense::map<std::string, int> m_cache;
 
        entt::compressed_pair<std::string, std::string> m_src;
    };
 
    template<>
    inline void Shader::set_uniform(const std::string& name)
    {
        GALAXY_LOG(GALAXY_ERROR, "Tried to set uniform without value: '{0}'.", name);
    }
 
    template<>
    inline void Shader::set_uniform<bool>(const std::string& name, const bool& a)
    {
        glProgramUniform1i(m_id, get_uniform_location(name), a);
    }
 
    template<>
    inline void Shader::set_uniform<int>(const std::string& name, const int& a)
    {
        glProgramUniform1i(m_id, get_uniform_location(name), a);
    }
 
    template<>
    inline void Shader::set_uniform<int, int>(const std::string& name, const int& a, const int& b)
    {
        glProgramUniform2i(m_id, get_uniform_location(name), a, b);
    }
 
    template<>
    inline void Shader::set_uniform<int, int, int>(const std::string& name, const int& a, const int& b, const int& c)
    {
        glProgramUniform3i(m_id, get_uniform_location(name), a, b, c);
    }
 
    template<>
    inline void Shader::set_uniform<int, int, int, int>(const std::string& name, const int& a, const int& b, const int& c, const int& d)
    {
        glProgramUniform4i(m_id, get_uniform_location(name), a, b, c, d);
    }
 
    template<>
    inline void Shader::set_uniform<unsigned int>(const std::string& name, const unsigned int& a)
    {
        glProgramUniform1ui(m_id, get_uniform_location(name), a);
    }
 
    template<>
    inline void Shader::set_uniform<unsigned int, unsigned int>(const std::string& name, const unsigned int& a, const unsigned int& b)
    {
        glProgramUniform2ui(m_id, get_uniform_location(name), a, b);
    }
 
    template<>
    inline void Shader::set_uniform<unsigned int, unsigned int, unsigned int>(const std::string& name, const unsigned int& a, const unsigned int& b, const unsigned int& c)
    {
        glProgramUniform3ui(m_id, get_uniform_location(name), a, b, c);
    }
 
    template<>
    inline void Shader::set_uniform<unsigned int, unsigned int, unsigned int, unsigned int>(
        const std::string&  name,
        const unsigned int& a,
        const unsigned int& b,
        const unsigned int& c,
        const unsigned int& d
    )
    {
        glProgramUniform4ui(m_id, get_uniform_location(name), a, b, c, d);
    }
 
    template<>
    inline void Shader::set_uniform<float>(const std::string& name, const float& a)
    {
        glProgramUniform1f(m_id, get_uniform_location(name), a);
    }
 
    template<>
    inline void Shader::set_uniform<float, float>(const std::string& name, const float& a, const float& b)
    {
        glProgramUniform2f(m_id, get_uniform_location(name), a, b);
    }
 
    template<>
    inline void Shader::set_uniform<float, float, float>(const std::string& name, const float& a, const float& b, const float& c)
    {
        glProgramUniform3f(m_id, get_uniform_location(name), a, b, c);
    }
 
    template<>
    inline void Shader::set_uniform<float, float, float, float>(const std::string& name, const float& a, const float& b, const float& c, const float& d)
    {
        glProgramUniform4f(m_id, get_uniform_location(name), a, b, c, d);
    }
 
    template<>
    inline void Shader::set_uniform<double>(const std::string& name, const double& a)
    {
        glProgramUniform1d(m_id, get_uniform_location(name), a);
    }
 
    template<>
    inline void Shader::set_uniform<double, double>(const std::string& name, const double& a, const double& b)
    {
        glProgramUniform2d(m_id, get_uniform_location(name), a, b);
    }
 
    template<>
    inline void Shader::set_uniform<double, double, double>(const std::string& name, const double& a, const double& b, const double& c)
    {
        glProgramUniform3d(m_id, get_uniform_location(name), a, b, c);
    }
 
    template<>
    inline void Shader::set_uniform<double, double, double, double>(const std::string& name, const double& a, const double& b, const double& c, const double& d)
    {
        glProgramUniform4d(m_id, get_uniform_location(name), a, b, c, d);
    }
 
    template<>
    inline void Shader::set_uniform<std::uint64_t>(const std::string& name, const std::uint64_t& a)
    {
        glProgramUniform1ui64ARB(m_id, get_uniform_location(name), a);
    }
 
    template<>
    inline void Shader::set_uniform<glm::mat3>(const std::string& name, const glm::mat3& a)
    {
        glProgramUniformMatrix3fv(m_id, get_uniform_location(name), 1, GL_FALSE, glm::value_ptr(a));
    }
 
    template<>
    inline void Shader::set_uniform<glm::mat4>(const std::string& name, const glm::mat4& a)
    {
        glProgramUniformMatrix4fv(m_id, get_uniform_location(name), 1, GL_FALSE, glm::value_ptr(a));
    }
 
    template<>
    inline void Shader::set_uniform<glm::vec2>(const std::string& name, const glm::vec2& a)
    {
        glProgramUniform2f(m_id, get_uniform_location(name), a.x, a.y);
    }
 
    template<>
    inline void Shader::set_uniform<glm::vec3>(const std::string& name, const glm::vec3& a)
    {
        glProgramUniform3f(m_id, get_uniform_location(name), a.x, a.y, a.z);
    }
 
    template<>
    inline void Shader::set_uniform<glm::vec4>(const std::string& name, const glm::vec4& a)
    {
        glProgramUniform4f(m_id, get_uniform_location(name), a.x, a.y, a.z, a.w);
    }
 
    template<>
    inline void Shader::set_uniform<std::array<float, 4>>(const std::string& name, const std::array<float, 4>& a)
    {
        glProgramUniform4f(m_id, get_uniform_location(name), a[0], a[1], a[2], a[3]);
    }
 
    template<>
    inline void Shader::set_uniform<Colour>(const std::string& name, const Colour& a)
    {
        auto vec4 = glm::vec4();
 
        vec4.x = std::clamp(math::normalize(a.r(), Colour::OFFSET), 0.0f, 1.0f);
        vec4.y = std::clamp(math::normalize(a.g(), Colour::OFFSET), 0.0f, 1.0f);
        vec4.z = std::clamp(math::normalize(a.b(), Colour::OFFSET), 0.0f, 1.0f);
        vec4.w = std::clamp(math::normalize(a.a(), Colour::OFFSET), 0.0f, 1.0f);
 
        set_uniform(name, vec4);
    }
} // namespace galaxy
 
#endif