void Shader::setup(const char *vs, const char *fs) { //fprintf(stdout, "vs, fs = %p, %p\n", vs, fs); //GLuint vid = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); //GLuint fid = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); GLhandleARB vid = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); GLhandleARB fid = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); glShaderSourceARB(vid, 1, &vs, 0); glShaderSourceARB(fid, 1, &fs, 0); glCompileShaderARB(vid); glCompileShaderARB(fid); char glslLog[1024]; GLsizei glslLogSize; glGetInfoLogARB(vid, 1024, &glslLogSize, glslLog); if (glslLogSize) printf("vertex program log: %s\n", glslLog); glGetInfoLogARB(fid, 1024, &glslLogSize, glslLog); if (glslLogSize) printf("fragment program log: %s\n", glslLog); pid = glCreateProgramObjectARB(); glAttachObjectARB(pid, vid); glAttachObjectARB(pid, fid); // delete shader objects as soon as they have been attached to a program glDeleteObjectARB(vid); glDeleteObjectARB(fid); glLinkProgramARB(pid); }
void ofxShader::setup(string fragmentName, string vertexName) { bLoaded = false; if (GLEE_ARB_shader_objects) { vertexShader = (GLhandleARB) glCreateShader(GL_VERTEX_SHADER); fragmentShader = (GLhandleARB) glCreateShader(GL_FRAGMENT_SHADER); string vs = loadShaderText(vertexName); string fs = loadShaderText(fragmentName); const char* vsptr = vs.c_str(); const char* fsptr = fs.c_str(); int vssize = vs.size(); int fssize = fs.size(); glShaderSourceARB(vertexShader, 1, &vsptr, &vssize); glShaderSourceARB(fragmentShader, 1, &fsptr, &fssize); glCompileShaderARB(vertexShader); //please add compile status check in: //GLint compileStatus = 0; //glGetObjectParameterivARB( vertexShader, GL_COMPILE_STATUS, &compileStatus ); //printf("%i \n", compileStatus); char infobuffer[1000]; GLsizei infobufferlen = 0; glGetInfoLogARB(vertexShader, 999, &infobufferlen, infobuffer); if (infobufferlen != 0) { infobuffer[infobufferlen] = 0; printf("vertexShader reports: %s \n", infobuffer); return; } glCompileShaderARB(fragmentShader); //glGetObjectParameterivARB( fragmentShader, GL_COMPILE_STATUS, &compileStatus ); //printf("%i \n", compileStatus); glGetInfoLogARB(fragmentShader, 999, &infobufferlen, infobuffer); if (infobufferlen != 0) { infobuffer[infobufferlen] = 0; printf("fragmentShader reports: %s \n", infobuffer); return; } shader = glCreateProgramObjectARB(); glAttachObjectARB(shader, vertexShader); glAttachObjectARB(shader, fragmentShader); glLinkProgramARB(shader); bLoaded = true; } else { cout << "Sorry, it looks like you can't run 'ARB_shader_objects'." << endl; cout << "Please check the capabilites of your graphics card." << endl; cout << "http://www.ozone3d.net/gpu_caps_viewer/)" << endl; } }
int main() { GLenum shader_prog, shader_vert, shader_frag; int i; char buf[1024]; const GLcharARB *vertex_shader_code, *fragment_shader_code; GLint loc; assert((vertex_shader_code = loadShader("shader.vert"))); assert((fragment_shader_code = loadShader("shader.frag"))); assert(!SDL_Init(SDL_INIT_EVERYTHING)); atexit(SDL_Quit); SDL_GL_SET_ATTR(RED_SIZE, 8); SDL_GL_SET_ATTR(GREEN_SIZE, 8); SDL_GL_SET_ATTR(BLUE_SIZE, 8); SDL_GL_SET_ATTR(DEPTH_SIZE, 16); SDL_GL_SET_ATTR(DOUBLEBUFFER, 1); assert(SDL_SetVideoMode(SCRW, SCRH, SCRBPP, SDL_OPENGL /*| SDL_FULLSCREEN*/)); /* puts((const char *)glGetString(GL_EXTENSIONS));*/ DO_GL_PROCS(DEFINE_GL_PROC) assert((shader_prog = glCreateProgramObjectARB())); assert((shader_vert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB))); assert((shader_frag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB))); i = strlen(vertex_shader_code); printf("vert len: %d\n", i); glShaderSourceARB(shader_vert, 1, &vertex_shader_code, &i); i = strlen(fragment_shader_code); printf("frag len: %d\n", i); glShaderSourceARB(shader_frag, 1, &fragment_shader_code, &i); glCompileShaderARB(shader_vert); glCompileShaderARB(shader_frag); glAttachObjectARB(shader_prog, shader_vert); glAttachObjectARB(shader_prog, shader_frag); glLinkProgramARB(shader_prog); i = 0; glGetInfoLogARB(shader_vert, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("vert error: \"%s\"\n", buf); i = 0; glGetInfoLogARB(shader_frag, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("frag error: \"%s\"\n", buf); i = 0; glGetInfoLogARB(shader_prog, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("prog error: \"%s\"\n", buf); glUseProgramObjectARB(shader_prog); loc = glGetUniformLocationARB(shader_prog, "time"); while (!SDL_GetKeyState(0)[SDLK_ESCAPE]) { float time = (float)SDL_GetTicks() / 2000.0f; SDL_PumpEvents(); glUniform1fARB(loc, time); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glBegin(GL_QUADS); glVertex3f(-1.0f, 1.0f, 0.0f); glVertex3f(1.0f, 1.0f, 0.0f); glVertex3f(1.0f, -1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 0.0f); glEnd(); SDL_GL_SwapBuffers(); } return 0; }
GPUShader *GPU_shader_create_lib(const char *code) { GLint status; GLcharARB log[5000]; GLsizei length = 0; GPUShader *shader; if (!GLEW_ARB_vertex_shader || !GLEW_ARB_fragment_shader) return NULL; shader = MEM_callocN(sizeof(GPUShader), "GPUShader"); shader->lib = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); if (!shader->lib) { fprintf(stderr, "GPUShader, object creation failed.\n"); GPU_shader_free(shader); return NULL; } glShaderSourceARB(shader->lib, 1, (const char**)&code, NULL); glCompileShaderARB(shader->lib); glGetObjectParameterivARB(shader->lib, GL_OBJECT_COMPILE_STATUS_ARB, &status); if (!status) { glGetInfoLogARB(shader->lib, sizeof(log), &length, log); shader_print_errors("compile", log, code); GPU_shader_free(shader); return NULL; } return shader; }
static void link_shader_arb (GLuint *program, GLuint vert, GLuint frag) { GLint gl_status; *program = glCreateProgramObjectARB (); glAttachObjectARB (*program, vert); glAttachObjectARB (*program, frag); glLinkProgramARB (*program); glGetObjectParameterivARB (*program, GL_OBJECT_LINK_STATUS_ARB, &gl_status); if (gl_status == GL_FALSE) { GLint log_size; glGetObjectParameterivARB (*program, GL_OBJECT_INFO_LOG_LENGTH_ARB, &log_size); if (0 < log_size) { char *log = _cairo_malloc (log_size); GLint chars; log[log_size - 1] = '\0'; glGetInfoLogARB (*program, log_size, &chars, log); printf ("OpenGL shader link failed:\n%s\n", log); free (log); } else { printf ("OpenGL shader link failed.\n"); } ASSERT_NOT_REACHED; } }
void neb::glsl::program::compile() { //GRU_GLSL_PROGRAM_FUNC glLinkProgram(o_); checkerror("glLinkProgram"); GLint blen = 0; GLsizei slen = 0; glGetProgramiv(o_, GL_INFO_LOG_LENGTH , &blen); checkerror("glGetProgramiv"); if (blen > 1) { GLchar* compiler_log = (GLchar*)malloc(blen); glGetInfoLogARB(o_, blen, &slen, compiler_log); printf("compiler_log:%s\n", compiler_log); free (compiler_log); } printf("program=%i\n",o_); }
//----------------------------------------------------------------------------- String logObjectInfo(const String& msg, const GLhandleARB obj) { String logMessage = msg; if (obj > 0) { GLint infologLength = 0; glGetObjectParameterivARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infologLength); if (infologLength > 0) { GLint charsWritten = 0; GLcharARB * infoLog = new GLcharARB[infologLength]; glGetInfoLogARB(obj, infologLength, &charsWritten, infoLog); logMessage += String(infoLog); LogManager::getSingleton().logMessage(logMessage); delete [] infoLog; } } return logMessage; }
bool glsl_geometry :: openMessARB(void) { if(m_shaderARB) { glDeleteObjectARB( m_shaderARB ); gem::utils::glsl::delshader(m_shaderARB); } m_shaderARB = glCreateShaderObjectARB(m_shaderTarget); if (!m_shaderARB) { error("could not create ARB shader object"); return false; } const char * vs = m_shaderString; glShaderSourceARB( m_shaderARB, 1, &vs, NULL ); glCompileShaderARB( m_shaderARB ); glGetObjectParameterivARB( m_shaderARB, GL_OBJECT_COMPILE_STATUS_ARB, &m_compiled ); if (!m_compiled) { GLint length; GLcharARB* log; glGetObjectParameterivARB( m_shaderARB, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length ); log = (GLcharARB*)malloc( length * sizeof(GLcharARB) ); glGetInfoLogARB( m_shaderARB, length, NULL, log ); post("compile Info_log:"); post("%s", log ); error("shader not loaded"); free(log); return false; } return true; }
//#include <object.h> //#include <sb6ktx.h> //#include <shader.h> GLint create_program(GLuint* s, int c, bool b) { printf("%s\n",__PRETTY_FUNCTION__); GLint o = glCreateProgram(); for(int i = 0; i < c; ++i ) { printf("shader %i attached to program %i\n",s[i],o); glAttachShader(o, s[i]); } glLinkProgram(o); GLint blen = 0; GLsizei slen = 0; glGetProgramiv(o, GL_INFO_LOG_LENGTH , &blen); if (blen > 1) { GLchar* compiler_log = (GLchar*)malloc(blen); glGetInfoLogARB(o, blen, &slen, compiler_log); printf("compiler_log:%s\n", compiler_log); free (compiler_log); } printf("program=%i\n",o); }
GLhandleARB Shader::makeShader(const char * fileName, GLenum type) { ifstream file(fileName); stringstream ss; ss << file.rdbuf(); string source = ss.str(); char * mem = (char *)alloca(source.length()+1); strcpy(mem, source.c_str()); //mem[source.length] = '\0'; GLhandleARB shaderHandle = glCreateShaderObjectARB (type); glShaderSourceARB (shaderHandle, 1, (const GLcharARB **)&mem, 0); glCompileShaderARB (shaderHandle); int status; glGetObjectParameterivARB (shaderHandle, GL_OBJECT_COMPILE_STATUS_ARB, &status); if (status != 0) return shaderHandle; //Everything OK... //It didn't, so log error information... //::log ("\nFailed to compile %s shader \"%s\"...", type == GL_VERTEX_SHADER_ARB ? "VERTEX" : "PIXEL", name.c_str ()); int length = 0; glGetObjectParameterivARB (shaderHandle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length); const long MAXIMUM_LOG_STRING = 1024; char logString [MAXIMUM_LOG_STRING]; GLsizei messageLength = min (length, MAXIMUM_LOG_STRING); if (messageLength > 0) { glGetInfoLogARB (shaderHandle, messageLength, 0, logString); MessageBox(NULL, logString, "Shader Error", MB_OK); } glDeleteObjectARB (shaderHandle); return NULL; }
GLhandleARB glLinkShader(GLhandleARB vertexShaderObject,GLhandleARB fragmentShaderObject) { /* Create the program object: */ GLhandleARB programObject=glCreateProgramObjectARB(); /* Attach all shader objects to the shader program: */ glAttachObjectARB(programObject,vertexShaderObject); glAttachObjectARB(programObject,fragmentShaderObject); /* Link the program: */ glLinkProgramARB(programObject); /* Check if the program linked successfully: */ GLint linkStatus; glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus); if(!linkStatus) { /* Get some more detailed information: */ GLcharARB linkLogBuffer[2048]; GLsizei linkLogSize; glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer); /* Delete the program object: */ glDeleteObjectARB(programObject); /* Signal an error: */ Misc::throwStdErr("glLinkShader: Error \"%s\" while linking shader program",linkLogBuffer); } return programObject; }
GLhandleARB glLinkShader(const std::vector<GLhandleARB>& shaderObjects) { /* Create the program object: */ GLhandleARB programObject=glCreateProgramObjectARB(); /* Attach all shader objects to the shader program: */ for(std::vector<GLhandleARB>::const_iterator soIt=shaderObjects.begin();soIt!=shaderObjects.end();++soIt) glAttachObjectARB(programObject,*soIt); /* Link the program: */ glLinkProgramARB(programObject); /* Check if the program linked successfully: */ GLint linkStatus; glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus); if(!linkStatus) { /* Get some more detailed information: */ GLcharARB linkLogBuffer[2048]; GLsizei linkLogSize; glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer); /* Delete the program object: */ glDeleteObjectARB(programObject); /* Signal an error: */ Misc::throwStdErr("glLinkShader: Error \"%s\" while linking shader program",linkLogBuffer); } return programObject; }
void glCompileShaderFromStrings(GLhandleARB shaderObject,size_t numShaderSources,va_list ap) { /* Get pointers to all shader source strings: */ const GLcharARB** strings=new const GLcharARB*[numShaderSources]; for(size_t i=0;i<numShaderSources;++i) strings[i]=va_arg(ap,const char*); /* Upload all shader source strings into the shader object: */ glShaderSourceARB(shaderObject,numShaderSources,strings,0); delete[] strings; /* Compile the shader source: */ glCompileShaderARB(shaderObject); /* Check if the shader compiled successfully: */ GLint compileStatus; glGetObjectParameterivARB(shaderObject,GL_OBJECT_COMPILE_STATUS_ARB,&compileStatus); if(!compileStatus) { /* Get some more detailed information: */ GLcharARB compileLogBuffer[2048]; GLsizei compileLogSize; glGetInfoLogARB(shaderObject,sizeof(compileLogBuffer),&compileLogSize,compileLogBuffer); /* Signal an error: */ Misc::throwStdErr("glCompileShaderFromStrings: Error \"%s\" while compiling shader",compileLogBuffer); } }
void glCompileShaderFromString(GLhandleARB shaderObject,const char* shaderSource) { /* Determine the length of the source string: */ GLint shaderSourceLength=GLint(strlen(shaderSource)); /* Upload the shader source into the shader object: */ const GLcharARB* ss=reinterpret_cast<const GLcharARB*>(shaderSource); glShaderSourceARB(shaderObject,1,&ss,&shaderSourceLength); /* Compile the shader source: */ glCompileShaderARB(shaderObject); /* Check if the shader compiled successfully: */ GLint compileStatus; glGetObjectParameterivARB(shaderObject,GL_OBJECT_COMPILE_STATUS_ARB,&compileStatus); if(!compileStatus) { /* Get some more detailed information: */ GLcharARB compileLogBuffer[2048]; GLsizei compileLogSize; glGetInfoLogARB(shaderObject,sizeof(compileLogBuffer),&compileLogSize,compileLogBuffer); /* Signal an error: */ Misc::throwStdErr("glCompileShaderFromString: Error \"%s\" while compiling shader",compileLogBuffer); } }
void GLShader::linkShader(void) { if(programObject!=0) Misc::throwStdErr("GLShader::linkShader: Attempt to link shader program multiple times"); /* Create the program object: */ programObject=glCreateProgramObjectARB(); /* Attach all previously compiled shaders to the program object: */ for(HandleList::iterator vsoIt=vertexShaderObjects.begin();vsoIt!=vertexShaderObjects.end();++vsoIt) glAttachObjectARB(programObject,*vsoIt); for(HandleList::iterator fsoIt=fragmentShaderObjects.begin();fsoIt!=fragmentShaderObjects.end();++fsoIt) glAttachObjectARB(programObject,*fsoIt); /* Link the program: */ glLinkProgramARB(programObject); /* Check if the program linked successfully: */ GLint linkStatus; glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus); if(!linkStatus) { /* Get some more detailed information: */ GLcharARB linkLogBuffer[2048]; GLsizei linkLogSize; glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer); /* Signal an error: */ Misc::throwStdErr("GLShader::linkShader: Error \"%s\" while linking shader program",linkLogBuffer); } }
void GlProgram:: compile(GLhandleARB shader, const std::string& sourceString) const { //determine the length of the source code GLint length = static_cast<GLint>(sourceString.size()); //upload the shader source into the shader object const GLcharARB* code = reinterpret_cast<const GLcharARB*>(sourceString.c_str()); glShaderSourceARB(shader, 1, &code, &length); //compile the shader source glCompileShaderARB(shader); //check if the shader compiled successfully GLint compileStatus; glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &compileStatus); if(!compileStatus) { //get some more detailed information GLcharARB compileLogBuffer[2048]; GLsizei compileLogSize; glGetInfoLogARB(shader, sizeof(compileLogBuffer), &compileLogSize, compileLogBuffer); //signal an error Misc::throwStdErr("%s", compileLogBuffer); } }
void GlProgram:: link() { //attach all previously compiled shaders to the program object for(ShaderHandle it=shaders.begin(); it!=shaders.end(); ++it) glAttachObjectARB(program, *it); //link the program glLinkProgramARB(program); //check if the program linked successfully GLint linkStatus; glGetObjectParameterivARB(program, GL_OBJECT_LINK_STATUS_ARB, &linkStatus); if (!linkStatus) { //get some more detailed information GLcharARB linkLogBuffer[2048]; GLsizei linkLogSize; glGetInfoLogARB(program, sizeof(linkLogBuffer), &linkLogSize, linkLogBuffer); //signal an error Misc::throwStdErr("GLProgram::link: Error \"%s\" while linking shader " "program", linkLogBuffer); } }
static void glsl_print_error( char *msg, GLhandleARB obj ) { char buf[MAX_ERROR_BUF]; GLsizei length; glGetInfoLogARB( obj, sizeof(buf), &length, buf ); ERROR( "%s: %s", msg, buf ); }
void LLPostProcess::checkShaderError(GLhandleARB shader) { GLint infologLength = 0; GLint charsWritten = 0; GLchar *infoLog; checkError(); // Check for OpenGL errors glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infologLength); checkError(); // Check for OpenGL errors if (infologLength > 0) { infoLog = (GLchar *)malloc(infologLength); if (infoLog == NULL) { /// Could not allocate infolog buffer return; } glGetInfoLogARB(shader, infologLength, &charsWritten, infoLog); // shaderErrorLog << (char *) infoLog << std::endl; mShaderErrorString = (char *) infoLog; free(infoLog); } checkError(); // Check for OpenGL errors }
bool ShaderGl::compile(string &messages){ assertGl(); messages= "Compiling shader: " + source.getPathInfo() + "\n"; //load source GLint length= source.getCode().size(); const GLcharARB *csource= source.getCode().c_str(); glShaderSourceARB(handle, 1, &csource, &length); //compile glCompileShaderARB(handle); //log GLint logLength= 0; glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &logLength); char *buffer= new char[logLength+1]; glGetInfoLogARB(handle, logLength+1, NULL, buffer); messages+= buffer; delete [] buffer; //status GLint status= false; glGetObjectParameterivARB(handle, GL_OBJECT_COMPILE_STATUS_ARB, &status); assertGl(); return status!=0; }
void XGLShader::printInfoLog(GLhandleARB obj) { int infologLength = 0; int charsWritten = 0; GLcharARB *infoLog; printOpenGLError(); // Check for OpenGL errors glGetObjectParameterivARB(obj, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*)&infologLength); printOpenGLError(); // Check for OpenGL errors if (infologLength > 0) { infoLog = (GLcharARB*)malloc(infologLength); if (infoLog == NULL) { printf("ERROR: Could not allocate InfoLog buffer\n"); exit(1); } glGetInfoLogARB(obj, infologLength, (GLint*)&charsWritten, infoLog); printf("InfoLog:\n%s\n\n", infoLog); free(infoLog); } printOpenGLError(); // Check for OpenGL errors }
GLuint Shader::GenerateShader(string from, GLenum type) { cout << "Compiling Shader..." << endl; string load; if(!LoadShaderFile(from,load)) { cout << "Compiling failed!" << endl; loadFailed = true; return 0; } GLuint shader = glCreateShader(type); const char *chars = load.c_str(); glShaderSource(shader, 1, &chars, NULL); glCompileShader(shader); GLint status; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status == GL_FALSE) { cout << "Compiling failed!" << endl; char error[512]; glGetInfoLogARB(shader, sizeof(error), NULL, error); cout << error; loadFailed = true; return 0; } cout << "Compiling success!" << endl << endl; loadFailed = false; return shader; }
GLuint GLUtil::CreateShader(GLenum eShaderType, const char *source) { GLuint shader = glCreateShaderObjectARB(eShaderType); glShaderSourceARB(shader, 1, (const char**)&source, NULL); glCompileShaderARB(shader); // debugging if (true) { GLchar *strInfoLog = new GLchar[1000]; GLsizei nChars; glGetInfoLogARB(shader, 999, &nChars, strInfoLog); strInfoLog[999] = '\0'; if (nChars != 0) { const char *strShaderType = NULL; switch(eShaderType) { case GL_VERTEX_SHADER: strShaderType = "Vertex"; break; case GL_GEOMETRY_SHADER: strShaderType = "Geometry"; break; case GL_FRAGMENT_SHADER: strShaderType = "Fragment"; break; } Console::getInstance()->message(CONSOLE_MSG_SYS, "%s Shader: %s", strShaderType, strInfoLog); } delete [] strInfoLog; } return shader; }
//////////////////////////////////////////////////////////////////////////////////////////////////// //! Print info log for glsl program object. The log is empty if no errors / warning occur. //! @param program_obj handle to the program / shader object //////////////////////////////////////////////////////////////////////////////////////////////////// /*static*/ void ErrorDevel::checkInfologGLSL( const unsigned int& program_obj) { // errror or only warnings bool error = false; int infolog_length; glGetObjectParameterivARB( program_obj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infolog_length); // bigger then 1 important while length('\n') == 1 if (infolog_length > 1) { char* infolog = new GLcharARB[infolog_length]; int readback_length; glGetInfoLogARB( program_obj, infolog_length, &readback_length, infolog); //std::cerr << "GLSL infolog reports:\n" << infolog << '\n' << std::endl; std::cerr << infolog << '\n' << std::endl; // check if errors occured or only warnings std::string str_infolog( infolog); error = ( std::string::npos != str_infolog.find( "error")) ? true : false; delete[] infolog; } if (error) { // call exit handler // exit exit( EXIT_SUCCESS); } }
void Shader::CompileShader() { char const * source = m_shaderSource.c_str(); glShaderSource(m_shader, 1, (const GLchar**)&source, 0); glCompileShader(m_shader); GLint isCompiled; glGetShaderiv(m_shader, GL_COMPILE_STATUS, &isCompiled); if(0 == isCompiled) { printf("Failed to compile shader!\n"); GLint blen = 0; GLsizei slen = 0; glGetShaderiv(m_shader, GL_INFO_LOG_LENGTH , &blen); if (blen > 1) { GLchar* compiler_log = (GLchar*)malloc(blen); glGetInfoLogARB(m_shader, blen, &slen, compiler_log); std::cerr << "compiler_log:\n" << compiler_log; free (compiler_log); } } }
GLuint GLUtil::CreateShaderProgram(GLuint *shaderList, int nShaders) { if (nShaders > 0) { GLuint program = glCreateProgramObjectARB(); // attach list of compiled shaders to the shader program for(size_t iLoop = 0; iLoop < nShaders; iLoop++) glAttachObjectARB(program, shaderList[iLoop]); //glBindAttribLocationARB(*program, 0, "position"); glLinkProgramARB(program); // debugging if (true) { GLchar *strInfoLog = new GLchar[1000]; GLsizei nChars; glGetInfoLogARB(program, 999, &nChars, strInfoLog); strInfoLog[999] = '\0'; if (nChars != 0) { Console::getInstance()->message(CONSOLE_MSG_SYS, "GLSL Linker: %s", strInfoLog); } delete[] strInfoLog; } // the shaders are no longer needed by the program once compiled for(size_t iLoop = 0; iLoop < nShaders; iLoop++) glDetachObjectARB(program, shaderList[iLoop]); return program; } return 0; }
GLhandleARB LoadGLSLShaderSource(GLenum ShadeType, GLcharARB *Source, char *ErrorLog, int *ErrorLength) { GLhandleARB Handle = 0; GLint Length = sizeof(Source)/sizeof(GLcharARB); if (Length == 0 || Source == NULL) return NULL; Handle = glCreateShaderObjectARB(ShadeType); glShaderSourceARB(Handle, 1, (const GLcharARB**)&Source, &Length); glCompileShaderARB(Handle); if (ErrorLog && ErrorLength) { GLint TotalLength = 0, nCharsWritten = 0; glGetObjectParameterivARB(Handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &TotalLength); if(TotalLength > 1) glGetInfoLogARB(Handle, *ErrorLength, &nCharsWritten, ErrorLog); *ErrorLength = TotalLength - 1; } return Handle; }
void ShaderProgram::initialize() { GLint status; handle = glCreateProgramObjectARB(); if (handle == 0) throw Exception("failed to create program"); // Add all shaders Shader::Iter i = shaders.begin(); for (; i != shaders.end(); ++i) { glAttachObjectARB(handle, (*i)->getHandle()); } // Link glLinkProgramARB(handle); glGetObjectParameterivARB(handle, GL_OBJECT_LINK_STATUS_ARB, &status); if (status != GL_TRUE) { std::string errors; GLint len; // Get size of info log glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &len); if (len > 1) { errors.resize(len); glGetInfoLogARB(handle, len, NULL, &errors[0]); } throw Exception("shader program link failed\n" + errors); } }
GLenum GLShader::CompileProgram(GLenum target, GLcharARB* sourcecode, GLhandleARB *shader) { GLint logLength; GLint compiled; if (sourcecode != 0) { *shader = glCreateShaderObjectARB(target); FailGLError("Failed to create fragment shader"); glShaderSourceARB(*shader,1,(const GLcharARB **)&sourcecode,0); FailGLError("Failed glShaderSourceARB"); glCompileShaderARB(*shader); FailGLError("Failed glCompileShaderARB"); glGetObjectParameterivARB(*shader,GL_OBJECT_COMPILE_STATUS_ARB,&compiled); glGetObjectParameterivARB(*shader,GL_OBJECT_INFO_LOG_LENGTH_ARB,&logLength); if (logLength) { GLcharARB *log = (GLcharARB *)malloc(logLength+128); glGetInfoLogARB(*shader, logLength, &logLength, log); //printf("Compile log: \n"); free (log); } //if (!compiled) // FailWithMessage("shader could not compile"); } return GL_NO_ERROR; }
/* ARB_shader_objects / ARB_vertex_shader / ARB_fragment_shader extensions API. */ static void compile_shader_arb (GLuint *shader, GLenum type, const char *text) { const char* strings[1] = { text }; GLint gl_status; *shader = glCreateShaderObjectARB (type); glShaderSourceARB (*shader, 1, strings, 0); glCompileShaderARB (*shader); glGetObjectParameterivARB (*shader, GL_OBJECT_COMPILE_STATUS_ARB, &gl_status); if (gl_status == GL_FALSE) { GLint log_size; glGetObjectParameterivARB (*shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &log_size); if (0 < log_size) { char *log = _cairo_malloc (log_size); GLint chars; log[log_size - 1] = '\0'; glGetInfoLogARB (*shader, log_size, &chars, log); printf ("OpenGL shader compilation failed. Shader:\n" "%s\n" "OpenGL compilation log:\n" "%s\n", text, log); free (log); } else { printf ("OpenGL shader compilation failed.\n"); } ASSERT_NOT_REACHED; } }