int compile(std::string fragmentSource){ const std::string vertexSource=""; GLuint fragmentShaderIndex = glCreateShader(GL_FRAGMENT_SHADER); const char* fragmentSourceStr = fragmentSource.c_str(); int fragmentSourceLen = fragmentSource.length(); glShaderSourceARB(fragmentShaderIndex, 1, &(fragmentSourceStr), &(fragmentSourceLen)); glCompileShader(fragmentShaderIndex); printShaderInfoLog(fragmentShaderIndex); GLuint programIndex = glCreateProgram(); glAttachShader(programIndex, fragmentShaderIndex); glLinkProgram(programIndex); printProgramInfoLog(programIndex); return programIndex; }
//----------------------------------------------------------------------- void GLSLProgram::loadFromSource(void) { // only create a shader object if glsl is supported if (isSupported()) { checkForGLSLError( "GLSLProgram::GLSLProgram", "GL Errors before creating shader object", 0 ); // create shader object mGLHandle = glCreateShaderObjectARB( (mType == GPT_VERTEX_PROGRAM) ? GL_VERTEX_SHADER_ARB : GL_FRAGMENT_SHADER_ARB ); checkForGLSLError( "GLSLProgram::GLSLProgram", "Error creating GLSL shader Object", 0 ); } const char* SLSource = mSource.c_str(); glShaderSourceARB(mGLHandle, 1, &SLSource, NULL); // check for load errors checkForGLSLError( "GLSLProgram::loadFromSource", "Cannot load GLSL high-level shader source : " + mName, 0 ); compile(); }
void CompileProgram(GLcharARB* sourcecode, GLhandleARB *shader) { GLint logLength; GLint compiled; glShaderSourceARB(*shader,1,(const GLcharARB **)&sourcecode,0); HandleGLError("Failed glShaderSourceARB"); glCompileShaderARB(*shader); HandleGLError("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) { std::cout << "shader could not compile" << std::endl; exit(0); } }
bool GlslProgram :: loadShader ( GLhandleARB shader, Data * data ) { const char * body = (const char *) data -> getPtr ( 0 ); GLint len = data -> getLength (); GLint compileStatus; glShaderSourceARB ( shader, 1, &body, &len ); // compile the particle vertex shader, and print out glCompileShaderARB ( shader ); if ( !checkGlError() ) // check for OpenGL errors return false; glGetObjectParameterivARB ( shader, GL_OBJECT_COMPILE_STATUS_ARB, &compileStatus ); loadLog ( shader ); return compileStatus != 0; }
GLhandleARB GLSL_CompileShader(const char* shaderfilename,unsigned int ShaderObject) { GLhandleARB GLSLShaderObject=0; GLSLShaderObject=glCreateShaderObjectARB(ShaderObject); unsigned char *ShaderAssembly = readShaderFile( shaderfilename ); const char *ShaderStrings[1]; ShaderStrings[0] = (char*)ShaderAssembly; glShaderSourceARB( GLSLShaderObject, 1, ShaderStrings, NULL ); glCompileShaderARB( GLSLShaderObject); //delete [] ShaderAssembly; GLint bCompiled=0; glGetObjectParameterivARB( GLSLShaderObject, GL_OBJECT_COMPILE_STATUS_ARB, &bCompiled ); if( bCompiled == false ) { char str[4096]; glGetInfoLogARB(GLSLShaderObject, sizeof(str), NULL, str); MessageBox( NULL, str, "Shader Compile Error", MB_OK|MB_ICONEXCLAMATION ); //MessageBox( NULL, "请尝试降低阴影设置,否则程序无法正常运行", "注意", MB_OK|MB_ICONEXCLAMATION ); } return GLSLShaderObject; }
//----------------------------------------------------------------------------- bool LoadShader(char *file, GLenum type, GLhandleARB context) { // GLSL shader. GLhandleARB shader; // Load shader's source text. char *code = LoadText(file); if(code == NULL) return false; // Create the shader from a text file. shader = glCreateShaderObjectARB(type); glShaderSourceARB(shader, 1, (const char**)&code, NULL); glCompileShaderARB(shader); GLint result; char error[1024]; // Returns the results of the shader compilation. glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &result); delete[] code; // Display shader errors if any. if(!result) { // Get the error message and display it. glGetInfoLogARB(shader, sizeof(error), NULL, error); printf("Error in %s...\n%s\n", file, error); return false; } // Attach to the effect's context. glAttachObjectARB(context, shader); glDeleteObjectARB(shader); return true; }
//-------------------------------------------------------------------------------------- // Método para cargar un shader en la memoria de la tarjeta. //-------------------------------------------------------------------------------------- bool CShaderObject::Load (const char * path, GLenum type) { appResetLastError(); FILE * file = fopen(path, "r"); if(file == NULL) return appSetLastError(SHAERR_SHAOBJ_FOPENFILE); string source = ""; char aux; fread(&aux, sizeof(char), 1, file); while(!feof(file)) { source += aux; fread(&aux, sizeof(char), 1, file); } fclose(file); if(!source.length()) return appSetLastError(SHAERR_SHAOBJ_EMPTYFILE); this->shader = glCreateShaderObjectARB(type); if(!this->shader) return appSetLastError(SHAERR_SHAOBJ_CREATESHADEROBJECT); const char * srcstr = source.c_str(); int len = source.length(); glShaderSourceARB(this->shader, 1, &srcstr, &len); glCompileShaderARB(this->shader); int cmperr; glGetObjectParameterivARB(this->shader, GL_OBJECT_COMPILE_STATUS_ARB, &cmperr); if(cmperr == 0) return appSetLastError(SHAERR_SHAOBJ_COMPILESHADER); return true; }
GLhandleARB LoadGLSLShader(GLenum ShadeType, const char *SourceFile, char *ErrorLog, int *ErrorLength) { GLhandleARB Handle = 0; FILE *InFile = fopen(SourceFile, "rt"); if (InFile == NULL) { printf("could not find file %s\n", SourceFile); return false; } GLint Length = (GLint)fsize(InFile); GLcharARB *Shader = new char[Length + 1]; if (Length == 0 || Shader == NULL) return NULL; Length = (GLint)fread(Shader, sizeof(GLcharARB), Length, InFile); Shader[Length] = '\0'; fclose(InFile); Handle = glCreateShaderObjectARB(ShadeType); glShaderSourceARB(Handle, 1, (const GLcharARB**)&Shader, &Length); glCompileShaderARB(Handle); delete [] Shader; 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; }
static void load_test_file (const char *filename) { FILE *f; GLint size; char *code; GLint i; f = fopen (filename, "r"); if (f == NULL) return; fseek (f, 0, SEEK_END); size = ftell (f); if (size == -1) { fclose (f); return; } fseek (f, 0, SEEK_SET); code = (char *) (malloc (size)); if (code == NULL) { fclose (f); return; } size = fread (code, 1, size, f); fclose (f); glShaderSourceARB (vert, 1, (const GLcharARB **) (&code), &size); glCompileShaderARB (vert); if (!CheckObjectStatus (vert)) exit (0); for (i = 0; i < sizeof (attribs) / sizeof (*attribs); i++) if (attribs[i].dispatch == A && attribs[i].bind != -1) glBindAttribLocationARB (prog, attribs[i].bind, attribs[i].name); }
GLShader::GLShader(const QString& fileName, GLenum shaderType) : m_compileError(false), m_failed(false) { GLSHADERS_ASSERT_OPENGL("GLShader::GLShader", glCreateShaderObjectARB && glShaderSourceARB && glCompileShaderARB && glGetObjectParameterivARB, return) m_shader = glCreateShaderObjectARB(shaderType); QFile file(fileName); if (file.open(QIODevice::ReadOnly)) { QByteArray bytes = file.readAll(); GLint size = file.size(); const char *p = bytes.data(); file.close(); glShaderSourceARB(m_shader, 1, reinterpret_cast<const GLcharARB**>(&p), &size); glCompileShaderARB(m_shader); int status; glGetObjectParameterivARB(m_shader, GL_OBJECT_COMPILE_STATUS_ARB, &status); m_compileError = (status != 1); } else { m_compileError = true; } }
void Shader::load(const std::string& fname) { std::ifstream file; std::string code; printf("loading shader %s\n", fname.c_str()); file.open(fname.c_str(), std::ios::in); if (!file) { throw Exception("failed to open " + fname); } file.seekg(0, std::ios::end); code.resize(file.tellg()); file.seekg(0, std::ios::beg); file.read(&code[0], code.size()); file.close(); const char* str = code.c_str(); glShaderSourceARB(handle, 1, &str, NULL); compile(); }
GLuint Painter::compileShader(const char* shader, GLenum type) { GLuint shaderId = glCreateShader(type); glShaderSourceARB(shaderId, 1, &shader, NULL); glCompileShader(shaderId); GLint success = 0; glGetShaderiv(shaderId, GL_COMPILE_STATUS, &success); if (success == GL_FALSE) { fprintf(stderr, "Failed to compile shader!\n%s\n", shader); GLint maxLength = 0; glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &maxLength); std::vector<GLchar> errorLog(maxLength); glGetShaderInfoLog(shaderId, maxLength, &maxLength, &errorLog[0]); fprintf(stderr, "%s\n", &errorLog[0]); glDeleteShader(shaderId); } return shaderId; }
bool glsl_vertex :: 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; } if(m_shaderARB) { t_atom a; gem::utils::glsl::atom_setshader(a, m_shaderARB); outlet_list(m_outShaderID, gensym("list"), 1, &a); } return true; }
GLhandleARB C4Shader::Create(GLenum iShaderType, const char *szWhat, const char *szShader) { // Create shader GLhandleARB hShader = glCreateShaderObjectARB(iShaderType); #ifdef GL_KHR_debug if (glObjectLabel) glObjectLabel(GL_SHADER, hShader, -1, szWhat); #endif // Compile glShaderSourceARB(hShader, 1, &szShader, 0); glCompileShaderARB(hShader); // Dump any information to log DumpInfoLog(szWhat, hShader); // Success? if(GetObjectStatus(hShader, GL_OBJECT_COMPILE_STATUS_ARB) == 1) return hShader; // Did not work :/ glDeleteObjectARB(hShader); return 0; }
void GLShader::loadShader(GLhandleARB shaderObject,const char* shaderSourceFileName) { /* Open the source file: */ Misc::File shaderSourceFile(shaderSourceFileName,"rt"); /* Determine the length of the source file: */ shaderSourceFile.seekEnd(0); GLint shaderSourceLength=GLint(shaderSourceFile.tell()); shaderSourceFile.seekSet(0); /* Read the shader source: */ GLcharARB* shaderSource=new GLcharARB[shaderSourceLength]; shaderSourceFile.read<GLcharARB>(shaderSource,shaderSourceLength); /* Upload the shader source into the shader object: */ const GLcharARB* ss=shaderSource; glShaderSourceARB(shaderObject,1,&ss,&shaderSourceLength); delete[] shaderSource; /* 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("%s",compileLogBuffer); } }
/// This function compiles a shader and check the log bool GLSLShader::CompileShader(GLint target, const std::string& fileName, const std::string& header) { std::string source = LoadTextFile(fileName); std::string shaderStage = GetShaderStageName(target); source = CombineHeaders(header, shaderStage + std::string("Shader"), source); GLhandleARB shader = glCreateShaderObjectARB(target); const char* src = source.c_str(); glShaderSourceARB(shader, 1, &src, NULL); glCompileShaderARB(shader); GLint compiled = 0, length = 0, laux = 0; glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &compiled); if (!compiled) std::cerr << "ERROR: Compilation of "<<shaderStage<<" shader failed:"<<std::endl; // else std::cout << "Compilation of "<<shaderStage<<" shader OK" << std::endl; glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length); if (length > 1) { std::cerr << "File: " << fileName << std::endl; if (!header.empty()) std::cerr << "Header:\n" << header << std::endl; GLcharARB *logString = (GLcharARB *)malloc((length+1) * sizeof(GLcharARB)); glGetInfoLogARB(shader, length, &laux, logString); std::cerr << logString << std::endl; free(logString); } if (compiled) m_hShaders[target] = shader; else glDeleteObjectARB(shader); return (compiled!=0); }
int main(int argc, char **argv) { float r = 0.5, g = 0.5, b = 1, ratio = 0; int dir = 1; ALLEGRO_DISPLAY *display; ALLEGRO_BITMAP *mysha; ALLEGRO_BITMAP *buffer; const char *tinter_shader_src[] = { "uniform sampler2D backBuffer;", "uniform float r;", "uniform float g;", "uniform float b;", "uniform float ratio;", "void main() {", " vec4 color;", " float avg, dr, dg, db;", " color = texture2D(backBuffer, gl_TexCoord[0].st);", " avg = (color.r + color.g + color.b) / 3.0;", " dr = avg * r;", " dg = avg * g;", " db = avg * b;", " color.r = color.r - (ratio * (color.r - dr));", " color.g = color.g - (ratio * (color.g - dg));", " color.b = color.b - (ratio * (color.b - db));", " gl_FragColor = color;", "}" }; const int TINTER_LEN = 18; double start; GLint loc; (void)argc; (void)argv; if (!al_init()) { abort_example("Could not init Allegro\n"); } al_install_keyboard(); al_init_image_addon(); al_set_new_display_flags(ALLEGRO_OPENGL); display = al_create_display(320, 200); if (!display) { abort_example("Error creating display\n"); } mysha = al_load_bitmap("data/mysha.pcx"); if (!mysha) { abort_example("Could not load image.\n"); } buffer = al_create_bitmap(320, 200); if (!al_have_opengl_extension("GL_EXT_framebuffer_object") && !al_have_opengl_extension("GL_ARB_fragment_shader")) { abort_example("Fragment shaders not supported.\n"); } tinter_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); glShaderSourceARB(tinter_shader, TINTER_LEN, tinter_shader_src, NULL); glCompileShaderARB(tinter_shader); tinter = glCreateProgramObjectARB(); glAttachObjectARB(tinter, tinter_shader); glLinkProgramARB(tinter); loc = glGetUniformLocationARB(tinter, "backBuffer"); glUniform1iARB(loc, al_get_opengl_texture(buffer)); start = al_get_time(); while (1) { double now, diff; ALLEGRO_KEYBOARD_STATE state; al_get_keyboard_state(&state); if (al_key_down(&state, ALLEGRO_KEY_ESCAPE)) { break; } now = al_get_time(); diff = now - start; start = now; ratio += diff * 0.5 * dir; if (dir < 0 && ratio < 0) { ratio = 0; dir = -dir; } else if (dir > 0 && ratio > 1) { ratio = 1; dir = -dir; } al_set_target_bitmap(buffer); glUseProgramObjectARB(tinter); loc = glGetUniformLocationARB(tinter, "ratio"); glUniform1fARB(loc, ratio); loc = glGetUniformLocationARB(tinter, "r"); glUniform1fARB(loc, r); loc = glGetUniformLocationARB(tinter, "g"); glUniform1fARB(loc, g); loc = glGetUniformLocationARB(tinter, "b"); glUniform1fARB(loc, b); al_draw_bitmap(mysha, 0, 0, 0); glUseProgramObjectARB(0); al_set_target_backbuffer(display); al_draw_bitmap(buffer, 0, 0, 0); al_flip_display(); al_rest(0.001); } glDetachObjectARB(tinter, tinter_shader); glDeleteObjectARB(tinter_shader); al_uninstall_system(); return 0; }
int XGLShader::compileShaders( const char *shdrVertex, const char *shdrFragment ) { GLhandleARB shdrVS, shdrFS;//, shdrProg; // handles to objects GLint vertCompiled, fragCompiled; // status values GLint linked; // Create a vertex shader object and a fragment shader object shdrVS = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); shdrFS = glCreateShaderObjectARB(GL_FRAGMENT_SHADER); // Load source code strings into shaders glShaderSourceARB(shdrVS, 1, &shdrVertex, NULL); glShaderSourceARB(shdrFS, 1, &shdrFragment, NULL); // Compile the shdr vertex shader and print out // the compiler log file. glCompileShaderARB(shdrVS); printOpenGLError(); // Check for OpenGL errors glGetObjectParameterivARB(shdrVS, GL_OBJECT_COMPILE_STATUS_ARB, &vertCompiled); this->printInfoLog(shdrVS); // Compile the shdr vertex shader and print out // the compiler log file. glCompileShaderARB(shdrFS); printOpenGLError(); // Check for OpenGL errors glGetObjectParameterivARB(shdrFS, GL_OBJECT_COMPILE_STATUS_ARB, &fragCompiled); this->printInfoLog(shdrFS); if (!vertCompiled || !fragCompiled) return 0; // Create a program object and attach the two compiled shaders this->sp = glCreateProgramObjectARB(); glAttachObjectARB(this->sp, shdrVS); glAttachObjectARB(this->sp, shdrFS); // Link the program object and print out the info log glLinkProgramARB(this->sp); printOpenGLError(); // Check for OpenGL errors glGetObjectParameterivARB(this->sp, GL_OBJECT_LINK_STATUS_ARB, &linked); this->printInfoLog(this->sp); if (!linked) return 0; // Install program object as part of current state //glUseProgramObjectARB(shdrProg); // Set up initial uniform values //glUniform3fARB( getUniLoc(shdrProg, "BrickColor"), 1.0, 0.3, 0.2); //glUniform3fARB( getUniLoc(shdrProg, "MortarColor"), 0.85, 0.86, 0.84); //glUniform2fARB( getUniLoc(shdrProg, "BrickSize"), 0.30, 0.15); //glUniform2fARB( getUniLoc(shdrProg, "BrickPct"), 0.90, 0.85); //glUniform3fARB( getUniLoc(shdrProg, "LightPosition"), 0.0, 0.0, 4.0); this->validShader = 1; return 1; }
static void R_BuildGammaProgram(void) { GLint compiled; gammaProgram.vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); gammaProgram.fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); glShaderSourceARB(gammaProgram.vertexShader, 1, (const GLcharARB **)&simpleGammaVert, NULL); glShaderSourceARB(gammaProgram.fragmentShader, 1, (const GLcharARB **)&simpleGammaFrag, NULL); glCompileShaderARB(gammaProgram.vertexShader); glCompileShaderARB(gammaProgram.fragmentShader); glGetObjectParameterivARB(gammaProgram.vertexShader, GL_COMPILE_STATUS, &compiled); if (!compiled) { GLint blen = 0; GLsizei slen = 0; glGetShaderiv(gammaProgram.vertexShader, GL_INFO_LOG_LENGTH, &blen); if (blen > 1) { GLchar *compiler_log; compiler_log = (GLchar *) malloc(blen); glGetInfoLogARB(gammaProgram.vertexShader, blen, &slen, compiler_log); Ren_Fatal("Failed to compile the gamma vertex shader reason: %s\n", compiler_log); } else { Ren_Fatal("Failed to compile the gamma vertex shader\n"); } } glGetObjectParameterivARB(gammaProgram.fragmentShader, GL_COMPILE_STATUS, &compiled); if (!compiled) { Ren_Fatal("Failed to compile the gamma fragment shader\n"); } gammaProgram.program = glCreateProgramObjectARB(); if (!gammaProgram.program) { Ren_Fatal("Failed to create program\n"); } glAttachObjectARB(gammaProgram.program, gammaProgram.vertexShader); glAttachObjectARB(gammaProgram.program, gammaProgram.fragmentShader); glLinkProgramARB(gammaProgram.program); glGetProgramivARB(gammaProgram.program, GL_LINK_STATUS, &compiled); // this throws glGetError() = 0x500 if (!compiled) { Ren_Fatal("Failed to link gamma shaders\n"); } glUseProgramObjectARB(gammaProgram.program); gammaProgram.currentMapUniform = glGetUniformLocation(gammaProgram.program, "u_CurrentMap"); gammaProgram.gammaUniform = glGetUniformLocation(gammaProgram.program, "u_gamma"); glUseProgramObjectARB(0); }
GLhandleARB loadShaderFromFile(char* filename, unsigned int type) { FILE *pfile; GLhandleARB handle; const GLcharARB* files[1]; // shader Compilation variable GLint result; // Compilation code result GLint errorLoglength; char* errorLogText; GLsizei actualErrorLogLength; char buffer[400000]; memset(buffer, 0, 400000); // This will raise a warning on MS compiler pfile = fopen(filename, "rb"); if (!pfile) { printf("Sorry, can't open file: '%s'.\n", filename); exit(0); } fread(buffer, sizeof(char), 400000, pfile); //printf("%s\n",buffer); fclose(pfile); handle = glCreateShaderObjectARB(type); if (!handle) { //We have failed creating the vertex shader object. printf("Failed creating vertex shader object from file: %s.", filename); exit(0); } files[0] = (const GLcharARB*)buffer; glShaderSourceARB( handle, //The handle to our shader 1, //The number of files. files, //An array of const char * data, which represents the source code of theshaders NULL); glCompileShaderARB(handle); //Compilation checking. glGetObjectParameterivARB(handle, GL_OBJECT_COMPILE_STATUS_ARB, &result); // If an error was detected. if (!result) { //We failed to compile. printf("Shader '%s' failed compilation.\n", filename); //Attempt to get the length of our error log. glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &errorLoglength); //Create a buffer to read compilation error message errorLogText = (char*)malloc(sizeof(char)* errorLoglength); //Used to get the final length of the log. glGetInfoLogARB(handle, errorLoglength, &actualErrorLogLength, errorLogText); // Display errors. printf("%s\n", errorLogText); // Free the buffer malloced earlier free(errorLogText); } printf("Shader loaded done\n"); return handle; }
implementation(const std::string& vertex_source_str, const std::string& fragment_source_str) : program_(0) { GLint success; const char* vertex_source = vertex_source_str.c_str(); auto vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); GL(glShaderSourceARB(vertex_shader, 1, &vertex_source, NULL)); GL(glCompileShaderARB(vertex_shader)); GL(glGetObjectParameterivARB(vertex_shader, GL_OBJECT_COMPILE_STATUS_ARB, &success)); if (success == GL_FALSE) { char info[2048]; GL(glGetInfoLogARB(vertex_shader, sizeof(info), 0, info)); GL(glDeleteObjectARB(vertex_shader)); std::stringstream str; str << "Failed to compile vertex shader:" << std::endl << info << std::endl; BOOST_THROW_EXCEPTION(caspar_exception() << msg_info(str.str())); } const char* fragment_source = fragment_source_str.c_str(); auto fragmemt_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); GL(glShaderSourceARB(fragmemt_shader, 1, &fragment_source, NULL)); GL(glCompileShaderARB(fragmemt_shader)); GL(glGetObjectParameterivARB(fragmemt_shader, GL_OBJECT_COMPILE_STATUS_ARB, &success)); if (success == GL_FALSE) { char info[2048]; GL(glGetInfoLogARB(fragmemt_shader, sizeof(info), 0, info)); GL(glDeleteObjectARB(fragmemt_shader)); std::stringstream str; str << "Failed to compile fragment shader:" << std::endl << info << std::endl; BOOST_THROW_EXCEPTION(caspar_exception() << msg_info(str.str())); } program_ = glCreateProgramObjectARB(); GL(glAttachObjectARB(program_, vertex_shader)); GL(glAttachObjectARB(program_, fragmemt_shader)); GL(glLinkProgramARB(program_)); GL(glDeleteObjectARB(vertex_shader)); GL(glDeleteObjectARB(fragmemt_shader)); GL(glGetObjectParameterivARB(program_, GL_OBJECT_LINK_STATUS_ARB, &success)); if (success == GL_FALSE) { char info[2048]; GL(glGetInfoLogARB(program_, sizeof(info), 0, info)); GL(glDeleteObjectARB(program_)); std::stringstream str; str << "Failed to link shader program:" << std::endl << info << std::endl; BOOST_THROW_EXCEPTION(caspar_exception() << msg_info(str.str())); } GL(glUseProgramObjectARB(program_)); }
GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, const char *libcode, const char *defines) { 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"); if (vertexcode) shader->vertex = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); if (fragcode) shader->fragment = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); shader->object = glCreateProgramObjectARB(); if (!shader->object || (vertexcode && !shader->vertex) || (fragcode && !shader->fragment)) { fprintf(stderr, "GPUShader, object creation failed.\n"); GPU_shader_free(shader); return NULL; } if (vertexcode) { const char *source[4]; int num_source = 0; source[num_source++] = gpu_shader_standard_extensions(); source[num_source++] = gpu_shader_standard_defines(); if (defines) source[num_source++] = defines; if (vertexcode) source[num_source++] = vertexcode; glAttachObjectARB(shader->object, shader->vertex); glShaderSourceARB(shader->vertex, num_source, source, NULL); glCompileShaderARB(shader->vertex); glGetObjectParameterivARB(shader->vertex, GL_OBJECT_COMPILE_STATUS_ARB, &status); if (!status) { glGetInfoLogARB(shader->vertex, sizeof(log), &length, log); shader_print_errors("compile", log, vertexcode); GPU_shader_free(shader); return NULL; } } if (fragcode) { const char *source[5]; int num_source = 0; source[num_source++] = gpu_shader_standard_extensions(); source[num_source++] = gpu_shader_standard_defines(); if (defines) source[num_source++] = defines; if (libcode) source[num_source++] = libcode; if (fragcode) source[num_source++] = fragcode; glAttachObjectARB(shader->object, shader->fragment); glShaderSourceARB(shader->fragment, num_source, source, NULL); glCompileShaderARB(shader->fragment); glGetObjectParameterivARB(shader->fragment, GL_OBJECT_COMPILE_STATUS_ARB, &status); if (!status) { glGetInfoLogARB(shader->fragment, sizeof(log), &length, log); shader_print_errors("compile", log, fragcode); GPU_shader_free(shader); return NULL; } } #if 0 if (lib && lib->lib) glAttachObjectARB(shader->object, lib->lib); #endif glLinkProgramARB(shader->object); glGetObjectParameterivARB(shader->object, GL_OBJECT_LINK_STATUS_ARB, &status); if (!status) { glGetInfoLogARB(shader->object, sizeof(log), &length, log); if (fragcode) shader_print_errors("linking", log, fragcode); else if (vertexcode) shader_print_errors("linking", log, vertexcode); else if (libcode) shader_print_errors("linking", log, libcode); GPU_shader_free(shader); return NULL; } return shader; }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBShaderObjects_nglShaderSourceARB(JNIEnv *env, jclass clazz, jint shader, jint count, jobject string, jint string_position, jint length, jlong function_pointer) { const GLcharARB *string_address = ((const GLcharARB *)(*env)->GetDirectBufferAddress(env, string)) + string_position; glShaderSourceARBPROC glShaderSourceARB = (glShaderSourceARBPROC)((intptr_t)function_pointer); glShaderSourceARB(shader, count, (const GLcharARB **)&string_address, (const GLint*)&length); }
bool Shader::compile(const char* vertexShaderCode, const char* fragmentShaderCode) { ensureGlContext(); // First make sure that we can use shaders if (!isAvailable()) { err() << "Failed to create a shader: your system doesn't support shaders " << "(you should test Shader::isAvailable() before trying to use the Shader class)" << std::endl; return false; } // Destroy the shader if it was already created if (m_shaderProgram) glCheck(glDeleteObjectARB(m_shaderProgram)); // Create the program m_shaderProgram = glCreateProgramObjectARB(); // Create the vertex shader if needed if (vertexShaderCode) { // Create and compile the shader GLhandleARB vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); glCheck(glShaderSourceARB(vertexShader, 1, &vertexShaderCode, NULL)); glCheck(glCompileShaderARB(vertexShader)); // Check the compile log GLint success; glCheck(glGetObjectParameterivARB(vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &success)); if (success == GL_FALSE) { char log[1024]; glCheck(glGetInfoLogARB(vertexShader, sizeof(log), 0, log)); err() << "Failed to compile vertex shader:" << std::endl << log << std::endl; glCheck(glDeleteObjectARB(vertexShader)); glCheck(glDeleteObjectARB(m_shaderProgram)); m_shaderProgram = 0; return false; } // Attach the shader to the program, and delete it (not needed anymore) glCheck(glAttachObjectARB(m_shaderProgram, vertexShader)); glCheck(glDeleteObjectARB(vertexShader)); } // Create the fragment shader if needed if (fragmentShaderCode) { // Create and compile the shader GLhandleARB fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); glCheck(glShaderSourceARB(fragmentShader, 1, &fragmentShaderCode, NULL)); glCheck(glCompileShaderARB(fragmentShader)); // Check the compile log GLint success; glCheck(glGetObjectParameterivARB(fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &success)); if (success == GL_FALSE) { char log[1024]; glCheck(glGetInfoLogARB(fragmentShader, sizeof(log), 0, log)); err() << "Failed to compile fragment shader:" << std::endl << log << std::endl; glCheck(glDeleteObjectARB(fragmentShader)); glCheck(glDeleteObjectARB(m_shaderProgram)); m_shaderProgram = 0; return false; } // Attach the shader to the program, and delete it (not needed anymore) glCheck(glAttachObjectARB(m_shaderProgram, fragmentShader)); glCheck(glDeleteObjectARB(fragmentShader)); } // Link the program glCheck(glLinkProgramARB(m_shaderProgram)); // Check the link log GLint success; glCheck(glGetObjectParameterivARB(m_shaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success)); if (success == GL_FALSE) { char log[1024]; glCheck(glGetInfoLogARB(m_shaderProgram, sizeof(log), 0, log)); err() << "Failed to link shader:" << std::endl << log << std::endl; glCheck(glDeleteObjectARB(m_shaderProgram)); m_shaderProgram = 0; return false; } return true; }
bool Shader::compile(){ const char * ff = mFragText.c_str(); const char * vv = mVertText.c_str(); //printf("Fragment: %s\n", ff); //printf("Vertex: %s\n", vv); char infobuffer[16385]; GLsizei infobufferlen = 0; if(mVertText != ""){ glShaderSourceARB(mVert, 1, &vv,NULL); glCompileShaderARB(mVert); } if(mFragText != ""){ glShaderSourceARB(mFrag, 1, &ff,NULL); glCompileShaderARB(mFrag); } mProgram = glCreateProgramObjectARB(); if(mFragText != "") glAttachObjectARB(mProgram, mFrag); if(mVertText != "") glAttachObjectARB(mProgram, mVert); GLint compiled, linked; glGetObjectParameterivARB(mVert, GL_COMPILE_STATUS, &compiled); if (!compiled && mVertText != "") { glGetInfoLogARB(mVert, 16384, &infobufferlen, infobuffer); infobuffer[infobufferlen] = 0; ERR("Couldn't compile vertex shader: \n%s\n", infobuffer); return false; } glGetObjectParameterivARB(mFrag, GL_COMPILE_STATUS, &compiled); if (!compiled && mFragText != "") { glGetInfoLogARB(mFrag, 16384, &infobufferlen, infobuffer); infobuffer[infobufferlen] = 0; ERR("Couldn't compile fragment shader: \n%s\n", infobuffer); return false; } glLinkProgramARB(mProgram); //glGetProgramiv(mProgram, GL_LINK_STATUS, &linked); glGetObjectParameterivARB(mProgram, GL_OBJECT_LINK_STATUS_ARB, &linked); if (!linked) { glGetInfoLogARB(mProgram, 16384, &infobufferlen, infobuffer); infobuffer[infobufferlen] = 0; ERR("Couldn't link shader: \n%s\n", infobuffer); return false; } //Log::debug("Compiled shader!\n"); bIsCompiled = true; return true; }
/*************************************************************************** setShader ****************************************************************************/ void setShader(){ GLhandleARB my_program; GLhandleARB my_vertex_shader; GLhandleARB my_fragment_shader; GLsizei* elength = E_MALLOC(sizeof(GLint)); GLchar* infolog = E_MALLOC(5000*sizeof(GLchar)); // Create Shader And Program Objects my_program = glCreateProgramObjectARB(); my_vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); my_fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); // Load Shader Sources GLcharARB* vertsrc; GLcharARB* fragsrc; switch(shademode){ case GOOCH_SHADER: vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/gooch.vert"); fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/gooch.frag"); break; case PHONG_SHADER: vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/phong-use-diffuse.vert"); fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/phong-use-diffuse.frag"); break; case LATTICE_SHADER: vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/CH11-lattice.vert.txt"); fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/CH11-lattice.frag.txt"); break; case PPL2_SHADER: vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/per-pixel-lighting.vert"); fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/per-pixel-lighting.frag"); break; case TEST_SHADER: vertsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/CH14-chromaticAb.vert.txt"); fragsrc = readShaderSrc("/Users/tom/Desktop/all_shaders/CH14-chromaticAb.frag.txt"); break; } glShaderSourceARB(my_vertex_shader, 1, &vertsrc, NULL); glShaderSourceARB(my_fragment_shader, 1, &fragsrc, NULL); // Compile The Shaders glCompileShaderARB(my_vertex_shader); GLint blen = 0; GLint slen = 0; GLchar* compiler_log; glGetObjectParameterivARB(my_vertex_shader, GL_OBJECT_INFO_LOG_LENGTH_ARB , &blen); if (blen > 1) { if ((compiler_log = (GLcharARB*)E_MALLOC(blen)) == NULL) { printf("OOM\n"); } glGetInfoLogARB(my_vertex_shader, blen, &slen, compiler_log); if (compiler_log!=0) { printf("compiler_log: %s\n", compiler_log); free(compiler_log); } } glCompileShaderARB(my_fragment_shader); glGetObjectParameterivARB(my_fragment_shader, GL_OBJECT_INFO_LOG_LENGTH_ARB , &blen); if (blen > 1) { if ((compiler_log = (GLcharARB*)E_MALLOC(blen)) == NULL) { printf("OOM\n"); } glGetInfoLogARB(my_fragment_shader, blen, &slen, compiler_log); if (compiler_log!=0) { printf("compiler_log: %s\n", compiler_log); free(compiler_log); } } // Attach The Shader Objects To The Program Object glAttachObjectARB(my_program, my_vertex_shader); glAttachObjectARB(my_program, my_fragment_shader); glGetObjectParameterivARB(my_program, GL_OBJECT_INFO_LOG_LENGTH_ARB , elength); if (elength > 0){ glGetInfoLogARB(my_program, 500, elength, infolog); printf("%s\n", infolog); } // Link The Program Object glLinkProgramARB(my_program); glGetObjectParameterivARB(my_program, GL_OBJECT_INFO_LOG_LENGTH_ARB , elength); if (elength > 0){ glGetInfoLogARB(my_program, 500, elength, infolog); printf("%s\n", infolog); } glValidateProgramARB(my_program); if(GL_VALIDATE_STATUS){ // Use The Program Object Instead Of Fixed Function OpenGL glUseProgramObjectARB(my_program); if(shademode == GOOCH_SHADER){ // set gooch shader parameters GLint loc; GLfloat vs[]={0.75, 0.75, 0.75}; loc = glGetUniformLocationARB(my_program, "SurfaceColor"); glUniform3fv(loc, 1, vs); GLfloat vw[]={0.6, 0.6, 0.0}; loc = glGetUniformLocationARB(my_program, "WarmColor"); glUniform3fv(loc, 1, vw); GLfloat vc[]={0.0, 0.0, 0.6}; loc = glGetUniformLocationARB(my_program, "CoolColor"); glUniform3fv(loc, 1, vc); loc = glGetUniformLocationARB(my_program, "DiffuseWarm"); glUniform1f(loc, 0.45); loc = glGetUniformLocationARB(my_program, "DiffuseCool"); glUniform1f(loc, 0.40); } if(shademode == LATTICE_SHADER){ // set gooch shader parameters GLint loc; GLfloat vs[]={10.00, 100.0, 0.0}; loc = glGetUniformLocationARB(my_program, "LightPosition"); glUniform3fv(loc, 1, vs); GLfloat vw[]={0.6, 0.6, 0.0}; loc = glGetUniformLocationARB(my_program, "LightColor"); glUniform3fv(loc, 1, vw); GLfloat vc[]={0.0, 0.0, 100.0}; loc = glGetUniformLocationARB(my_program, "EyePosition"); glUniform3fv(loc, 1, vc); GLfloat vd[]={0.5, 0.5, 0.5}; loc = glGetUniformLocationARB(my_program, "Specular"); glUniform3fv(loc, 1, vd); GLfloat ve[]={1.0, 1.0, 1.0}; loc = glGetUniformLocationARB(my_program, "Ambient"); glUniform3fv(loc, 1, ve); loc = glGetUniformLocationARB(my_program, "Kd"); glUniform1f(loc, 0.40); GLfloat vf[]={20.0, 20.0}; loc = glGetUniformLocationARB(my_program, "Scale"); glUniform2fv(loc, 1, vf); GLfloat vg[]={0.3, 0.3}; loc = glGetUniformLocationARB(my_program, "Threshold"); glUniform2fv(loc, 1, vg); GLfloat vh[]={0.5, 0.5, 0.5}; loc = glGetUniformLocationARB(my_program, "SurfaceColor"); glUniform3fv(loc, 1, vh); } } glGetObjectParameterivARB(my_program, GL_OBJECT_INFO_LOG_LENGTH_ARB , elength); if (elength > 0){ glGetInfoLogARB(my_program, 500, elength, infolog); printf("%s\n", infolog); } }
//--------------------------------------------------------------- void ofxShader::loadShader(string fragmentName, string vertexName){ fragmentName = ofToDataPath(fragmentName); vertexName = ofToDataPath(vertexName); bLoaded = false; if (GLEE_ARB_shader_objects){ // ---------------------------------- (a) load in the shaders char *vs = NULL,*fs = NULL; vs = LoadShaderText(vertexName.c_str()); fs = LoadShaderText(fragmentName.c_str()); vertexShader = (GLhandleARB)glCreateShader(GL_VERTEX_SHADER); fragmentShader = (GLhandleARB)glCreateShader(GL_FRAGMENT_SHADER); if( vs == NULL || fs == NULL ){ printf("unable to load %s \n", vertexName.c_str()); return; } GLint length = strlen(vs); glShaderSourceARB(vertexShader, 1, (const char**)&vs, &length); length = strlen(fs); glShaderSourceARB(fragmentShader, 1, (const char**)&fs, &length); char infobuffer[1000]; GLsizei infobufferlen = 0; // ----------------------------------- (b) compile the shaders // try to compile "vertex shader" glCompileShaderARB(vertexShader); //please add compile status check in: GLint compileStatus = 0; glGetObjectParameterivARB( vertexShader, GL_COMPILE_STATUS, &compileStatus ); printf("vertexShader status = %i \n", compileStatus); if(compileStatus == 0) { printf("vertexShader erroorrr"); exit (0); } /* glGetInfoLogARB(vertexShader, 999, &infobufferlen, infobuffer); if (infobufferlen != 0){ infobuffer[infobufferlen] = 0; printf("vertexShader reports0: %s \n", infobuffer); return; } */ // ------------------------------------ // try to compile "fragment shader" glCompileShaderARB(fragmentShader); glGetObjectParameterivARB( fragmentShader, GL_COMPILE_STATUS, &compileStatus ); printf("fragmentShader status %i \n", compileStatus); if(compileStatus == 0) { printf("fragmentShader erroorrr"); //exit (0); } /* // per a que funcioni el shader te que estar comentat glGetInfoLogARB(fragmentShader, 999, &infobufferlen, infobuffer); if (infobufferlen != 0){ infobuffer[infobufferlen] = 0; printf("fragmentShader reports: %s \n", infobuffer); return; }*/ // ----------------------------------- (c) link the shaders shader = glCreateProgramObjectARB(); glAttachObjectARB(shader,vertexShader); glAttachObjectARB(shader,fragmentShader); glLinkProgramARB(shader); bLoaded = true; } else { printf("sorry, it looks like you can't run 'ARB_shader_objects' \n please check the capabilites of your graphics card (http://www.ozone3d.net/gpu_caps_viewer/) \n"); } }
bool Shader::compile(const char *vertexShaderCode, const char *fragmentShaderCode) { ensureGLContext(); if (!isAvailable()) { std::cerr << "Failed to create a shader. Your system doesn't support shaders. " << "You should use Shader::isAvailable() befor trying to use shaders.\n"; return false; } if (mShaderProgram) { glCheck(glDeleteObjectARB(mShaderProgram)); } mCurrentTexture = -1; mTextures.clear(); mParams.clear(); mShaderProgram = glCheck(glCreateProgramObjectARB()); if (vertexShaderCode) { GLhandleARB vertexShader = glCheck(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)); glCheck(glShaderSourceARB(vertexShader, 1, &vertexShaderCode, null)); glCheck(glCompileShaderARB(vertexShader)); GLint success; glCheck(glGetObjectParameterivARB(vertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &success)); if (success == GL_FALSE) { char log[1024]; glCheck(glGetInfoLogARB(vertexShader, sizeof(log), 0, log)); std::cerr << "Failed to compile vertex shader. " << log << "\n"; glCheck(glDeleteObjectARB(mShaderProgram)); glCheck(glDeleteObjectARB(vertexShader)); mShaderProgram = 0; return false; } glCheck(glAttachObjectARB(mShaderProgram, vertexShader)); glCheck(glDeleteObjectARB(vertexShader)); } if (fragmentShaderCode) { GLhandleARB fragmentShader = glCheck(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB)); glCheck(glShaderSourceARB(fragmentShader, 1, &fragmentShaderCode, null)); glCheck(glCompileShaderARB(fragmentShader)); GLint success; glCheck(glGetObjectParameterivARB(fragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &success)); if (success == GL_FALSE) { char log[1024]; glCheck(glGetInfoLogARB(fragmentShader, sizeof(log), 0, log)); std::cerr << "Failed to compile vertex shader. " << log << "\n"; glCheck(glDeleteObjectARB(mShaderProgram)); glCheck(glDeleteObjectARB(fragmentShader)); mShaderProgram = 0; return false; } glCheck(glAttachObjectARB(mShaderProgram, fragmentShader)); glCheck(glDeleteObjectARB(fragmentShader)); } glCheck(glLinkProgramARB(mShaderProgram)); GLint success; glCheck(glGetObjectParameterivARB(mShaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success)); if (success == GL_FALSE) { char log[1024]; glCheck(glGetInfoLogARB(mShaderProgram, sizeof(log), 0, log)); std::cerr << "Failed to link shader. " << log << "\n"; glCheck(glDeleteObjectARB(mShaderProgram)); mShaderProgram = 0; return false; } glCheck(glFlush()); return true; }
bool GeoShaderFactory::loadShader(GLhandleARB &progObj, QString shaderString) { GLhandleARB fragObj = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); glAttachObjectARB(progObj, fragObj); GLhandleARB vertObj = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); glAttachObjectARB(progObj, vertObj); { // vertObj QString qstr; qstr = "varying vec3 pointPosition;\n"; qstr += "varying vec3 normal;\n"; qstr += "void main(void)\n"; qstr += "{\n"; qstr += " // Transform vertex position into homogenous clip-space.\n"; qstr += " gl_FrontColor = gl_Color;\n"; qstr += " gl_BackColor = gl_Color;\n"; qstr += " gl_Position = ftransform();\n"; qstr += " pointPosition = gl_Vertex.xyz;\n"; qstr += " normal = gl_NormalMatrix * gl_Normal;\n"; qstr += " gl_TexCoord[0] = gl_TextureMatrix[0] * gl_MultiTexCoord0;\n"; qstr += " gl_TexCoord[1] = gl_TextureMatrix[1] * gl_MultiTexCoord1;\n"; qstr += " gl_TexCoord[2] = gl_TextureMatrix[2] * gl_MultiTexCoord2;\n"; qstr += " gl_ClipVertex = gl_ModelViewMatrix * gl_Vertex;\n"; qstr += "}\n"; int len = qstr.length(); char *tbuffer = new char[len+1]; sprintf(tbuffer, qstr.toLatin1().data()); const char *sstr = tbuffer; glShaderSourceARB(vertObj, 1, &sstr, NULL); delete [] tbuffer; GLint compiled; glCompileShaderARB(vertObj); glGetObjectParameterivARB(vertObj, GL_OBJECT_COMPILE_STATUS_ARB, &compiled); if (!compiled) { GLcharARB str[1000]; GLsizei len; glGetInfoLogARB(vertObj, (GLsizei) 1000, &len, str); QMessageBox::information(0, "Error : Vertex Shader", str); return false; } } { // fragObj int len = shaderString.length(); char *tbuffer = new char[len+1]; sprintf(tbuffer, shaderString.toLatin1().data()); const char *sstr = tbuffer; glShaderSourceARB(fragObj, 1, &sstr, NULL); delete [] tbuffer; GLint compiled; glCompileShaderARB(fragObj); glGetObjectParameterivARB(fragObj, GL_OBJECT_COMPILE_STATUS_ARB, &compiled); if (!compiled) { GLcharARB str[1000]; GLsizei len; glGetInfoLogARB(fragObj, (GLsizei) 1000, &len, str); QMessageBox::information(0, "Error : Fragment Shader", str); return false; } } //----------- link program shader ---------------------- GLint linked; glLinkProgramARB(progObj); glGetObjectParameterivARB(progObj, GL_OBJECT_LINK_STATUS_ARB, &linked); if (!linked) { GLcharARB str[1000]; GLsizei len; QMessageBox::information(0, "ProgObj", "error linking texProgObj"); glGetInfoLogARB(progObj, (GLsizei) 1000, &len, str); QMessageBox::information(0, "Error", QString("%1\n%2").arg(len).arg(str)); return false; } glDeleteObjectARB(fragObj); glDeleteObjectARB(vertObj); return true; }
bool BL_Shader::LinkProgram() { int vertlen = 0, fraglen=0, proglen=0; int vertstatus=0, fragstatus=0, progstatus=0; unsigned int tmpVert=0, tmpFrag=0, tmpProg=0; int char_len=0; char *logInf =0; if (mError) goto programError; if (!vertProg || !fragProg) { spit("Invalid GLSL sources"); return false; } if ( !GLEW_ARB_fragment_shader) { spit("Fragment shaders not supported"); return false; } if ( !GLEW_ARB_vertex_shader) { spit("Vertex shaders not supported"); return false; } // -- vertex shader ------------------ tmpVert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); glShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0); glCompileShaderARB(tmpVert); glGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLint*) &vertlen); // print info if any if ( vertlen > 0 && vertlen < MAX_LOG_LEN) { logInf = (char*)MEM_mallocN(vertlen, "vert-log"); glGetInfoLogARB(tmpVert, vertlen, (GLsizei*)&char_len, logInf); if (char_len >0) { spit("---- Vertex Shader Error ----"); spit(logInf); } MEM_freeN(logInf); logInf=0; } // check for compile errors glGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB,(GLint*)&vertstatus); if (!vertstatus) { spit("---- Vertex shader failed to compile ----"); goto programError; } // -- fragment shader ---------------- tmpFrag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); glShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0); glCompileShaderARB(tmpFrag); glGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &fraglen); if (fraglen >0 && fraglen < MAX_LOG_LEN) { logInf = (char*)MEM_mallocN(fraglen, "frag-log"); glGetInfoLogARB(tmpFrag, fraglen,(GLsizei*) &char_len, logInf); if (char_len >0) { spit("---- Fragment Shader Error ----"); spit(logInf); } MEM_freeN(logInf); logInf=0; } glGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, (GLint*) &fragstatus); if (!fragstatus) { spit("---- Fragment shader failed to compile ----"); goto programError; } // -- program ------------------------ // set compiled vert/frag shader & link tmpProg = glCreateProgramObjectARB(); glAttachObjectARB(tmpProg, tmpVert); glAttachObjectARB(tmpProg, tmpFrag); glLinkProgramARB(tmpProg); glGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &proglen); glGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &progstatus); if (proglen > 0 && proglen < MAX_LOG_LEN) { logInf = (char*)MEM_mallocN(proglen, "prog-log"); glGetInfoLogARB(tmpProg, proglen, (GLsizei*)&char_len, logInf); if (char_len >0) { spit("---- GLSL Program ----"); spit(logInf); } MEM_freeN(logInf); logInf=0; } if (!progstatus) { spit("---- GLSL program failed to link ----"); goto programError; } // set mShader = tmpProg; glDeleteObjectARB(tmpVert); glDeleteObjectARB(tmpFrag); mOk = 1; mError = 0; return true; programError: if (tmpVert) { glDeleteObjectARB(tmpVert); tmpVert=0; } if (tmpFrag) { glDeleteObjectARB(tmpFrag); tmpFrag=0; } if (tmpProg) { glDeleteObjectARB(tmpProg); tmpProg=0; } mOk = 0; mUse = 0; mError = 1; return false; }