Referência da Classe Shader

#include <shader.hpp>

Membros Públicos
	Shader (const std::string &filepath)
	~Shader ()
void	bind () const
void	unbind () const
void	setUniform3f (const std::string &name, glm::vec3 value)
void	setUniform4f (const std::string &name, glm::vec4 value)
void	setUniformMat4f (const std::string &name, const glm::mat4 &matrix)

Membros Privados
GLuint	createShader (const std::string &vertex_shader, const std::string &fragment_shader)
ShaderProgramSource	parseShader (const std::string &filepath)
GLuint	compileShader (GLuint type, const std::string &source)
GLint	getUniformLocation (const std::string &name)

Atributos Privados
GLuint	m_buffer_id
std::unordered_map< std::string, GLint >	m_uniformLocationCache

Descrição detalhada

Classe auxiliar para gerenciamento de programas de shader.

A classe Shader carrega shaders de arquivos externos (vertex shader e fragment shader), compila o programa e fornece métodos para ativação, desativação e configuração de uniformes.

Construtores e Destrutores

Shader()

Shader::Shader

(

const std::string &

filepath

)

Construtor da classe Shader.

Carrega os shaders a partir de um arquivo externo especificado pelo caminho do arquivo, compila o programa de shader e inicializa o cache de localização de uniformes.

filepath: Caminho do arquivo contendo os shaders (vertex e fragment).

                                        : m_buffer_id(0) {
    ShaderProgramSource source = parseShader(filepath);
    m_buffer_id = createShader(source.vertex_src, source.fragment_src);
}

~Shader()

Shader::~Shader

(

)

Destrutor da classe Shader.

Realiza a liberação da memória alocada pelo programa de shader em OpenGL.

{ glDeleteProgram(m_buffer_id); }

Funções membros

bind()

void Shader::bind

(

)

const

Ativa o programa de shader.

Vincula o programa de shader para que ele seja usado para renderização.

{ glUseProgram(m_buffer_id); }

compileShader()

GLuint Shader::compileShader ( GLuint  type, const std::string &  source  )

private

Compila o código fonte de um shader individual.

type: Tipo de shader (GL_VERTEX_SHADER ou GL_FRAGMENT_SHADER).

source: Código fonte do shader.

Returno: Identificador OpenGL do shader compilado.

                                                                 {
    GLuint id = glCreateShader(type);
    const char *src = source.c_str();
    glShaderSource(id, 1, &src, nullptr);
    glCompileShader(id);
 
    int sucess;
    glGetShaderiv(id, GL_COMPILE_STATUS, &sucess);
    if (!sucess) {
        int len;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &len);
        char *message = (char *)alloca(len * sizeof(char));
        glGetShaderInfoLog(id, len, &len, message);
        std::cerr << "Failed compile "
                  << (type == GL_VERTEX_SHADER ? "vertex" : "fragment")
                  << " shader!\n"
                  << message << '\n';
        glDeleteShader(id);
        return 0;
    }
 
    return id;
}

createShader()

GLuint Shader::createShader ( const std::string &  vertex_shader, const std::string &  fragment_shader  )

private

Cria um shader individual (vertex ou fragment) a partir do código fonte.

type: Tipo de shader (GL_VERTEX_SHADER ou GL_FRAGMENT_SHADER).

source: Código fonte do shader.

Retorno: Identificador OpenGL do shader criado.

                                                              {
    GLuint program = glCreateProgram();
    GLuint vs = compileShader(GL_VERTEX_SHADER, vertex_shader);
    GLuint fs = compileShader(GL_FRAGMENT_SHADER, fragment_shader);
 
    glAttachShader(program, vs);
    glAttachShader(program, fs);
    glLinkProgram(program);
    glValidateProgram(program);
 
    glDeleteShader(vs);
    glDeleteShader(fs);
 
    return program;
}

getUniformLocation()

GLint Shader::getUniformLocation ( const std::string &  name )

private

Obtém a localização de um uniforme no programa de shader.

Essa função verifica se a localização do uniforme já está armazenada no cache m_uniformLocationCache. Se a localização não estiver no cache, ela consulta a OpenGL e armazena o resultado no cache para consultas futuras.

name: Nome do uniforme.

Returno: Localização do uniforme (GLint) ou -1 se o uniforme não for encontrado.

                                                      {
    if (m_uniformLocationCache.find(name) != m_uniformLocationCache.end()) {
        return m_uniformLocationCache[name];
    }
 
    GLint location = glGetUniformLocation(m_buffer_id, name.c_str());
    if (location == -1) {
        std::cerr << "Warning: Uniform '" << name << "' doesn't exit!\n";
    }
 
    m_uniformLocationCache[name] = location;
    return location;
}

parseShader()

ShaderProgramSource Shader::parseShader ( const std::string &  filepath )

private

Carrega e separa o código fonte dos shaders (vertex e fragment) de um arquivo.

filepath: Caminho do arquivo contendo os shaders.

Returno: Estrutura contendo o código fonte separado para vertex shader e fragment shader.

                                                                 {
    enum class ShaderType {
        NONE = -1,
        VERTEX = 0,
        FRAGMENT = 1,
    };
 
    std::string line;
    std::ifstream stream(filepath);
    std::vector<std::stringstream> ss(2);
    ShaderType type = ShaderType::NONE;
    while (getline(stream, line)) {
        if (line.find("#shader") != std::string::npos) {
            if (line.find("vertex") != std::string::npos) {
                type = ShaderType::VERTEX;
            } else if (line.find("fragment") != std::string::npos) {
                type = ShaderType::FRAGMENT;
            }
        } else {
            ss[static_cast<int>(type)] << line << '\n';
        }
    }
    return {
        .vertex_src = ss[0].str(),
        .fragment_src = ss[1].str(),
    };
}

setUniform3f()

void Shader::setUniform3f	(	const std::string &	name,
		glm::vec3	value
	)

Define um uniforme do tipo vec3 no programa de shader.

name: Nome do uniforme.

value: Valor do uniforme como um vetor glm::vec3.

                                                              {
    GLint location = getUniformLocation(name);
    glUniform3f(location, value.x, value.y, value.z);
}

setUniform4f()

void Shader::setUniform4f	(	const std::string &	name,
		glm::vec4	value
	)

Define um uniforme do tipo vec4 no programa de shader.

name: Nome do uniforme.

value: Valor do uniforme como um vetor glm::vec4.

                                                              {
    GLint location = getUniformLocation(name);
    glUniform4f(location, value.x, value.y, value.z, value.w);
}

setUniformMat4f()

void Shader::setUniformMat4f	(	const std::string &	name,
		const glm::mat4 &	matrix
	)

Define um uniforme do tipo mat4 no programa de shader.

name: Nome do uniforme.

matrix: Valor do uniforme como uma matriz glm::mat4.

                                                                         {
    GLint location = getUniformLocation(name);
    glUniformMatrix4fv(location, 1, GL_FALSE, &matrix[0][0]);
}

unbind()

void Shader::unbind

(

)

const

Desativa o programa de shader.

Desvincula o programa de shader, podendo ser útil para evitar interferência com outros programas de shader.

{ glUseProgram(0); }

Atributos

m_buffer_id

GLuint Shader::m_buffer_id

private

Identificador OpenGL do programa de shader.

m_uniformLocationCache

std::unordered_map<std::string, GLint> Shader::m_uniformLocationCache

private

Cache para localização de uniformes no programa de shader.

Um mapa que armazena o nome do uniforme como chave e sua localização (GLint) como valor. O cache evita consultas repetidas à OpenGL para recuperar a localização de uniformes.

---

A documentação para essa classe foi gerada a partir dos seguintes arquivos:

• shader.hpp
• shader.cpp