Muto::OpenGLShader Class Reference

#include <OpenGLShader.h>

Inheritance diagram for Muto::OpenGLShader:

Public Member Functions
void	Bind () const override
	connects the shader program for use.
virtual const std::string &	GetName () const override
	OpenGLShader (const std::string &filepath)
	OpenGLShader (const std::string &name, const std::string &vertexSrc, const std::string &fragmentSrc)
virtual void	SetFloat (const std::string &name, float value) override
	Sets a single float uniform in the shader.
virtual void	SetFloat3 (const std::string &name, const glm::vec3 &value) override
	Sets a 3-component float vector uniform in the shader.
virtual void	SetFloat4 (const std::string &name, const glm::vec4 &value) override
	Sets a 4-component float vector uniform in the shader.
virtual void	SetInt (const std::string &name, int value) override
	Sets a single integer uniform in the shader.
virtual void	SetIntArray (const std::string &name, int *values, uint32_t count) override
	Sets an array of integers uniform in the shader.
virtual void	SetMat4 (const std::string &name, const glm::mat4 &value) override
	Sets a 4x4 matrix uniform in the shader.
void	Unbind () const override
	disconnects the shader program.
void	UploadUniformFloat (const std::string &name, float value)
void	UploadUniformFloat2 (const std::string &name, const glm::vec2 &values)
void	UploadUniformFloat3 (const std::string &name, const glm::vec3 &values)
void	UploadUniformFloat4 (const std::string &name, const glm::vec4 &values)
void	UploadUniformInt (const std::string &name, int value)
void	UploadUniformMat3 (const std::string &name, const glm::mat3 &matrix)
void	UploadUniformMat4 (const std::string &name, const glm::mat4 &matrix)
	~OpenGLShader ()
Public Member Functions inherited from Muto::Shader
virtual	~Shader ()=default

Private Member Functions
void	Compile (std::unordered_map< GLenum, std::string > &shaderSources)
std::unordered_map< GLenum, std::string >	PreProcess (const std::string &source)
std::string	ReadFile (const std::string &filepath)

Private Attributes
std::string	m_Name
unsigned int	m_RendererID

Additional Inherited Members
Static Public Member Functions inherited from Muto::Shader
static Ref< Shader >	Create (const std::string &filepath)
	Creates a shader from a file.
static Ref< Shader >	Create (const std::string &name, const std::string &vertexSrc, const std::string &fragmentSrc)
	Creates a new shader from vertex and fragment shader source code.

Constructor & Destructor Documentation

OpenGLShader() [1/2]

Muto::OpenGLShader::OpenGLShader

(

const std::string &

filepath

)

    {
        MU_PROFILE_FUNCTION();
        std::string shaderSrc = ReadFile(filepath);
        auto shaderSources = PreProcess(shaderSrc);
        Compile(shaderSources);
 
        // Extract name from filepath
        auto lastSlash = filepath.find_last_of("/\\");
        lastSlash = lastSlash == std::string::npos ? 0 : lastSlash + 1;
        auto lastDot = filepath.rfind('.');
        auto count = lastDot == std::string::npos ? filepath.size() - lastSlash : lastDot - lastSlash;
        m_Name = filepath.substr(lastSlash, count);
    }

References m_Name, and ReadFile().

OpenGLShader() [2/2]

Muto::OpenGLShader::OpenGLShader	(	const std::string &	name,
		const std::string &	vertexSrc,
		const std::string &	fragmentSrc
	)

        : m_Name(name)
    {
        MU_PROFILE_FUNCTION();
        std::unordered_map<GLenum, std::string> sources;
        sources[GL_VERTEX_SHADER] = vertexSrc;
        sources[GL_FRAGMENT_SHADER] = fragmentSrc;
        Compile(sources);
    }

References m_Name.

~OpenGLShader()

Muto::OpenGLShader::~OpenGLShader

(

)

    {
        MU_PROFILE_FUNCTION();
        glDeleteProgram(m_RendererID);
    }

References m_RendererID.

Member Function Documentation

Bind()

void Muto::OpenGLShader::Bind ( ) const

overridevirtual

connects the shader program for use.

Implements Muto::Shader.

    {
        MU_PROFILE_FUNCTION();
        glUseProgram(m_RendererID);
    }

References m_RendererID.

Compile()

void Muto::OpenGLShader::Compile ( std::unordered_map< GLenum, std::string > &  shaderSources )

private

    {
        MU_PROFILE_FUNCTION();
        GLuint program = glCreateProgram();
 
        std::array<GLenum, 2> shaderIDs;
        MU_CORE_ASSERT(shaderSources.size() <= shaderIDs.size(), "We only support 2 shaders for now!");
        int glShaderIDIndex = 0;
 
        for (auto& kv : shaderSources)
        {
            GLenum type = kv.first;
            const std::string& source = kv.second;
 
            GLuint shader = glCreateShader(type);
 
            const GLchar* shaderSource = source.c_str();
            glShaderSource(shader, 1, &shaderSource, 0);
 
            glCompileShader(shader);
 
            GLint isCompiled = 0;
            glGetShaderiv(shader, GL_COMPILE_STATUS, &isCompiled);
            if (isCompiled == GL_FALSE)
            {
                GLint maxLength = 0;
                glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
 
                std::vector<GLchar> infoLog(maxLength);
                glGetShaderInfoLog(shader, maxLength, &maxLength, &infoLog[0]);
 
                glDeleteShader(shader);
 
                MU_CORE_ERROR("{0}", infoLog.data());
                MU_CORE_ASSERT(false, "Shader compilation failure!");
                break;
            }
            glAttachShader(program, shader);
            shaderIDs[glShaderIDIndex++] = shader;
        }
 
        // Link our program
        glLinkProgram(program);
 
        // Note the different functions here: glGetProgram* instead of glGetShader*.
        GLint isLinked = 0;
        glGetProgramiv(program, GL_LINK_STATUS, (int*)&isLinked);
        if (isLinked == GL_FALSE)
        {
            GLint maxLength = 0;
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
 
            // The maxLength includes the NULL character
            std::vector<GLchar> infoLog(maxLength);
            glGetProgramInfoLog(program, maxLength, &maxLength, &infoLog[0]);
 
            // We don't need the program anymore.
            glDeleteProgram(program);
 
            for (auto id : shaderIDs)
                glDeleteShader(id);
 
            MU_CORE_ERROR("{0}", infoLog.data());
            MU_CORE_ASSERT(false, "Shader link failure!");
            return;
        }
 
        for (auto id : shaderIDs)
        {
            glDetachShader(program, id);
        }
 
        m_RendererID = program;
 
    }

References m_RendererID.

GetName()

virtual const std::string & Muto::OpenGLShader::GetName ( ) const

inlineoverridevirtual

Implements Muto::Shader.

{ return m_Name; }

References m_Name.

PreProcess()

std::unordered_map< GLenum, std::string > Muto::OpenGLShader::PreProcess ( const std::string &  source )

private

    {
        MU_PROFILE_FUNCTION();
        std::unordered_map<GLenum, std::string> shaderSources;
 
        const char* typeToken = "#type";
        size_t typeTokenLength = strlen(typeToken);
        size_t pos = source.find(typeToken, 0); // Start of shader type declaration line
        while (pos != std::string::npos)
        {
            size_t eol = source.find_first_of("\r\n", pos); // End of shader type declaration line
            MU_CORE_ASSERT(eol != std::string::npos, "Syntax error");
 
            size_t begin = pos + typeTokenLength + 1; // Start of shader type name (after "#type " keyword)
            std::string type = source.substr(begin, eol - begin);
            MU_CORE_ASSERT(ShaderTypeFromString(type), "Invalid shader type specified");
            size_t nextLinePos = source.find_first_not_of("\r\n", eol); // Start of shader code after shader type declaration line
            MU_CORE_ASSERT(nextLinePos != std::string::npos, "Syntax error");
 
            pos = source.find(typeToken, nextLinePos); // Start of next shader type declaration line
            shaderSources[ShaderTypeFromString(type)] = (pos == std::string::npos) ? source.substr(nextLinePos) : source.substr(nextLinePos, pos - nextLinePos);
        }
        return shaderSources;
    }

References Muto::ShaderTypeFromString().

ReadFile()

std::string Muto::OpenGLShader::ReadFile ( const std::string &  filepath )

private

    {
        MU_PROFILE_FUNCTION();
        std::string result;
        std::ifstream in(filepath, std::ios::in | std::ios::binary);
        if (in)
        {
            in.seekg(0, std::ios::end);
            result.resize(in.tellg());
            in.seekg(0, std::ios::beg);
            in.read(&result[0], result.size());
        }
        else
        {
            MU_CORE_ERROR("Could not open file '{0}'", filepath);
            MU_CORE_ASSERT(false, "Failed to open file!");
        }
        return result;
    }

Referenced by OpenGLShader().

SetFloat()

void Muto::OpenGLShader::SetFloat ( const std::string &  name, float  value  )

overridevirtual

Sets a single float uniform in the shader.

Implements Muto::Shader.

    {
        MU_PROFILE_FUNCTION();
        UploadUniformFloat(name, value);
    }

References UploadUniformFloat().

SetFloat3()

void Muto::OpenGLShader::SetFloat3 ( const std::string &  name, const glm::vec3 &  value  )

overridevirtual

Sets a 3-component float vector uniform in the shader.

Implements Muto::Shader.

    {
        MU_PROFILE_FUNCTION();
        UploadUniformFloat3(name, value);
    }

SetFloat4()

void Muto::OpenGLShader::SetFloat4 ( const std::string &  name, const glm::vec4 &  value  )

overridevirtual

Sets a 4-component float vector uniform in the shader.

Implements Muto::Shader.

    {
        MU_PROFILE_FUNCTION();
        UploadUniformFloat4(name, value);
    }

SetInt()

void Muto::OpenGLShader::SetInt ( const std::string &  name, int  value  )

overridevirtual

Sets a single integer uniform in the shader.

Implements Muto::Shader.

    {
        MU_PROFILE_FUNCTION();
        UploadUniformInt(name, value);
    }

References UploadUniformInt().

SetIntArray()

void Muto::OpenGLShader::SetIntArray ( const std::string &  name, int *  values, uint32_t  count  )

overridevirtual

Sets an array of integers uniform in the shader.

Implements Muto::Shader.

    {
        MU_PROFILE_FUNCTION();
        GLint location = glGetUniformLocation(m_RendererID, name.c_str());
        glUniform1iv(location, count, values);
    }

SetMat4()

void Muto::OpenGLShader::SetMat4 ( const std::string &  name, const glm::mat4 &  value  )

overridevirtual

Sets a 4x4 matrix uniform in the shader.

Implements Muto::Shader.

    {
        MU_PROFILE_FUNCTION();
        UploadUniformMat4(name, value);
    }

Unbind()

void Muto::OpenGLShader::Unbind ( ) const

overridevirtual

disconnects the shader program.

Implements Muto::Shader.

    {
        MU_PROFILE_FUNCTION();
        glUseProgram(0);
    }

UploadUniformFloat()

void Muto::OpenGLShader::UploadUniformFloat	(	const std::string &	name,
		float	value
	)

    {
        GLint location = glGetUniformLocation(m_RendererID, name.c_str());
        glUniform1f(location, value);
    }

Referenced by SetFloat().

UploadUniformFloat2()

void Muto::OpenGLShader::UploadUniformFloat2	(	const std::string &	name,
		const glm::vec2 &	values
	)

    {
        GLint location = glGetUniformLocation(m_RendererID, name.c_str());
        glUniform2f(location, values.x, values.y);
    }

UploadUniformFloat3()

void Muto::OpenGLShader::UploadUniformFloat3	(	const std::string &	name,
		const glm::vec3 &	values
	)

    {
        GLint location = glGetUniformLocation(m_RendererID, name.c_str());
        glUniform3f(location, values.x, values.y, values.z);
    }

UploadUniformFloat4()

void Muto::OpenGLShader::UploadUniformFloat4	(	const std::string &	name,
		const glm::vec4 &	values
	)

    {
        GLint location = glGetUniformLocation(m_RendererID, name.c_str());
        glUniform4f(location, values.x, values.y, values.z, values.w);
    }

UploadUniformInt()

void Muto::OpenGLShader::UploadUniformInt	(	const std::string &	name,
		int	value
	)

    {
        GLint location = glGetUniformLocation(m_RendererID, name.c_str());
        glUniform1i(location, value);
    }

Referenced by SetInt().

UploadUniformMat3()

void Muto::OpenGLShader::UploadUniformMat3	(	const std::string &	name,
		const glm::mat3 &	matrix
	)

    {
        GLint location = glGetUniformLocation(m_RendererID, name.c_str());
        glUniformMatrix3fv(location, 1, GL_FALSE, glm::value_ptr(matrix));
    }

UploadUniformMat4()

void Muto::OpenGLShader::UploadUniformMat4	(	const std::string &	name,
		const glm::mat4 &	matrix
	)

    {
        GLint location = glGetUniformLocation(m_RendererID, name.c_str());
        glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(matrix));
    }

Member Data Documentation

m_Name

std::string Muto::OpenGLShader::m_Name

private

Referenced by GetName(), OpenGLShader(), and OpenGLShader().

m_RendererID

unsigned int Muto::OpenGLShader::m_RendererID

private

Referenced by Bind(), Compile(), and ~OpenGLShader().

---

The documentation for this class was generated from the following files:

• Muto/src/RenderAPI/OpenGL/OpenGLShader.h
• Muto/src/RenderAPI/OpenGL/OpenGLShader.cpp