Vesper::OpenGLShader Class Reference

#include <OpenGLShader.h>

Inheritance diagram for Vesper::OpenGLShader:

Public Member Functions
	OpenGLShader (const std::string &filepath)
	OpenGLShader (const std::string &name, const std::string &vertexSrc, const std::string &fragmentSrc)
	~OpenGLShader ()
void	Bind () const override
	connects the shader program for use.
void	Unbind () const override
	disconnects the shader program.
virtual void	SetMat4 (const std::string &name, const glm::mat4 &value) override
	Sets a 4x4 matrix 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	SetFloat3 (const std::string &name, const glm::vec3 &value) override
	Sets a 3-component float vector uniform in the shader.
virtual void	SetFloat (const std::string &name, float value) override
	Sets a single float 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 const std::string &	GetName () const override
void	UploadUniformMat4 (const std::string &name, const glm::mat4 &matrix)
void	UploadUniformMat3 (const std::string &name, const glm::mat3 &matrix)
void	UploadUniformFloat4 (const std::string &name, const glm::vec4 &values)
void	UploadUniformFloat3 (const std::string &name, const glm::vec3 &values)
void	UploadUniformFloat2 (const std::string &name, const glm::vec2 &values)
void	UploadUniformFloat (const std::string &name, float value)
void	UploadUniformInt (const std::string &name, int value)
Public Member Functions inherited from Vesper::Shader
virtual	~Shader ()=default

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

Private Attributes
unsigned int	m_RendererID
std::string	m_Name

Additional Inherited Members
Static Public Member Functions inherited from Vesper::Shader
static Ref< Shader >	Create (const std::string &name, const std::string &vertexSrc, const std::string &fragmentSrc)
static Ref< Shader >	Create (const std::string &filepath)

Constructor & Destructor Documentation

OpenGLShader() [1/2]

Vesper::OpenGLShader::OpenGLShader

(

const std::string &

filepath

)

    {
        VZ_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);
    }

OpenGLShader() [2/2]

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

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

References OpenGLShader().

Referenced by OpenGLShader().

~OpenGLShader()

Vesper::OpenGLShader::~OpenGLShader

(

)

    {
        VZ_PROFILE_FUNCTION();
        glDeleteProgram(m_RendererID);
    }

References m_RendererID.

Member Function Documentation

Bind()

void Vesper::OpenGLShader::Bind ( ) const

overridevirtual

connects the shader program for use.

Implements Vesper::Shader.

    {
        VZ_PROFILE_FUNCTION();
        glUseProgram(m_RendererID);
    }

References m_RendererID.

Compile()

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

private

    {
        VZ_PROFILE_FUNCTION();
        GLuint program = glCreateProgram();
 
        std::array<GLenum, 2> shaderIDs;
        VZ_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);
 
                VZ_CORE_ERROR("{0}", infoLog.data());
                VZ_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);
 
            VZ_CORE_ERROR("{0}", infoLog.data());
            VZ_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 & Vesper::OpenGLShader::GetName ( ) const

inlineoverridevirtual

Implements Vesper::Shader.

{ return m_Name; }

PreProcess()

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

private

    {
        VZ_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
            VZ_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);
            VZ_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
            VZ_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;
    }

ReadFile()

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

private

    {
        VZ_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
        {
            VZ_CORE_ERROR("Could not open file '{0}'", filepath);
            VZ_CORE_ASSERT(false, "Failed to open file!");
        }
        return result;
    }

SetFloat()

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

overridevirtual

Sets a single float uniform in the shader.

Implements Vesper::Shader.

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

References UploadUniformFloat().

SetFloat3()

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

overridevirtual

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

Implements Vesper::Shader.

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

SetFloat4()

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

overridevirtual

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

Implements Vesper::Shader.

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

SetInt()

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

overridevirtual

Sets a single integer uniform in the shader.

Implements Vesper::Shader.

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

References UploadUniformInt().

SetIntArray()

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

overridevirtual

Sets an array of integers uniform in the shader.

Implements Vesper::Shader.

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

SetMat4()

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

overridevirtual

Sets a 4x4 matrix uniform in the shader.

Implements Vesper::Shader.

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

Unbind()

void Vesper::OpenGLShader::Unbind ( ) const

overridevirtual

disconnects the shader program.

Implements Vesper::Shader.

    {
        VZ_PROFILE_FUNCTION();
        glUseProgram(0);
    }

UploadUniformFloat()

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

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

Referenced by SetFloat().

UploadUniformFloat2()

void Vesper::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 Vesper::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 Vesper::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 Vesper::OpenGLShader::UploadUniformInt	(	const std::string &	name,
		int	value )

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

Referenced by SetInt().

UploadUniformMat3()

void Vesper::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 Vesper::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 Vesper::OpenGLShader::m_Name

private

m_RendererID

unsigned int Vesper::OpenGLShader::m_RendererID

private

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

---

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

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