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; } }