panel panel_create(int width, int height, image font) { panel result = {width, height, font.width, font.height, NULL, NULL, 0, 0, 0, 0, 0}; result.font = texture_create(font); result.foreground = malloc(4*width*height); result.background = malloc(4*width*height); // program and shader handles GLhandleARB vertex_shader, fragment_shader; int length; GLint shader_ok; // create and compiler vertex shader vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); length = strlen(vertex_source); glShaderSourceARB(vertex_shader, 1, &vertex_source, &length); glCompileShaderARB(vertex_shader); glGetObjectParameterivARB(vertex_shader, GL_COMPILE_STATUS, &shader_ok); assert(shader_ok); // create and compiler fragment shader fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); length = strlen(fragment_source); glShaderSourceARB(fragment_shader, 1, &fragment_source, &length); glCompileShaderARB(fragment_shader); glGetObjectParameterivARB(fragment_shader, GL_COMPILE_STATUS, &shader_ok); assert(shader_ok); // create program result.shader_program = glCreateProgramObjectARB(); // attach shaders glAttachObjectARB(result.shader_program, vertex_shader); glAttachObjectARB(result.shader_program, fragment_shader); // link the program and check for errors glLinkProgramARB(result.shader_program); glGetObjectParameterivARB(result.shader_program, GL_LINK_STATUS, &shader_ok); assert(shader_ok); // we don't need these anymore glDeleteObjectARB(vertex_shader); glDeleteObjectARB(fragment_shader); // generate and bind the buffer object glGenBuffersARB(1, &result.vbo); glBindBufferARB(GL_ARRAY_BUFFER_ARB, result.vbo); // fill with data glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(GLfloat)*6*5, quad_data, GL_STATIC_DRAW_ARB); glActiveTexture(GL_TEXTURE1); glGenTextures(1, &result.fg_tex); glBindTexture(GL_TEXTURE_2D, result.fg_tex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, result.width, result.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.foreground); glActiveTexture(GL_TEXTURE2); glGenTextures(1, &result.bg_tex); glBindTexture(GL_TEXTURE_2D, result.bg_tex); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, result.width, result.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, result.background); glUseProgramObjectARB(result.shader_program); glUniform1iARB(glGetUniformLocationARB(result.shader_program, "font"), 0); glUniform1iARB(glGetUniformLocationARB(result.shader_program, "foreground"), 1); glUniform1iARB(glGetUniformLocationARB(result.shader_program, "background"), 2); glUniform2fARB(glGetUniformLocationARB(result.shader_program, "panel_size"), width, height); return result; }
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_)); }
/*! \brief Builds the shader and allocates the associated OpenGL objects. * * This function will throw an exception if compilation * fails. */ inline void build() { if (_vertexShaderCode.empty()) _vertexShaderCode = magnet::string::format_code(initVertexShaderSource()); if (_fragmentShaderCode.empty()) _fragmentShaderCode = magnet::string::format_code(initFragmentShaderSource()); if (_geometryShaderCode.empty()) _geometryShaderCode = magnet::string::format_code(initGeometryShaderSource()); //Check for the ability to use fragment and vertex shaders if (!GLEW_ARB_fragment_program || !GLEW_ARB_vertex_program || !GLEW_ARB_fragment_shader || !GLEW_ARB_vertex_shader) M_throw() << "This OpenGL context/driver does not support GLSL (programmable shaders)"; GLint result; //Vertex shader if (!_vertexShaderCode.empty()) { if (!GLEW_ARB_vertex_shader) M_throw() << "Vertex shaders are not supported by your OpenGL driver."; if (!(_vertexShaderHandle = glCreateShaderObjectARB(GL_VERTEX_SHADER))) M_throw() << "Failed to create vertex shader handle"; const GLcharARB* src = _vertexShaderCode.c_str(); glShaderSourceARB(_vertexShaderHandle, 1, &src, NULL); glCompileShaderARB(_vertexShaderHandle); glGetObjectParameterivARB(_vertexShaderHandle, GL_OBJECT_COMPILE_STATUS_ARB, &result); if (!result) M_throw() << "Vertex shader compilation failed, build log follows\n" << getShaderBuildlog(_vertexShaderHandle); } //Fragment shader if (!_fragmentShaderCode.empty()) { if (!GLEW_ARB_fragment_shader) M_throw() << "Fragment shaders are not supported by your OpenGL driver."; if (!(_fragmentShaderHandle = glCreateShaderObjectARB(GL_FRAGMENT_SHADER))) M_throw() << "Failed to create fragment shader handle"; const GLcharARB* src = _fragmentShaderCode.c_str(); glShaderSourceARB(_fragmentShaderHandle, 1, &src, NULL); glCompileShaderARB(_fragmentShaderHandle); glGetObjectParameterivARB(_fragmentShaderHandle, GL_OBJECT_COMPILE_STATUS_ARB, &result); if (!result) M_throw() << "Fragment shader compilation failed, build log follows\n" << getShaderBuildlog(_fragmentShaderHandle); } //Geometry shader if (!(_geometryShaderCode.empty())) { if (!GL_EXT_geometry_shader4) M_throw() << "Geometry shaders are not supported by your OpenGL driver."; if (!(_geometryShaderHandle = glCreateShaderObjectARB(GL_GEOMETRY_SHADER_EXT))) M_throw() << "Failed to create geometry shader handle"; const GLcharARB* src = _fragmentShaderCode.c_str(); glShaderSourceARB(_geometryShaderHandle, 1, &src, NULL); glCompileShaderARB(_geometryShaderHandle); glGetObjectParameterivARB(_fragmentShaderHandle, GL_OBJECT_COMPILE_STATUS_ARB, &result); if (!result) M_throw() << "Geometry shader compilation failed, build log follows\n" << getShaderBuildlog(_fragmentShaderHandle); } //Now we've build both shaders, combine them into a program _shaderID = glCreateProgramObjectARB(); if (!(_vertexShaderCode.empty())) glAttachObjectARB(_shaderID,_vertexShaderHandle); if (!(_fragmentShaderCode.empty())) glAttachObjectARB(_shaderID,_fragmentShaderHandle); if (!(_geometryShaderCode.empty())) glAttachObjectARB(_shaderID,_geometryShaderHandle); glLinkProgramARB(_shaderID); //Done, now the inheriting shader should grab the locations of its uniforms _built = true; }
/** * @brief * Constructor */ TessellationControlShaderGLSL::TessellationControlShaderGLSL(PLRenderer::Renderer &cRenderer) : PLRenderer::TessellationControlShader(cRenderer), m_nOpenGLTessellationControlShader(glCreateShaderObjectARB(GL_TESS_CONTROL_SHADER)) { }
// // Load vertex and fragment shader, compile, link etc. // qbool SHD_Load(shader_t *s, const char *vertex_fileName, const char *fragment_fileName) { shader_t s_tmp; GLint linked = 0; int i; if (!SHD_Initialized()) { Com_Printf("SHD_Load: shader system not initialized\n"); return false; } memset(&s_tmp, 0, sizeof(s_tmp)); // just some assertion checks SHD_AlredyLoaded(s); if (shd.count >= MAX_SHADERS) { Com_Printf("SHD_Load: full shader list\n"); goto cleanup; } if (!s) { Com_Printf("SHD_Load: zero shader\n"); goto cleanup; } // we must have here nulified struct for (i = 0; i < sizeof(*s); i++) { if (((byte*)s)[i]) { Com_Printf("SHD_Load: shader struct not ready\n"); goto cleanup; } } // create a program object s_tmp.program = glCreateProgramObjectARB(); if (!s_tmp.program) { Com_Printf("SHD_Load: failed to create program\n"); goto cleanup; } // create shaders s_tmp.vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); s_tmp.fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); // load source code strings into shaders if (!SHD_LoadAndCompile(s_tmp.vertexShader, vertex_fileName)) goto cleanup; if (!SHD_LoadAndCompile(s_tmp.fragmentShader, fragment_fileName)) goto cleanup; // attach the two compiled shaders // TODO: check success glAttachObjectARB(s_tmp.program, s_tmp.vertexShader); glAttachObjectARB(s_tmp.program, s_tmp.fragmentShader); // link the program object and print out the info log glLinkProgramARB(s_tmp.program); // check for OpenGL errors if (!SHD_CheckOpenGLError()) { Com_Printf("SHD_Load: OpenGL errors encountered\n"); goto cleanup; } glGetObjectParameterivARB(s_tmp.program, GL_OBJECT_LINK_STATUS_ARB, &linked); if (!linked) { Com_Printf("SHD_Load: program not linked\n"); goto cleanup; } // copy struct *s = s_tmp; // link to shd list shd.shaders[shd.count] = s; shd.count++; return true; cleanup: // GOTO MARK SHD_Free(&s_tmp); return false; }
const char *marcLeftUpperArm_SHADER_VertexStrings[1]; const char *marcLeftUpperArm_SHADER_FragmentStrings[1]; marcLeftUpperArm_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *marcLeftUpperArm_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.vert" ); marcLeftUpperArm_SHADER_VertexStrings[0] = (char*)marcLeftUpperArm_SHADER_VertexAssembly; glShaderSourceARB( marcLeftUpperArm_SHADER_Vertex, 1, marcLeftUpperArm_SHADER_VertexStrings, NULL ); glCompileShaderARB( marcLeftUpperArm_SHADER_Vertex); delete marcLeftUpperArm_SHADER_VertexAssembly; marcLeftUpperArm_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *marcLeftUpperArm_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.frag" ); marcLeftUpperArm_SHADER_FragmentStrings[0] = (char*)marcLeftUpperArm_SHADER_FragmentAssembly; glShaderSourceARB( marcLeftUpperArm_SHADER_Fragment, 1, marcLeftUpperArm_SHADER_FragmentStrings, NULL ); glCompileShaderARB( marcLeftUpperArm_SHADER_Fragment ); delete marcLeftUpperArm_SHADER_FragmentAssembly; marcLeftUpperArm_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( marcLeftUpperArm_SHADER, marcLeftUpperArm_SHADER_Vertex ); glAttachObjectARB( marcLeftUpperArm_SHADER, marcLeftUpperArm_SHADER_Fragment ); glLinkProgramARB(marcLeftUpperArm_SHADER); UNIFORM_counter_marcLeftUpperArm = glGetUniformLocationARB( marcLeftUpperArm_SHADER, "counter" );
bool ShaderFactory::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 pointpos;\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 += " 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 += " pointpos = gl_Vertex.xyz;\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 = -1; 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 = -1; glCompileShaderARB(fragObj); glGetObjectParameterivARB(fragObj, GL_OBJECT_COMPILE_STATUS_ARB, &compiled); if (!compiled) { GLcharARB str[1000]; GLsizei len; glGetInfoLogARB(fragObj, (GLsizei) 1000, &len, str); //----------------------------------- // display error //qApp->beep(); QString estr; QStringList slist = shaderString.split("\n"); for(int i=0; i<slist.count(); i++) estr += QString("%1 : %2\n").arg(i+1).arg(slist[i]); QTextEdit *tedit = new QTextEdit(); tedit->insertPlainText("-------------Error----------------\n\n"); tedit->insertPlainText(str); tedit->insertPlainText("\n-----------Shader---------------\n\n"); tedit->insertPlainText(estr); QVBoxLayout *layout = new QVBoxLayout(); layout->addWidget(tedit); QDialog *showError = new QDialog(); showError->setWindowTitle("Error in Fragment Shader"); showError->setSizeGripEnabled(true); showError->setModal(true); showError->setLayout(layout); showError->exec(); //----------------------------------- return false; } } //----------- link program shader ---------------------- GLint linked = -1; 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; }
const char *marcRightLowerLeg_SHADER_VertexStrings[1]; const char *marcRightLowerLeg_SHADER_FragmentStrings[1]; marcRightLowerLeg_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *marcRightLowerLeg_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.vert" ); marcRightLowerLeg_SHADER_VertexStrings[0] = (char*)marcRightLowerLeg_SHADER_VertexAssembly; glShaderSourceARB( marcRightLowerLeg_SHADER_Vertex, 1, marcRightLowerLeg_SHADER_VertexStrings, NULL ); glCompileShaderARB( marcRightLowerLeg_SHADER_Vertex); delete marcRightLowerLeg_SHADER_VertexAssembly; marcRightLowerLeg_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *marcRightLowerLeg_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.frag" ); marcRightLowerLeg_SHADER_FragmentStrings[0] = (char*)marcRightLowerLeg_SHADER_FragmentAssembly; glShaderSourceARB( marcRightLowerLeg_SHADER_Fragment, 1, marcRightLowerLeg_SHADER_FragmentStrings, NULL ); glCompileShaderARB( marcRightLowerLeg_SHADER_Fragment ); delete marcRightLowerLeg_SHADER_FragmentAssembly; marcRightLowerLeg_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( marcRightLowerLeg_SHADER, marcRightLowerLeg_SHADER_Vertex ); glAttachObjectARB( marcRightLowerLeg_SHADER, marcRightLowerLeg_SHADER_Fragment ); glLinkProgramARB(marcRightLowerLeg_SHADER); UNIFORM_counter_marcRightLowerLeg = glGetUniformLocationARB( marcRightLowerLeg_SHADER, "counter" );
void pip::Shader::loadShader(const string &vertexName, const string &fragmentName) { //printLog(this->prog); // Loading vertex shader. if(this->vertexShadersMap.count(vertexName) == 0) // TODO Error checking? { this->vertexShadersMap[vertexName] = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); //printLog(this->vertexShadersMap[vertexName]); string program; if(loadFile(vertexName, program)) { const char * vv = STR_CCHR(program); std::cout << "Program: " << vv << std::endl; glShaderSourceARB(this->vertexShadersMap[vertexName], 1, &vv, NULL); /*GLenum glErr; glErr = glGetError(); while (glErr != GL_NO_ERROR) { printf("%s\n", gluErrorString(glErr)); glErr = glGetError(); }*/ //delete vv; glCompileShaderARB(this->vertexShadersMap[vertexName]); //printLog(this->vertexShadersMap[vertexName]); GLint result = GL_FALSE; glGetObjectParameterivARB(this->vertexShadersMap[vertexName],GL_COMPILE_STATUS,&result); if(result == GL_FALSE) { //printLog(this->vertexShadersMap[vertexName]); throw EngineException("Error occurred when compiling '" + vertexName + "' vertex shader."); } }else throw EngineException("Can't load '" + vertexName + "' shader!"); } // Loading fragment shader. if(this->fragmentShadersMap.count(fragmentName) == 0) { this->fragmentShadersMap[fragmentName] = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); string program; if(loadFile(fragmentName, program)) { const char * ff = STR_CCHR(program); glShaderSourceARB(this->fragmentShadersMap[fragmentName], 1, &ff,NULL); //delete ff; glCompileShaderARB(this->fragmentShadersMap[fragmentName]); GLint result = GL_FALSE; glGetObjectParameterivARB(this->fragmentShadersMap[fragmentName],GL_COMPILE_STATUS,&result); if(result == GL_FALSE) throw EngineException("Error occurred when compiling '" + fragmentName + "' fragment shader."); }else throw EngineException("Can't load '" + fragmentName + "' shader!"); } this->prog = glCreateProgramObjectARB(); // Attaching vertex shader to program object. glAttachObjectARB(this->prog, this->vertexShadersMap[vertexName]); // Attaching fragment shader to program object. glAttachObjectARB(this->prog, this->fragmentShadersMap[fragmentName]); glLinkProgramARB(this->prog); GLint result = GL_FALSE; glGetObjectParameterivARB(this->prog,GL_OBJECT_LINK_STATUS_ARB,&result); if(result == GL_FALSE) throw EngineException("Error occurred when linking shaders."); }
const char *spikes_00_SHADER_VertexStrings[1]; const char *spikes_00_SHADER_FragmentStrings[1]; spikes_00_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *spikes_00_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/spikes_00/spikes_00.vert" ); spikes_00_SHADER_VertexStrings[0] = (char*)spikes_00_SHADER_VertexAssembly; glShaderSourceARB( spikes_00_SHADER_Vertex, 1, spikes_00_SHADER_VertexStrings, NULL ); glCompileShaderARB( spikes_00_SHADER_Vertex); delete spikes_00_SHADER_VertexAssembly; spikes_00_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *spikes_00_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/spikes_00/spikes_00.frag" ); spikes_00_SHADER_FragmentStrings[0] = (char*)spikes_00_SHADER_FragmentAssembly; glShaderSourceARB( spikes_00_SHADER_Fragment, 1, spikes_00_SHADER_FragmentStrings, NULL ); glCompileShaderARB( spikes_00_SHADER_Fragment ); delete spikes_00_SHADER_FragmentAssembly; spikes_00_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( spikes_00_SHADER, spikes_00_SHADER_Vertex ); glAttachObjectARB( spikes_00_SHADER, spikes_00_SHADER_Fragment ); glLinkProgramARB(spikes_00_SHADER); UNIFORM_counter_spikes_00 = glGetUniformLocationARB( spikes_00_SHADER, "counter" );
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 (myShaderProgram) GLCheck(glDeleteObjectARB(myShaderProgram)); // Create the program myShaderProgram = 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(myShaderProgram)); myShaderProgram = 0; return false; } // Attach the shader to the program, and delete it (not needed anymore) GLCheck(glAttachObjectARB(myShaderProgram, 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(myShaderProgram)); myShaderProgram = 0; return false; } // Attach the shader to the program, and delete it (not needed anymore) GLCheck(glAttachObjectARB(myShaderProgram, fragmentShader)); GLCheck(glDeleteObjectARB(fragmentShader)); } // Link the program GLCheck(glLinkProgramARB(myShaderProgram)); // Check the link log GLint success; GLCheck(glGetObjectParameterivARB(myShaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success)); if (success == GL_FALSE) { char log[1024]; GLCheck(glGetInfoLogARB(myShaderProgram, sizeof(log), 0, log)); Err() << "Failed to link shader:" << std::endl << log << std::endl; GLCheck(glDeleteObjectARB(myShaderProgram)); myShaderProgram = 0; return false; } return true; }
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; }
static inline bool r_create_program(const char *id, const char *vss, const char *fss, uint *vs, uint *fs, uint *prog) { OPENGL_EVENT_BEGIN(0, __PRETTY_FUNCTION__); *vs = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); *fs = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); // shut up compiler... glShaderSourceARB(*vs, 1, (const char **)&vss, NULL); glShaderSourceARB(*fs, 1, (const char **)&fss, NULL); // compile vertex shader glCompileShaderARB(*vs); if (!r_shader_check(*vs, GL_OBJECT_COMPILE_STATUS_ARB, id, "vertex shader compilation")) { OPENGL_EVENT_END(); return false; } // compile fragment shader glCompileShaderARB(*fs); if (!r_shader_check(*fs, GL_OBJECT_COMPILE_STATUS_ARB, id, "fragment shader compilation")) { OPENGL_EVENT_END(); return false; } // link the program together *prog = glCreateProgramObjectARB(); glAttachObjectARB(*prog, *vs); glAttachObjectARB(*prog, *fs); glLinkProgramARB(*prog); if (!r_shader_check(*prog, GL_OBJECT_LINK_STATUS_ARB, id, "GPU program linking")) { OPENGL_EVENT_END(); return false; } // validate the program glValidateProgramARB(*prog); if (!r_shader_check(*prog, GL_OBJECT_VALIDATE_STATUS_ARB, id, "GPU program validation")) { OPENGL_EVENT_END(); return false; } #if OPENGL_DEBUG if (GLEW_KHR_debug) { glObjectLabel(GL_SHADER, *vs, -1, id); glObjectLabel(GL_SHADER, *fs, -1, id); glObjectLabel(GL_PROGRAM, *prog, -1, id); } #endif OPENGL_EVENT_END(); return true; }
void initShader(void) { /////////////////////////////////////////////////////////////////////////// // // Create earth shader // GLhandleARB terrain_vertex_shader; GLhandleARB terrain_fragment_shader; // // Create and load resources // g_terrainProgram = glCreateProgramObjectARB(); terrain_vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); terrain_fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); loadShaderFromFile(terrain_vertex_shader, "shader/terrain.vert"); loadShaderFromFile(terrain_fragment_shader, "shader/terrain.frag"); // // Compile // glCompileShaderARB(terrain_vertex_shader); GET_GLERROR(0); printInfoLog(terrain_vertex_shader); glCompileShaderARB(terrain_fragment_shader); GET_GLERROR(0); printInfoLog(terrain_fragment_shader); // // Link // glAttachObjectARB(g_terrainProgram, terrain_vertex_shader); glAttachObjectARB(g_terrainProgram, terrain_fragment_shader); glLinkProgramARB(g_terrainProgram); GET_GLERROR(0); printInfoLog(g_terrainProgram); /////////////////////////////////////////////////////////////////////////// // // Setup terrain shader // // // Sampler // glUseProgramObjectARB(g_terrainProgram); GET_GLERROR(0); float test; // // Aufgabe 1.b - Begin // int samplerTerrain = glGetUniformLocationARB(g_terrainProgram, "samplerTerrain"); GET_GLERROR(0); int samplerGradient = glGetUniformLocationARB(g_terrainProgram, "samplerGradient"); GET_GLERROR(0); glUniform1i(samplerTerrain, 0); GET_GLERROR(0); glUniform1i(samplerGradient, 1); GET_GLERROR(0); // // Aufgabe 1.b - End // // // Bounding Box // int LLFLocation = glGetUniformLocationARB(g_terrainProgram, "v3LLF"); GET_GLERROR(0); int URBLocation = glGetUniformLocationARB(g_terrainProgram, "v3URB"); GET_GLERROR(0); vec3 LLF = vec3(g_sceneAABB.xMin, g_sceneAABB.yMin, g_sceneAABB.zMin); vec3 URB = vec3(g_sceneAABB.xMax, g_sceneAABB.yMax, g_sceneAABB.zMax); glUniform3fARB(LLFLocation, g_sceneAABB.xMin, g_sceneAABB.yMin, g_sceneAABB.zMin); GET_GLERROR(0); glUniform3fARB(URBLocation, g_sceneAABB.xMax, g_sceneAABB.yMax, g_sceneAABB.zMax); GET_GLERROR(0); return; }
bool GPU::Shader::PgObject::Allocate() { m_Id = glCreateShaderObjectARB( m_PgType ); return m_Id != 0; }
const char *marcRightHand_SHADER_VertexStrings[1]; const char *marcRightHand_SHADER_FragmentStrings[1]; marcRightHand_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *marcRightHand_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.vert" ); marcRightHand_SHADER_VertexStrings[0] = (char*)marcRightHand_SHADER_VertexAssembly; glShaderSourceARB( marcRightHand_SHADER_Vertex, 1, marcRightHand_SHADER_VertexStrings, NULL ); glCompileShaderARB( marcRightHand_SHADER_Vertex); delete marcRightHand_SHADER_VertexAssembly; marcRightHand_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *marcRightHand_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/marcParts/marcTorso/marcTorso.frag" ); marcRightHand_SHADER_FragmentStrings[0] = (char*)marcRightHand_SHADER_FragmentAssembly; glShaderSourceARB( marcRightHand_SHADER_Fragment, 1, marcRightHand_SHADER_FragmentStrings, NULL ); glCompileShaderARB( marcRightHand_SHADER_Fragment ); delete marcRightHand_SHADER_FragmentAssembly; marcRightHand_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( marcRightHand_SHADER, marcRightHand_SHADER_Vertex ); glAttachObjectARB( marcRightHand_SHADER, marcRightHand_SHADER_Fragment ); glLinkProgramARB(marcRightHand_SHADER);
GPUShader *GPU_shader_create(const char *vertexcode, const char *fragcode, /*GPUShader *lib,*/ const char *libcode) { GLint status; GLcharARB log[5000]; const char *fragsource[2]; GLsizei length = 0; GLint count; 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) { glAttachObjectARB(shader->object, shader->vertex); glShaderSourceARB(shader->vertex, 1, (const char**)&vertexcode, 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) { count = 0; if(libcode) fragsource[count++] = libcode; if(fragcode) fragsource[count++] = fragcode; glAttachObjectARB(shader->object, shader->fragment); glShaderSourceARB(shader->fragment, count, fragsource, 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(lib && lib->lib) glAttachObjectARB(shader->object, lib->lib);*/ 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; }
const char *particle_50mm_SHADER_VertexStrings[1]; const char *particle_50mm_SHADER_FragmentStrings[1]; particle_50mm_SHADER_Vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB ); unsigned char *particle_50mm_SHADER_VertexAssembly = readShaderFile( "_MODEL_FOLDERS_/particle_50mm/particle_50mm.vert" ); particle_50mm_SHADER_VertexStrings[0] = (char*)particle_50mm_SHADER_VertexAssembly; glShaderSourceARB( particle_50mm_SHADER_Vertex, 1, particle_50mm_SHADER_VertexStrings, NULL ); glCompileShaderARB( particle_50mm_SHADER_Vertex); delete particle_50mm_SHADER_VertexAssembly; particle_50mm_SHADER_Fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB ); unsigned char *particle_50mm_SHADER_FragmentAssembly = readShaderFile( "_MODEL_FOLDERS_/particle_50mm/particle_50mm.frag" ); particle_50mm_SHADER_FragmentStrings[0] = (char*)particle_50mm_SHADER_FragmentAssembly; glShaderSourceARB( particle_50mm_SHADER_Fragment, 1, particle_50mm_SHADER_FragmentStrings, NULL ); glCompileShaderARB(particle_50mm_SHADER_Fragment ); delete particle_50mm_SHADER_FragmentAssembly; particle_50mm_SHADER = glCreateProgramObjectARB(); glAttachObjectARB( particle_50mm_SHADER, particle_50mm_SHADER_Vertex ); glAttachObjectARB( particle_50mm_SHADER, particle_50mm_SHADER_Fragment ); glLinkProgramARB(particle_50mm_SHADER); UNIFORM_counter1_particle_50mm = glGetUniformLocationARB( particle_50mm_SHADER, "counter1" ); UNIFORM_counter2_particle_50mm = glGetUniformLocationARB( particle_50mm_SHADER, "counter2" );
bool Shader::CompileProgram() { 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 (myShaderProgram) GLCheck(glDeleteObjectARB(myShaderProgram)); // Define the vertex shader source (we provide it directly as it doesn't have to change) static const char* vertexSrc = "void main()" "{" " gl_TexCoord[0] = gl_MultiTexCoord0;" " gl_FrontColor = gl_Color;" " gl_Position = ftransform();" "}"; // Create the program myShaderProgram = glCreateProgramObjectARB(); // Create the shaders GLhandleARB vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB); GLhandleARB fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB); // Compile them const char* fragmentSrc = myFragmentShader.c_str(); GLCheck(glShaderSourceARB(vertexShader, 1, &vertexSrc, NULL)); GLCheck(glShaderSourceARB(fragmentShader, 1, &fragmentSrc, NULL)); GLCheck(glCompileShaderARB(vertexShader)); GLCheck(glCompileShaderARB(fragmentShader)); // Check the compile logs 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 shader:" << std::endl << log << std::endl; GLCheck(glDeleteObjectARB(vertexShader)); GLCheck(glDeleteObjectARB(fragmentShader)); GLCheck(glDeleteObjectARB(myShaderProgram)); myShaderProgram = 0; return false; } 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 shader:" << std::endl << log << std::endl; GLCheck(glDeleteObjectARB(vertexShader)); GLCheck(glDeleteObjectARB(fragmentShader)); GLCheck(glDeleteObjectARB(myShaderProgram)); myShaderProgram = 0; return false; } // Attach the shaders to the program GLCheck(glAttachObjectARB(myShaderProgram, vertexShader)); GLCheck(glAttachObjectARB(myShaderProgram, fragmentShader)); // We can now delete the shaders GLCheck(glDeleteObjectARB(vertexShader)); GLCheck(glDeleteObjectARB(fragmentShader)); // Link the program GLCheck(glLinkProgramARB(myShaderProgram)); // Get link log GLCheck(glGetObjectParameterivARB(myShaderProgram, GL_OBJECT_LINK_STATUS_ARB, &success)); if (success == GL_FALSE) { // Oops... link errors char log[1024]; GLCheck(glGetInfoLogARB(myShaderProgram, sizeof(log), 0, log)); Err() << "Failed to link shader:" << std::endl << log << std::endl; GLCheck(glDeleteObjectARB(myShaderProgram)); myShaderProgram = 0; return false; } return true; }