Shader.hpp

Go to the documentation of this file.

 
#ifndef GALAXY_GRAPHICS_SHADER_HPP_
#define GALAXY_GRAPHICS_SHADER_HPP_
 
#include <ankerl/unordered_dense.h>
#include <Raylib.hpp>
 
#include "galaxy/logging/Log.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;

        template<typename... Uniforms>
        void set_uniform(const std::string& name, const Uniforms&... args);
 
    private:
        Shader(const Shader&) = delete;

        Shader& operator=(const Shader&) = delete;

        [[nodiscard]]
        int get_uniform_location(const std::string& name);
 
    private:
        ray::Shader m_shader;

        ankerl::unordered_dense::map<std::string, int> m_cache;
    };
 
    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)
    {
        ray::SetShaderValue(m_shader, get_uniform_location(name), &a, ray::SHADER_UNIFORM_INT);
    }
 
    template<>
    inline void Shader::set_uniform<int>(const std::string& name, const int& a)
    {
        ray::SetShaderValue(m_shader, get_uniform_location(name), &a, ray::SHADER_UNIFORM_INT);
    }
 
    template<>
    inline void Shader::set_uniform<unsigned int>(const std::string& name, const unsigned int& a)
    {
        ray::SetShaderValue(m_shader, get_uniform_location(name), &a, ray::SHADER_UNIFORM_UINT);
    }
 
    template<>
    inline void Shader::set_uniform<float>(const std::string& name, const float& a)
    {
        ray::SetShaderValue(m_shader, get_uniform_location(name), &a, ray::SHADER_UNIFORM_FLOAT);
    }
 
    template<>
    inline void Shader::set_uniform<ray::Vector2>(const std::string& name, const ray::Vector2& a)
    {
        ray::SetShaderValue(m_shader, get_uniform_location(name), &a, ray::SHADER_UNIFORM_VEC2);
    }
 
    template<>
    inline void Shader::set_uniform<ray::Vector3>(const std::string& name, const ray::Vector3& a)
    {
        ray::SetShaderValue(m_shader, get_uniform_location(name), &a, ray::SHADER_UNIFORM_VEC3);
    }
 
    template<>
    inline void Shader::set_uniform<ray::Vector4>(const std::string& name, const ray::Vector4& a)
    {
        ray::SetShaderValue(m_shader, get_uniform_location(name), &a, ray::SHADER_UNIFORM_VEC4);
    }
 
    template<>
    inline void Shader::set_uniform<ray::Matrix>(const std::string& name, const ray::Matrix& a)
    {
        ray::SetShaderValueMatrix(m_shader, get_uniform_location(name), a);
    }
 
    template<>
    inline void Shader::set_uniform<ray::Texture2D>(const std::string& name, const ray::Texture2D& a)
    {
        ray::SetShaderValueTexture(m_shader, get_uniform_location(name), a);
    }
} // namespace galaxy
 
#endif