Shader.cpp

Go to the documentation of this file.

 
 
#include <entt/locator/locator.hpp>
 
#include "galaxy/fs/VirtualFileSystem.hpp"
#include "galaxy/platform/Pragma.hpp"
 
#include "Shader.hpp"
 
#ifdef GALAXY_WIN_PLATFORM
#pragma warning(push)
#pragma warning(disable : 26414)
#endif
 
namespace galaxy
{
    Shader::Shader() noexcept
        : m_id {0}
    {
    }
 
    Shader::Shader(Shader&& s) noexcept
    {
        if (this->m_id != 0)
        {
            glDeleteProgram(this->m_id);
        }
 
        this->m_cache = std::move(s.m_cache);
        this->m_src   = std::move(s.m_src);
        this->m_id    = s.m_id;
 
        s.m_id = 0;
    }
 
    Shader& Shader::operator=(Shader&& s) noexcept
    {
        if (this != &s)
        {
            if (this->m_id != 0)
            {
                glDeleteProgram(this->m_id);
            }
 
            this->m_cache = std::move(s.m_cache);
            this->m_src   = std::move(s.m_src);
            this->m_id    = s.m_id;
 
            s.m_id = 0;
        }
 
        return *this;
    }
 
    Shader::~Shader() noexcept
    {
        destroy();
    }
 
    bool Shader::load(const std::string& file) noexcept
    {
        auto& fs = entt::locator<VirtualFileSystem>::value();
 
        auto data = fs.read(file);
        return parse(data);
    }
 
    bool Shader::load(const std::string& vertex, const std::string& frag) noexcept
    {
        auto& fs = entt::locator<VirtualFileSystem>::value();
 
        auto v = fs.read(vertex);
        auto f = fs.read(frag);
 
        return parse(v, f);
    }
 
    bool Shader::parse(const std::string& src) noexcept
    {
        return preprocess(src);
    }
 
    bool Shader::parse(const std::string& vertex, const std::string& frag) noexcept
    {
        auto result = true;
 
        if (vertex.empty())
        {
            GALAXY_LOG(GALAXY_ERROR, "Shader was passed an empty vertex shader.");
            result = false;
        }
 
        if (frag.empty())
        {
            GALAXY_LOG(GALAXY_ERROR, "Shader was passed an empty fragment shader.");
            result = false;
        }
 
        if (result)
        {
            m_src.first()  = vertex;
            m_src.second() = frag;
        }
 
        return result;
    }
 
    void Shader::compile()
    {
        if (!m_src.first().empty() && !m_src.second().empty())
        {
            // Error reporting for OpenGL.
            char info[1024] = {0};
            auto success    = 0;
            auto v_id       = 0u;
            auto f_id       = 0u;
 
            // Then we need to convert the stream to a c string because OpenGL requires a refernece to a c string.
            auto v_src = m_src.first().c_str();
            auto f_src = m_src.second().c_str();
 
            // Retrieve the ids from opengl when creating the shader, then compile shaders, while checking for errors.
            v_id = glCreateShader(GL_VERTEX_SHADER);
            glShaderSource(v_id, 1, &v_src, nullptr);
            glCompileShader(v_id);
 
            glGetShaderiv(v_id, GL_COMPILE_STATUS, &success);
            if (!success)
            {
                glGetShaderInfoLog(v_id, 1024, nullptr, info);
 
                GALAXY_LOG(GALAXY_ERROR, "Failed to compile vertex shader. {0}.", info);
            }
 
            // Now do the same for the fragment shader.
            f_id = glCreateShader(GL_FRAGMENT_SHADER);
            glShaderSource(f_id, 1, &f_src, nullptr);
            glCompileShader(f_id);
 
            glGetShaderiv(f_id, GL_COMPILE_STATUS, &success);
            if (!success)
            {
                glGetShaderInfoLog(f_id, 1024, nullptr, info);
 
                GALAXY_LOG(GALAXY_ERROR, "Failed to compile fragment shader. {0}.", info);
            }
 
            if (success)
            {
                // Create and link program.
                m_id = glCreateProgram();
                glAttachShader(m_id, v_id);
                glAttachShader(m_id, f_id);
                glLinkProgram(m_id);
 
                glGetProgramiv(m_id, GL_LINK_STATUS, &success);
                if (!success)
                {
                    glGetProgramInfoLog(m_id, 1024, nullptr, info);
 
                    GALAXY_LOG(GALAXY_ERROR, "Failed to attach shaders: {0}.", info);
                }
 
                GLint uniform_count = 0;
                glGetProgramiv(m_id, GL_ACTIVE_UNIFORMS, &uniform_count);
 
                if (uniform_count != 0)
                {
                    GLint max_name_len = 0;
                    glGetProgramiv(m_id, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_name_len);
 
                    GLsizei length = 0;
                    GLsizei count  = 0;
                    GLenum  type   = GL_NONE;
 
                    for (GLint i = 0; i < uniform_count; ++i)
                    {
                        auto uniform_name = std::make_unique<char[]>(max_name_len);
                        glGetActiveUniform(m_id, i, max_name_len, &length, &count, &type, uniform_name.get());
 
                        m_cache.emplace(std::string(uniform_name.get(), length), glGetUniformLocation(m_id, uniform_name.get()));
                    }
                }
            }
 
            // Cleanup shaders.
            glDeleteShader(v_id);
            glDeleteShader(f_id);
            m_src = {};
        }
        else
        {
            GALAXY_LOG(GALAXY_ERROR, "Tried to compile empty shader.");
        }
    }
 
    void Shader::destroy()
    {
        if (m_id != 0)
        {
            glDeleteProgram(m_id);
            m_id = 0;
        }
    }
 
    void Shader::bind() const
    {
        glUseProgram(m_id);
    }
 
    void Shader::unbind() const
    {
        glUseProgram(0);
    }
 
    unsigned int Shader::id() const noexcept
    {
        return m_id;
    }
 
    bool Shader::preprocess(const std::string& src) noexcept
    {
        auto result = true;
 
        if (!src.empty())
        {
            const auto token = "#type";
            const auto len   = std::strlen(token);
 
            auto pos = src.find(token, 0);
            while (pos != std::string::npos)
            {
                const auto eol   = src.find_first_of("\r\n", pos);
                const auto begin = pos + len + 1;
 
                auto type = src.substr(begin, eol - begin);
 
                if (type == "vertex" || type == "fragment")
                {
                    const auto next_line = src.find_first_not_of("\r\n", eol);
                    pos                  = src.find(token, next_line);
 
                    if (type == "vertex")
                    {
                        m_src.first() = (pos == std::string::npos) ? src.substr(next_line) : src.substr(next_line, pos - next_line);
                    }
                    else
                    {
                        m_src.second() = (pos == std::string::npos) ? src.substr(next_line) : src.substr(next_line, pos - next_line);
                    }
                }
                else
                {
                    GALAXY_LOG(GALAXY_ERROR, "Failed to parse shader type. Must be 'vertex' or 'fragment'.");
                    result = false;
                }
            }
        }
        else
        {
            GALAXY_LOG(GALAXY_ERROR, "Empty source code provided to shader.");
            result = false;
        }
 
        return result;
    }
 
    int Shader::get_uniform_location(const std::string& name)
    {
        if (m_cache.contains(name))
        {
            return m_cache[name];
        }
        else
        {
            GALAXY_LOG(GALAXY_WARN, "Failed to get uniform location for '{0}'.", name);
            return -1;
        }
    }
} // namespace galaxy
 
#ifdef GALAXY_WIN_PLATFORM
#pragma warning(pop)
#endif