CARGADOR SHADER PARA GRAFICOS 3D

#include "ProgramaShader.h"

ProgramaShader::ProgramaShader(const std::string& archivoVertex, const std::string&

archivoFragment)

vertexShaderID = cargarShader(archivoVertex, GL_VERTEX_SHADER);

fragmentShaderID = cargarShader(archivoFragment, GL_FRAGMENT_SHADER);

programaID = glCreateProgram();

glAttachShader(programaID, vertexShaderID);

glAttachShader(programaID, fragmentShaderID);

//vincularAtributos(); pero de la clase hija

//implementamos el metodo getID para obtener el programID

ProgramaShader::~ProgramaShader()

detener();

glDetachShader(programaID, vertexShaderID);

glDetachShader(programaID, fragmentShaderID);

glDeleteShader(vertexShaderID);

glDeleteShader(fragmentShaderID);

glDeleteProgram(programaID);

void ProgramaShader::comenzar()

glUseProgram(programaID);
}

void ProgramaShader::detener()

glUseProgram(0);

GLuint ProgramaShader::cargarShader(const std::string archivo, GLenum tipo)

std::ifstream fuenteSahder("recursos/shaders/" + archivo + ".glsl");

std::stringstream secuenciaString;

std::string fuente;

if(!fuenteSahder.is_open()){

throw std::runtime_error("no se pudo abrir el archivo " + archivo);

secuenciaString << fuenteSahder.rdbuf();

fuente = secuenciaString.str();

auto recurso = fuente.c_str();

auto id = glCreateShader(tipo);

glShaderSource(id, 1, &recurso, nullptr);

glCompileShader(id);

GLint esExitoso;

GLchar informe[512];

glGetShaderiv(id, GL_COMPILE_STATUS, &esExitoso);//devuelve un valor a esExitoso

if(!esExitoso)

std::cout << "dato = " << archivo<<std::endl;

glGetShaderInfoLog(id, 512, nullptr, informe);

 throw std::runtime_error ("Error al compilar shader: " + std::string(informe));

return id;

void ProgramaShader::vincularAtributo(GLuint atributo, const std::string nombreVariable)

glBindAttribLocation(programaID, atributo, nombreVariable.c_str());//c_str() para convertir

a const char*

GLuint ProgramaShader::obtenerLocalizacionUniforme(const std::string nombreUniforme)

return glGetUniformLocation(programaID, nombreUniforme.c_str());

void ProgramaShader::cargarFloat(GLuint localizacion, GLfloat valor)

glUniform1f(localizacion, valor);

void ProgramaShader::cargarVector(GLuint localizacion, const Vector3& vector)

glUniform3f(localizacion,vector.x,vector.y,vector.z);

void ProgramaShader::cargarBool(GLuint localizacion, bool valor)

float cargar = 0;

if(valor){

cargar = 1;
 }

glUniform1f(localizacion, cargar);

void ProgramaShader::cargarMatriz(GLuint localizacion, const Matriz4& matriz)

glUniformMatrix4fv(localizacion, 1, GL_FALSE, glm::value_ptr(matriz));//glm_ptr construye

un vector

//desde un puntero

GLuint ProgramaShader::obtenerProgramaID() const

return programaID;

GLuint ProgramaShader::obtenerVertexShaderID() const

return vertexShaderID;

GLuint ProgramaShader::obtenerFragmentShaderID() const

return fragmentShaderID;