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 <nlohmann/json_fwd.hpp>
 
#include "galaxy/graphics/Colour.hpp"
 
namespace galaxy
{
    namespace graphics
    {
        class Shader final
        {
        public:
            Shader();
 
            Shader(const nlohmann::json& json);
 
            Shader(Shader&&);
 
            Shader& operator=(Shader&&);
 
            ~Shader();
 
            [[nodiscard]]
            bool load(const std::string& file);
 
            [[nodiscard]]
            bool load(const std::string& vertex, const std::string& frag);
 
            [[nodiscard]]
            bool parse(const std::string& src);
 
            [[nodiscard]]
            bool parse(const std::string& vertex, const std::string& frag);
 
            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;
 
        private:
            Shader(const Shader&) = delete;
 
            Shader& operator=(const Shader&) = delete;
 
            [[nodiscard]]
            bool preprocess(const std::string& src);
 
            [[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)
        {
            std::unreachable();
        }
 
        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<graphics::Colour>(const std::string& name, const graphics::Colour& a)
        {
            set_uniform(name, a.vec4());
        }
    } // namespace graphics
} // namespace galaxy
 
#endif