void GRendering::initGLSL(void)
{
// ------------------ Initialisiere ShadowMap Shader -------------------
glui_shadowMapShaderProgram = glCreateProgram();
GLuint glui_Shader_vert = compileShader("../Shader/ShadowMap.vert", VERT);
glAttachShader(glui_shadowMapShaderProgram, glui_Shader_vert);
GLuint glui_Shader_frag = compileShader("../Shader/ShadowMap.frag", FRAG);
glAttachShader(glui_shadowMapShaderProgram, glui_Shader_frag);
glBindAttribLocation(glui_shadowMapShaderProgram, SHADER_POSITION_LOC, "v_position");
glLinkProgram(glui_shadowMapShaderProgram);
printProgramInfoLog(glui_shadowMapShaderProgram);
// ------------------ Initialisiere Interactive Shader -----------------
glui_interactiveShaderProgram = glCreateProgram();
glui_Shader_vert = compileShader("../Shader/Interactive.vert", VERT);
glAttachShader(glui_interactiveShaderProgram, glui_Shader_vert);
GLuint glui_Shader_ctrl = compileShader("../Shader/Interactive.ctrl", CTRL);
glAttachShader(glui_interactiveShaderProgram, glui_Shader_ctrl);
GLuint glui_Shader_eval = compileShader("../Shader/Interactive.eval", EVAL);
glAttachShader(glui_interactiveShaderProgram, glui_Shader_eval);
glui_Shader_frag = compileShader("../Shader/Interactive.frag", FRAG);
glAttachShader(glui_interactiveShaderProgram, glui_Shader_frag);
glBindAttribLocation(glui_interactiveShaderProgram, SHADER_POSITION_LOC, "v_position");
glBindAttribLocation(glui_interactiveShaderProgram, SHADER_NORMAL_LOC, "v_normal");
glBindAttribLocation(glui_interactiveShaderProgram, SHADER_TEX_COORD_LOC, "v_texture");
glLinkProgram(glui_interactiveShaderProgram);
printProgramInfoLog(glui_interactiveShaderProgram);
// ------------------ Initialisiere Water Shader -----------------------
glui_waterShaderProgram = glCreateProgram();
glui_Shader_vert = compileShader("../Shader/Water.vert", VERT);
glAttachShader(glui_waterShaderProgram, glui_Shader_vert);
glui_Shader_frag = compileShader("../Shader/Water.frag", FRAG);
glAttachShader(glui_waterShaderProgram, glui_Shader_frag);
glBindAttribLocation(glui_waterShaderProgram, SHADER_POSITION_LOC, "v_position");
glBindAttribLocation(glui_waterShaderProgram, SHADER_NORMAL_LOC, "v_normal");
glLinkProgram(glui_waterShaderProgram);
printProgramInfoLog(glui_waterShaderProgram);
// ------------------ Initialisiere Skybox Shader ----------------------
glui_skyboxShaderProgram = glCreateProgram();
glui_Shader_vert = compileShader("../Shader/Sky.vert", VERT);
glAttachShader(glui_skyboxShaderProgram, glui_Shader_vert);
glui_Shader_frag = compileShader("../Shader/Sky.frag", FRAG);
glAttachShader(glui_skyboxShaderProgram, glui_Shader_frag);
glBindAttribLocation(glui_skyboxShaderProgram, SHADER_POSITION_LOC, "v_position");
glLinkProgram(glui_skyboxShaderProgram);
printProgramInfoLog(glui_skyboxShaderProgram);
}
// Create a GLSL program object from vertex and fragment shader files
GLuint
InitShader(const char* vShaderFile, const char* fShaderFile)
{
struct Shader {
const char* filename;
GLenum type;
GLchar* source;
} shaders[2] = {
{ vShaderFile, GL_VERTEX_SHADER, NULL },
{ fShaderFile, GL_FRAGMENT_SHADER, NULL }
};
GLuint program = glCreateProgram();
for ( int i = 0; i < 2; ++i ) {
Shader& s = shaders[i];
s.source = readShaderSource( s.filename );
if ( shaders[i].source == NULL ) {
std::cerr << "Failed to read " << s.filename << std::endl;
exit( EXIT_FAILURE );
}
GLuint shader = glCreateShader( s.type );
glShaderSource( shader, 1, (const GLchar**) &s.source, NULL );
glCompileShader( shader );
printShaderInfoLog(shader);
GLint compiled;
glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
if ( !compiled ) {
std::cerr << s.filename << " failed to compile:" << std::endl;
GLint logSize;
glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &logSize );
char* logMsg = new char[logSize];
glGetShaderInfoLog( shader, logSize, NULL, logMsg );
std::cerr << logMsg << std::endl;
delete [] logMsg;
exit( EXIT_FAILURE );
}
delete [] s.source;
glAttachShader( program, shader );
}
/* link and error check */
glLinkProgram(program);
GLint linked;
glGetProgramiv( program, GL_LINK_STATUS, &linked );
if ( !linked ) {
std::cerr << "Shader program failed to link" << std::endl;
GLint logSize;
glGetProgramiv( program, GL_INFO_LOG_LENGTH, &logSize);
char* logMsg = new char[logSize];
glGetProgramInfoLog( program, logSize, NULL, logMsg );
std::cerr << logMsg << std::endl;
delete [] logMsg;
exit( EXIT_FAILURE );
}
/* use program object */
glUseProgram(program);
printProgramInfoLog(program);
return program;
}
// Read/compile/link shaders
static bool loadShaders(GLuint *program, const char *definitions,
const char *vertexPath, const char *fragmentPath)
{
GLint status;
bool success = true; // Assume overall success
char *buffer[2];
*program = glCreateProgram();
ASSERT_OR_RETURN(false, definitions != NULL, "Null in preprocessor definitions!");
ASSERT_OR_RETURN(false, *program, "Could not create shader program!");
*buffer = (char *)definitions;
if (vertexPath)
{
success = false; // Assume failure before reading shader file
if ((*(buffer + 1) = readShaderBuf(vertexPath)))
{
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(shader, 2, (const char **)buffer, NULL);
glCompileShader(shader);
// Check for compilation errors
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (!status)
{
debug(LOG_ERROR, "Vertex shader compilation has failed [%s]", vertexPath);
printShaderInfoLog(LOG_ERROR, shader);
}
else
{
printShaderInfoLog(LOG_3D, shader);
glAttachShader(*program, shader);
success = true;
}
free(*(buffer + 1));
}
}
if (success && fragmentPath)
{
success = false; // Assume failure before reading shader file
if ((*(buffer + 1) = readShaderBuf(fragmentPath)))
{
GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(shader, 2, (const char **)buffer, NULL);
glCompileShader(shader);
// Check for compilation errors
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (!status)
{
debug(LOG_ERROR, "Fragment shader compilation has failed [%s]", fragmentPath);
printShaderInfoLog(LOG_ERROR, shader);
}
else
{
printShaderInfoLog(LOG_3D, shader);
glAttachShader(*program, shader);
success = true;
}
free(*(buffer + 1));
}
}
if (success)
{
glLinkProgram(*program);
// Check for linkage errors
glGetProgramiv(*program, GL_LINK_STATUS, &status);
if (!status)
{
debug(LOG_ERROR, "Shader program linkage has failed [%s, %s]", vertexPath, fragmentPath);
printProgramInfoLog(LOG_ERROR, *program);
success = false;
}
else
{
printProgramInfoLog(LOG_3D, *program);
}
}
return success;
}
bumpmaphdl::bumpmaphdl()
{
type = "bumpmap";
shininess = 1.0;
if (vertex == 0 && fragment == 0 && program == 0)
{
/* TODO Assignment 3: Load and link the shaders and load the texture Keep in mind that vertex, fragment,
* and program are static variables meaning they are *shared across all instances of
* this class. So you only have to initialize them once when the first instance of
* the class is created.
*/
glEnable(GL_DEPTH_TEST);
vertex = load_shader_file("res/bumpmap.vx", GL_VERTEX_SHADER);
fragment = load_shader_file("res/bumpmap.ft", GL_FRAGMENT_SHADER);
program = glCreateProgram();
progmap.insert(pair<string, int>("bumpmap", program));
printProgramInfoLog(program);
glAttachShader(program, vertex);
glAttachShader(program, fragment);
GLint pok = 0;
glGetProgramiv(program, GL_LINK_STATUS, &pok);
if (pok == GL_FALSE)
cout << "program bad" << endl;
if (pok == GL_TRUE)
cout << "program good" << endl;
glAttachShader(program, vertex);
glAttachShader(program, fragment);
GLint vok = 0;
GLint fok = 0;
glGetShaderiv(vertex, GL_COMPILE_STATUS, &vok);
glGetShaderiv(fragment, GL_COMPILE_STATUS, &fok);
if (vok == GL_FALSE)
cout << "Something in the vertex shader fed up";
if (vok == GL_TRUE)
cout << "normmap V shader is good";
if (fok == GL_FALSE)
cout << "Something in the fragment shader fed up";
if (vok == GL_TRUE)
cout << "F shader is good";
printShaderInfoLog(vertex);
printShaderInfoLog(fragment);
glLinkProgram(program);
pok = 0;
glGetProgramiv(program, GL_LINK_STATUS, &pok);
if (pok == GL_FALSE)
cout << "program bad" << endl;
if (pok == GL_TRUE)
cout << "program good" << endl;
unsigned width, height ,w2, h2;
vector<unsigned char> image,other;
loadtexture(width, height, image, "res/img/chest.png");
loadtexture(w2, h2, other, "res/img/chest_nm.png");
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image.data());
glGenerateMipmap(GL_TEXTURE_2D);
glGenTextures(1, &normalmap);
glBindTexture(GL_TEXTURE_2D, normalmap);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w2, h2, 0, GL_RGBA, GL_UNSIGNED_BYTE, other.data());
glGenerateMipmap(GL_TEXTURE_2D);
}
}
void setShaders() {
const char * vv;
const char * ff;
char *vs,*fs;
GLint status;
GLhandleARB vertex_program,fragment_program;
GLint sourceSize, shader_texture_source;
vertex_program = glCreateShader(GL_VERTEX_SHADER);
fragment_program = glCreateShader(GL_FRAGMENT_SHADER);
vs = textFileRead(SHADER_DIR "demosaic.vrt");
if (vs==NULL) {
fprintf(stderr,"ERROR: failed to read vertex shader %s\n",
SHADER_DIR "demosaic.vrt");
use_shaders = 0;
return;
}
fs = textFileRead(SHADER_DIR "demosaic.frg");
if (fs==NULL) {
fprintf(stderr,"ERROR: failed to read fragment shader %s\n",
SHADER_DIR "demosaic.frg");
use_shaders = 0;
return;
}
vv = vs;
ff = fs;
glShaderSource(vertex_program, 1, &vv,NULL);
glShaderSource(fragment_program, 1, &ff,NULL);
free(vs);free(fs);
glCompileShader(vertex_program);
glGetShaderiv(vertex_program,GL_COMPILE_STATUS,&status);
if (status!=GL_TRUE) {
fprintf(stderr,
"ERROR: GLSL vertex shader compile error, disabling shaders\n");
use_shaders = 0;
return;
}
glCompileShader(fragment_program);
glGetShaderiv(fragment_program,GL_COMPILE_STATUS,&status);
if (status!=GL_TRUE) {
fprintf(stderr,
"ERROR: GLSL fragment shader compile error, disabling shaders\n");
use_shaders = 0;
return;
}
printShaderInfoLog(vertex_program);
printShaderInfoLog(fragment_program);
glsl_program = glCreateProgram();
glAttachShader(glsl_program,vertex_program);
glAttachShader(glsl_program,fragment_program);
glLinkProgram(glsl_program);
printProgramInfoLog(glsl_program);
glGetProgramiv(glsl_program,GL_LINK_STATUS,&status);
if (status!=GL_TRUE) {
fprintf(stderr,"ERROR: GLSL link error, disabling shaders\n");
use_shaders = 0;
return;
}
glUseProgram(glsl_program);
printf("GLSL shaders in use\n");
sourceSize = glGetUniformLocation(glsl_program,"sourceSize");
shader_texture_source = glGetUniformLocation(glsl_program,"source");
glUniform4f(sourceSize,
PBO_stride,height,
1.0/PBO_stride,1.0/height);
glUniform1i(shader_texture_source, 0);
}
// Read/compile/link shaders
GLuint pie_LoadShader(const char *programName, const char *vertexPath, const char *fragmentPath)
{
SHADER_PROGRAM program;
GLint status;
bool success = true; // Assume overall success
char *buffer[2];
memset(&program, 0, sizeof(program));
program.program = glCreateProgram();
ASSERT_OR_RETURN(false, program.program, "Could not create shader program!");
*buffer = (char *)"";
if (vertexPath)
{
success = false; // Assume failure before reading shader file
if ((*(buffer + 1) = readShaderBuf(vertexPath)))
{
GLuint shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(shader, 2, (const char **)buffer, NULL);
glCompileShader(shader);
// Check for compilation errors
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (!status)
{
debug(LOG_ERROR, "Vertex shader compilation has failed [%s]", vertexPath);
printShaderInfoLog(LOG_ERROR, shader);
}
else
{
printShaderInfoLog(LOG_3D, shader);
glAttachShader(program.program, shader);
success = true;
}
if (GLEW_VERSION_4_3 || GLEW_KHR_debug)
{
glObjectLabel(GL_SHADER, shader, -1, vertexPath);
}
free(*(buffer + 1));
}
}
if (success && fragmentPath)
{
success = false; // Assume failure before reading shader file
if ((*(buffer + 1) = readShaderBuf(fragmentPath)))
{
GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(shader, 2, (const char **)buffer, NULL);
glCompileShader(shader);
// Check for compilation errors
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (!status)
{
debug(LOG_ERROR, "Fragment shader compilation has failed [%s]", fragmentPath);
printShaderInfoLog(LOG_ERROR, shader);
}
else
{
printShaderInfoLog(LOG_3D, shader);
glAttachShader(program.program, shader);
success = true;
}
if (GLEW_VERSION_4_3 || GLEW_KHR_debug)
{
glObjectLabel(GL_SHADER, shader, -1, fragmentPath);
}
free(*(buffer + 1));
}
}
if (success)
{
glLinkProgram(program.program);
// Check for linkage errors
glGetProgramiv(program.program, GL_LINK_STATUS, &status);
if (!status)
{
debug(LOG_ERROR, "Shader program linkage has failed [%s, %s]", vertexPath, fragmentPath);
printProgramInfoLog(LOG_ERROR, program.program);
success = false;
}
else
{
printProgramInfoLog(LOG_3D, program.program);
}
if (GLEW_VERSION_4_3 || GLEW_KHR_debug)
{
glObjectLabel(GL_PROGRAM, program.program, -1, programName);
}
}
getLocs(&program);
glUseProgram(0);
shaderProgram.append(program);
return shaderProgram.size() - 1;
}
int Renderer::initShader(std::string vsFileName, std::string fsFileName)
{
// Les opérations devant être faites pour pouvoir utiliser des shaders OpenGL dans notre application sont les suivantes :
// 1 - Vertex shader :
// 1.1 - Charger le source depuis le fichier "../shaders/vertexdefault.glsl" en utilisant la fonction loaders::text::loadFile() de lecture d'un fichier texte
char* vertexShaderSource = loaders::text::loadFile(vsFileName.c_str());
// 1.2 - Créer un objet OpenGL VERTEX_SHADER et y associer le source
int vertexShaderId;
glAssert(vertexShaderId = glCreateShader(GL_VERTEX_SHADER));
glAssert(glShaderSource(vertexShaderId, 1, (const GLchar **)&vertexShaderSource, NULL));
// 1.3 - Compiler le shader
glAssert(glCompileShader(vertexShaderId));
// 1.4 - Vérifier les erreurs de compilation
GLint compiled;
glAssert(glGetShaderiv(vertexShaderId, GL_COMPILE_STATUS, &compiled));
if (!compiled) {
std::cerr << "[" << vsFileName << "] Vertex shader not compiled : " << std::endl;
printShaderInfoLog(vertexShaderId);
return 0;
}
// 2 - Fragment shader :
// 2.1 - Charger le source depuis le fichier "../shaders/fragmentdefault.glsl" en utilisant la fonction loaders::text::loadFile() de lecture d'un fichier texte
char *fragmentShaderSource;
fragmentShaderSource = loaders::text::loadFile(fsFileName.c_str());
// 2.2 - Créer un objet OpenGL FRAGMENT_SHADER et y associer le source
int fragmentShaderId;
glAssert(fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER));
glAssert(glShaderSource(fragmentShaderId, 1, (const GLchar **)&fragmentShaderSource, NULL));
// 2.3 - Compiler le shader
glAssert(glCompileShader(fragmentShaderId));
// 2.4 - Vérifier les erreurs de compilation
glAssert(glGetShaderiv(fragmentShaderId, GL_COMPILE_STATUS, &compiled));
if (!compiled) {
std::cerr << "[" << fsFileName << "] fragment shader not compiled : " << std::endl;
printShaderInfoLog(fragmentShaderId);
return 0;
}
// 3 - Programme :
// 3.1 - Créer un programme OpenGL, stocker son identifiant dans g_Program et y associer les shaders
int program;
glAssert(program = glCreateProgram());
glAssert(glAttachShader(program, vertexShaderId));
glAssert(glAttachShader(program, fragmentShaderId));
// 3.2 - Fixer les positions des attributs géométriques en accord avec la classe MyGLMesh et les conventions
// d'écriture du source GLSL inPosition --> index 0, inNormal --> index 1 et inTexCoord --> index 2.
glAssert(glBindAttribLocation(program, 0, "inPosition"));
glAssert(glBindAttribLocation(program, 1, "inNormal"));
glAssert(glBindAttribLocation(program, 2, "inTexCoord"));
// 3.3 - Lier le programme
glAssert(glLinkProgram(program));
// 3.4 - Vérifier les erreurs d'édition de lien
GLint linked;
glAssert(glGetProgramiv(program, GL_LINK_STATUS, &linked));
if (!linked) {
std::cerr << "Program not linked" << std::endl;
printProgramInfoLog(program);
}
return program;
}
void shader_object::setShader(const char *vs, const char *fs, const char *gs,
GLuint itype, GLuint otype, GLint osize)
{
//fprintf(stderr, "**** %s:%s() ****\n", __FILE__, __func__);
v = glCreateShader(GL_VERTEX_SHADER);
f = glCreateShader(GL_FRAGMENT_SHADER);
if(gs) g = glCreateShader(GL_GEOMETRY_SHADER_EXT);
glShaderSource(v, 1, &vs, NULL);
glShaderSource(f, 1, &fs, NULL);
if(g)
{
glShaderSource(g, 1, &gs, NULL);
}
//printf("compile vertex shader\n");
glCompileShader(v);
GLint params;
glGetShaderiv(v, GL_COMPILE_STATUS, ¶ms);
if(params == GL_FALSE)
{
fprintf(stderr, "compile vertex shader error:\n");
printShaderInfoLog(v);
exit(10);
}
//printf("compile fragment shader\n");
glCompileShader(f);
glGetShaderiv(f, GL_COMPILE_STATUS, ¶ms);
if(params == GL_FALSE)
{
fprintf(stderr, "compile fragment shader error:\n");
printShaderInfoLog(f);
exit(10);
}
if(g)
{
//printf("compile geometry shader\n");
glCompileShader(g);
glGetShaderiv(g, GL_COMPILE_STATUS, ¶ms);
if(params == GL_FALSE)
{
fprintf(stderr, "compile geometry shader error:\n");
printShaderInfoLog(g);
exit(10);
}
}
//printf("create program\n");
p = glCreateProgram();
//printf("attach shaders to program\n");
glAttachShader(p, v);
glAttachShader(p, f);
if(g)
{
glAttachShader(p, g);
setup_geometry_shader(itype, otype, osize);
}
//printf("link program\n");
glLinkProgram(p);
glGetProgramiv(p, GL_LINK_STATUS, ¶ms);
if(params == GL_FALSE)
{
fprintf(stderr, "link program error:\n");
printProgramInfoLog(p);
exit(10);
}
if( printOpenGLError() ) exit(1);
//glUseProgram(p);
}
void printAll(GLuint program) {
std::cout << "*************** shader program " << program << " info ***************" << std::endl;
int params = -1;
glGetProgramiv(program, GL_LINK_STATUS, ¶ms);
checkGL();
std::cout << "GL_LINK_STATUS: " << params << std::endl;
glGetProgramiv(program, GL_ATTACHED_SHADERS, ¶ms);
checkGL();
std::cout << "GL_ATTACHED_SHADERS: " << params << std::endl;
glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, ¶ms);
checkGL();
std::cout << "GL_ACTIVE_ATTRIBUTES: " << params << std::endl;
int location = 0;
char name[64];
char longName[64];
int actualLength = 0;
int size = 0;
GLenum type;
for(int i = 0; i < params; ++i) {
glGetActiveAttrib(program, i, sizeof(name), &actualLength,
&size, &type, name);
checkGL();
if(size > 1) {
for(int j = 0; j < size; ++j) {
sprintf(longName, "%s[%i]", name, j);
location = glGetAttribLocation(program, longName);
checkGL();
std::cout << " " << i <<
") type: " << GLTypeToString(type) <<
" name: " << longName <<
" location: " << location << std::endl;
}
} else {
location = glGetAttribLocation(program, name);
checkGL();
std::cout << " " << i <<
") type: " << GLTypeToString(type) <<
" name: " << name <<
" location: " << location << std::endl;
}
}
glGetProgramiv(program, GL_ACTIVE_UNIFORMS, ¶ms);
checkGL();
std::cout << "GL_ACTIVE_UNIFORMS: " << params << std::endl;
for(int i = 0; i < params; ++i) {
glGetActiveUniform(program, i, sizeof(name), &actualLength,
&size, &type, name);
checkGL();
if(size > 1) {
for(int j = 0; j < size; ++j) {
sprintf(longName, "%s[%i]", name, j);
location = glGetUniformLocation(program, longName);
checkGL();
std::cout << " " << i <<
") type: " << GLTypeToString(type) <<
" name: " << longName <<
" location: " << location << std::endl;
}
} else {
location = glGetUniformLocation(program, name);
checkGL();
std::cout << " " << i <<
") type: " << GLTypeToString(type) <<
" name: " << name <<
" location: " << location << std::endl;
}
}
GLint blocks = 0;
glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &blocks);
checkGL();
std::cout << "GL_MAX_UNIFORM_BUFFER_BINDINGS = " << blocks << std::endl;
printProgramInfoLog(program);
}
/*function to help load the shader - note current version only loading a vertex shader */
int InstallShader(const GLchar *vShaderName, const GLchar *fShaderName) {
GLuint VS, FS; //handles to shader Model
GLint vCompiled, fCompiled, linked; //status of shader
VS = glCreateShader(GL_VERTEX_SHADER);
FS = glCreateShader(GL_FRAGMENT_SHADER);
//load the source
glShaderSource(VS, 1, &vShaderName, NULL);
glShaderSource(FS, 1, &fShaderName, NULL);
//compile shader and print log
glCompileShader(VS);
/* check shader status requires helper functions */
printOpenGLError();
glGetShaderiv(VS, GL_COMPILE_STATUS, &vCompiled);
printShaderInfoLog(VS);
//compile shader and print log
glCompileShader(FS);
/* check shader status requires helper functions */
printOpenGLError();
glGetShaderiv(FS, GL_COMPILE_STATUS, &fCompiled);
printShaderInfoLog(FS);
if (!vCompiled || !fCompiled) {
printf("Error compiling the shader %s", vShaderName);
return 0;
}
//create a program Model and attach the compiled shader
ShadeProg = glCreateProgram();
glAttachShader(ShadeProg, VS);
glAttachShader(ShadeProg, FS);
glLinkProgram(ShadeProg);
/* check shader status requires helper functions */
printOpenGLError();
glGetProgramiv(ShadeProg, GL_LINK_STATUS, &linked);
printProgramInfoLog(ShadeProg);
glUseProgram(ShadeProg);
/* get handles to attribute data */
h_aPosition = safe_glGetAttribLocation(ShadeProg, "aPosition");
h_aNormal = safe_glGetAttribLocation(ShadeProg, "aNormal");
h_uProjMatrix = safe_glGetUniformLocation(ShadeProg, "uProjMatrix");
h_uViewMatrix = safe_glGetUniformLocation(ShadeProg, "uViewMatrix");
h_uModelMatrix = safe_glGetUniformLocation(ShadeProg, "uModelMatrix");
h_uShadeType = safe_glGetUniformLocation(ShadeProg, "uShadeType");
h_uCamPos = safe_glGetUniformLocation(ShadeProg, "uCamPos");
h_uSun = safe_glGetUniformLocation(ShadeProg, "uSun");
h_uLightColor = safe_glGetUniformLocation(ShadeProg, "uLColor");
h_uMatAmb = safe_glGetUniformLocation(ShadeProg, "uMat.aColor");
h_uMatDif = safe_glGetUniformLocation(ShadeProg, "uMat.dColor");
h_uMatSpec = safe_glGetUniformLocation(ShadeProg, "uMat.sColor");
h_uMatShine = safe_glGetUniformLocation(ShadeProg, "uMat.shine");
h_aTexCoord = safe_glGetAttribLocation(ShadeProg, "aTexCoord");
h_uTexUnit = safe_glGetUniformLocation(ShadeProg, "uTexUnit");
printf("sucessfully installed shader %d\n", ShadeProg);
return 1;
}
OpenGLProgram::OpenGLProgram(string vertex_shader_file_name, string fragment_shader_file_name) {
/* Cool preprocessing */
m_program_ok = true;
ifstream input_vertex_shader_file(vertex_shader_file_name, ios::in | ios::binary);
if (input_vertex_shader_file) {
input_vertex_shader_file.seekg(0, ios::end);
m_vertex_shader_source.resize(static_cast<unsigned int>(input_vertex_shader_file.tellg()));
input_vertex_shader_file.seekg(0, ios::beg);
input_vertex_shader_file.read(&m_vertex_shader_source[0], m_vertex_shader_source.size());
input_vertex_shader_file.close();
} else {
cerr << "Could not open vertex shader file at: " << vertex_shader_file_name << endl;
m_program_ok = false;
}
ifstream input_fragment_shader_file(fragment_shader_file_name, ios::in | ios::binary);
if (input_fragment_shader_file) {
input_fragment_shader_file.seekg(0, ios::end);
m_fragment_shader_source.resize(static_cast<unsigned int>(input_fragment_shader_file.tellg()));
input_fragment_shader_file.seekg(0, ios::beg);
input_fragment_shader_file.read(&m_fragment_shader_source[0], m_fragment_shader_source.size());
input_fragment_shader_file.close();
} else {
cerr << "Could not open fragment shader file at: " << fragment_shader_file_name << endl;
m_program_ok = false;
}
/* or not */
m_vertex_shader = glCreateShader(GL_VERTEX_SHADER);
const char* start = &m_vertex_shader_source[0];
glShaderSource(m_vertex_shader, 1, &start, NULL);
m_fragment_shader= glCreateShader(GL_FRAGMENT_SHADER);
start = &m_fragment_shader_source[0];
glShaderSource(m_fragment_shader, 1, &start, NULL);
try {
int status;
glCompileShader(m_vertex_shader);
glGetShaderiv(m_vertex_shader, GL_COMPILE_STATUS, &status);
if(status == GL_FALSE) {
throw m_vertex_shader;
}
glCompileShader(m_fragment_shader);
glGetShaderiv(m_fragment_shader, GL_COMPILE_STATUS, &status);
if(status == GL_FALSE) {
throw m_fragment_shader;
}
} catch(GLuint bad_shader) {
printShaderInfoLog(bad_shader);
m_program_ok = false;
}
m_program = glCreateProgram();
try {
int status;
glAttachShader(m_program, m_vertex_shader);
glAttachShader(m_program, m_fragment_shader);
glLinkProgram(m_program);
glGetProgramiv(m_program, GL_LINK_STATUS, &status);
if(status == GL_FALSE) {
throw m_program;
}
} catch(GLuint bad_program) {
printProgramInfoLog(bad_program);
m_program_ok = false;
}
}
