//----------------------------------------------------------------------- void GLSLProgram::detachFromProgramObject( const GLuint programObject ) { OGRE_CHECK_GL_ERROR(glDetachShader(programObject, mGLShaderHandle)); logObjectInfo( "Error detaching " + mName + " shader object from GLSL Program Object", programObject ); // attach child objects GLSLProgramContainerIterator childprogramcurrent = mAttachedGLSLPrograms.begin(); GLSLProgramContainerIterator childprogramend = mAttachedGLSLPrograms.end(); while (childprogramcurrent != childprogramend) { GLSLProgram* childShader = *childprogramcurrent; childShader->detachFromProgramObject( programObject ); ++childprogramcurrent; } }
GLMaterial::GLMaterial(GLRenderSystem& renderer, const Material& mat) : _params(mat.default_params) { _id = glCreateProgram(); BufferID vShader = renderer.find_shader(mat.vertex_shader).get_id(); BufferID fShader = renderer.find_shader(mat.fragment_shader).get_id(); glAttachShader(_id, vShader); glAttachShader(_id, fShader); glBindAttribLocation(_id, 0, "vPosition"); glBindAttribLocation(_id, 1, "vTexCoord"); glBindAttribLocation(_id, 2, "vNormal"); glLinkProgram(_id); // Make sure program successfully linked GLint linked; glGetProgramiv(_id, GL_LINK_STATUS, &linked); if (!linked) { GLsizei length; glGetProgramiv(_id, GL_INFO_LOG_LENGTH, &length); GLchar* log = new GLchar[length + 1]; glGetProgramInfoLog(_id, length, &length, log); Console::WriteLine("Material compilation failed: \"@\"", log); delete[] log; } _model = glGetUniformLocation(_id, "model"); _view = glGetUniformLocation(_id, "view"); _projection = glGetUniformLocation(_id, "projection"); glDetachShader(_id, vShader); glDetachShader(_id, fShader); }
static void ShaderTool_PostLinkCleanup(ShaderTool_SInfo_T * info, GLuint prog) { if(info->attached_flag) { glDetachShader(prog, info->shader); glDeleteShader(info->shader); info->shader = 0; } if(info->source != NULL) { free(info->source); info->source = NULL; } }
Shader::~Shader() { if(m_nVertId != 0) { glDetachShader(m_nProgId, m_nVertId); glDeleteShader(m_nVertId); } if(m_nFragId != 0) { glDetachShader(m_nProgId, m_nFragId); glDeleteShader(m_nFragId); } if(m_nGeomId != 0) { glDetachShader(m_nProgId, m_nGeomId); glDeleteShader(m_nGeomId); } if(m_nTessControlId != 0) { glDetachShader(m_nProgId, m_nTessControlId); glDeleteShader(m_nTessControlId); } if(m_nTessEvalId != 0) { glDetachShader(m_nProgId, m_nTessEvalId); glDeleteShader(m_nTessEvalId); } glDeleteProgram(m_nProgId); }
//------------------------------------------------------------------------------------- inline ZZshProgram madeProgram(ZZshShader shader, ZZshShader shader2, char* name) { ZZshProgram prog = glCreateProgram(); glAttachShader(prog, shader); if (shader2 != 0) glAttachShader(prog, shader2); glLinkProgram(prog); if (!GetLinkLog(prog)) { ZZLog::Error_Log("Failed to link shader for %s: ", name); prog = UseEmptyProgram(name, GL_FRAGMENT_SHADER); } glDetachShader(prog, shader); ZZLog::Error_Log("Made shader program for %s... Ok",name); return prog; }
GLint make_program(GLuint vert, GLuint frag){ GLuint prog = glCreateProgram(); glAttachShader(prog, vert); glAttachShader(prog, frag); glLinkProgram(prog); GLint status; glGetProgramiv(prog, GL_LINK_STATUS, &status); if (status == GL_FALSE){ GLint len; glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &len); char *log = malloc(sizeof(char) * len); glGetProgramInfoLog(prog, len, 0, log); fprintf(stderr, "Program failed to link, log:\n%s", log); free(log); } glDetachShader(prog, vert); glDetachShader(prog, frag); if (status == GL_FALSE){ glDeleteProgram(prog); return -1; } return prog; }
static GLuint _shader_init(const char *vs_path, const char *fs_path) { GLuint vertex_shader, fragment_shader; vertex_shader = _create_shader(GL_VERTEX_SHADER, vs_path); fragment_shader = _create_shader(GL_FRAGMENT_SHADER, fs_path); GLuint shader_program = glCreateProgram(); glAttachShader(shader_program, vertex_shader); glAttachShader(shader_program, fragment_shader); glLinkProgram(shader_program); GLint status; glGetProgramiv(shader_program, GL_LINK_STATUS, &status); if (status == GL_FALSE) { puts("Shader linker failure!"); GLint infoLogLength; glGetProgramiv(shader_program, GL_INFO_LOG_LENGTH, &infoLogLength); GLchar strInfoLog[infoLogLength]; glGetProgramInfoLog(shader_program, infoLogLength, NULL, strInfoLog); printf("\nGLSL error: %s", strInfoLog); return -1; } else { printf("Shader program linked: %d\n", shader_program); } glDetachShader(shader_program, vertex_shader); glDetachShader(shader_program, fragment_shader); return shader_program; }
Program& Program::operator=(Program&& other) { if (this != &other) { for (GLuint i : _shaders) glDetachShader(_program, i); glDeleteProgram(_program); _program = other._program; _shaders = std::move(other._shaders); _errors = std::move(other._errors); other._program = 0; } return *this; }
void ImGui_ImplGlfwGL3_InvalidateDeviceObjects() { if (g_VboHandle) glDeleteBuffers(1, &g_VboHandle); if (g_ElementsHandle) glDeleteBuffers(1, &g_ElementsHandle); g_VboHandle = g_ElementsHandle = 0; if (g_ShaderHandle && g_VertHandle) glDetachShader(g_ShaderHandle, g_VertHandle); if (g_VertHandle) glDeleteShader(g_VertHandle); g_VertHandle = 0; if (g_ShaderHandle && g_FragHandle) glDetachShader(g_ShaderHandle, g_FragHandle); if (g_FragHandle) glDeleteShader(g_FragHandle); g_FragHandle = 0; if (g_ShaderHandle) glDeleteProgram(g_ShaderHandle); g_ShaderHandle = 0; if (g_FontTexture) { glDeleteTextures(1, &g_FontTexture); ImGui::GetIO().Fonts->TexID = 0; g_FontTexture = 0; } }
static void delete_flag_programs(struct flag_shaders const *shaders) { glDetachShader( shaders->flag_program, shaders->vertex_shader ); glDetachShader( shaders->flag_program, shaders->flag_fragment_shader ); glDetachShader( shaders->shadowmap_program, shaders->vertex_shader ); glDetachShader( shaders->shadowmap_program, shaders->shadowmap_fragment_shader ); glDeleteProgram(shaders->flag_program); glDeleteProgram(shaders->shadowmap_program); glDeleteShader(shaders->vertex_shader); glDeleteShader(shaders->flag_fragment_shader); glDeleteShader(shaders->shadowmap_fragment_shader); }
bool GLWidgetRendererPrivate::releaseShaderProgram() { video_format.setPixelFormat(VideoFormat::Format_Invalid); plane0Size = QSize(); #if NO_QGL_SHADER if (vert) { if (program) glDetachShader(program, vert); glDeleteShader(vert); } if (frag) { if (program) glDetachShader(program, frag); glDeleteShader(frag); } if (program) { glDeleteProgram(program); program = 0; } #else shader_program->removeAllShaders(); #endif return true; }
gl_program::~gl_program() { GLenum error_check_value = glGetError(); for (GLuint cur : shader_ids) { glDetachShader(program_id, cur); glDeleteShader(cur); } glDeleteProgram(program_id); error_check_value = glGetError(); if (error_check_value != GL_NO_ERROR) { std::cerr << "Could not destroy the shaders!\n"; } }
int unloadComputeShader(struct computeShaderObject * sh) { fprintf(stderr,"unloadComputeShader \n"); glUseProgram(0); glDetachShader(sh->computeShaderProgram, sh->computeShaderObject); glDeleteShader(sh->computeShaderObject); //glDeleteShader(sh->computeShader); glDeleteProgram(sh->computeShaderProgram); if (sh->compMem!=0) { free(sh->compMem); } if (sh!=0) { free(sh); } return 1; }
void ShaderProgram::Cleanup() { if( m_VertShaderString ) delete[] m_VertShaderString; if( m_FragShaderString ) delete[] m_FragShaderString; glDetachShader( m_Program, m_VertShader ); glDetachShader( m_Program, m_FragShader ); if( m_VertShader ) glDeleteShader( m_VertShader ); if( m_FragShader ) glDeleteShader( m_FragShader ); if( m_Program ) glDeleteProgram( m_Program ); m_VertShaderString = 0; m_FragShaderString = 0; m_VertShader = 0; m_FragShader = 0; m_Program = 0; }
void GLSLProgram::linkshaders(){ //Attach our shaders to our program glAttachShader(_programID, _vertexShaderID); glAttachShader(_programID, _fragmentShaderID); //Link our program glLinkProgram(_programID); //Note the different functions here: glGetProgram* instead of glGetShader*. GLint isLinked = 0; glGetProgramiv(_programID, GL_LINK_STATUS, (int *)&isLinked); if (isLinked == GL_FALSE) { GLint maxLength = 0; glGetProgramiv(_programID, GL_INFO_LOG_LENGTH, &maxLength); //The maxLength includes the NULL character std::vector<GLchar> errorLog(maxLength); glGetProgramInfoLog(_programID, maxLength, &maxLength, &errorLog[0]); //We don't need the program anymore. glDeleteProgram(_programID); //Don't leak shaders either. glDeleteShader(_vertexShaderID); glDeleteShader(_fragmentShaderID); std::printf("%s\n", &(errorLog[0])); fatalerror("couldn't link shader"); } //Always detach shaders after a successful link. glDetachShader(_programID, _vertexShaderID); glDetachShader(_programID, _fragmentShaderID); glDeleteShader(_vertexShaderID); glDeleteShader(_fragmentShaderID); }
//---------------------------------------------------------------------------- GLuint OpenGL::CreateProgram (GLuint vertexShader, GLuint fragmentShader) { GLuint program = glCreateProgram(); glAttachShader(program, vertexShader); glAttachShader(program, fragmentShader); // Link the program. glLinkProgram(program); GLint isLinked = 0; glGetProgramiv(program, GL_LINK_STATUS, &isLinked); if (!isLinked) { std::string linkStatus = "Program link error: "; GLint infoLogLength = 0; glGetShaderiv(program, GL_INFO_LOG_LENGTH, &infoLogLength); if (infoLogLength > 0) { GLchar* infoLog = new1<GLchar>(infoLogLength); glGetShaderInfoLog(program, infoLogLength, 0, infoLog); linkStatus += std::string(infoLog); delete1(infoLog); } else { linkStatus += "<no log>"; } glDetachShader(program, vertexShader); glDetachShader(program, fragmentShader); glDeleteProgram(program); assertion(false, "CreateProgram failed: %s\n", linkStatus.c_str()); return 0; } return program; }
void ArcShaderProgram::destroy() { std::list<ArcShader>::iterator i; for (i = mShaders.begin(); i != mShaders.end(); ++i) { glDetachShader(mProgram, i->getHandle()); glDeleteShader(i->getHandle()); } mShaders.clear(); glDeleteProgram(mProgram); ExitOnGLError("ERROR: Could not destroy the shaders"); }
GLuint GLFuncs::CreateProgram(const std::vector<GLuint> &shaderList) { if (!_useShaders) { return 0; } GLuint program = glCreateProgram(); bool anyValidShader = false; for (size_t iLoop = 0; iLoop < shaderList.size(); iLoop++) { if (shaderList[iLoop] != 0) { anyValidShader = true; } glAttachShader(program, shaderList[iLoop]); } if (!anyValidShader) { Log::Out << "No valid shader was specified." << endl; return (GLuint)0; } glBindAttribLocation(program, this->_vtxAttribIdx, "vertexPosition"); glBindAttribLocation(program, this->_uvAttribIdx, "vertexUV"); glBindAttribLocation(program, this->_colAttribIdx, "vertexColor"); glLinkProgram(program); GLint status; glGetProgramiv(program, GL_LINK_STATUS, &status); if (status == GL_FALSE) { GLint infoLogLength; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLength); GLchar *strInfoLog = new GLchar[infoLogLength + 1]; glGetProgramInfoLog(program, infoLogLength, NULL, strInfoLog); Log::Out << "Linker failure: " << strInfoLog << endl; delete[] strInfoLog; glDeleteProgram(program); program = 0; } for (size_t iLoop = 0; iLoop < shaderList.size(); iLoop++) glDetachShader(program, shaderList[iLoop]); return program; }
/* Shader program deinitialization function. * ARGUMENTS: None. * RETURNS: None. */ VOID tlr::shader::Close( VOID ) { UINT shdrs[2]; if (ProgId == 0) return; for (UINT i = 0; i < 2; i++) { glDetachShader(ProgId, shdrs[i]); glDeleteShader(shdrs[i]); } glDeleteProgram(ProgId); /* Set 0 - no shader load */ ProgId = 0; } /* End of 'tlr::shader::Close' function */
Program(const vector<shared_ptr<Shader>>& shaders) { _handle = glCreateProgram(); for(auto& shader : shaders) glAttachShader(_handle, *shader); glLinkProgram(_handle); if (getProgramiv(_handle, GL_LINK_STATUS) == GL_FALSE) { throw logic_error("failed to link the program:\n" + getProgramInfoLog(_handle)); } for(auto& shader : shaders) glDetachShader(_handle, *shader); }
void program:: clear_stages() const { for(auto it(stages_.begin()) ; it != stages_.end() ; ++it) { stage* stage_ptr(it->get()); if(stage_ptr != nullptr) { if(id_ != 0) glDetachShader(id_,stage_ptr->id()); stage_ptr->clear(); } } }
int SCE_RSetProgramShader (SCE_RProgram *prog, SCE_RShaderGLSL *shader, int attach) { if (attach) glAttachShader (prog->id, shader->id); else glDetachShader (prog->id, shader->id); if (shader->type == SCE_TESS_EVALUATION_SHADER || shader->type == SCE_TESS_CONTROL_SHADER) prog->use_tess = attach; /* program need to be relinked in order to apply the changes */ prog->linked = SCE_FALSE; return SCE_OK; }
void ShaderManager::detachShader(std::string shaderKey, std::string shaderProgramKey){ glGetError(); GLuint shaderID = _shaderData->getShaderID(shaderKey); GLuint shaderProgramID = _shaderData->getShaderProgramID(shaderProgramKey); if(shaderProgramID != 0 && shaderID != 0){ glDetachShader(shaderProgramID, shaderID); } else { throw std::exception("ERROR: No shader or shader-program with associated key does exist!"); } if(glGetError() != GL_NO_ERROR){ throw std::exception(("ERROR: Could not detach shader "+std::string(shaderKey)+" from "+std::string(shaderProgramKey)).c_str()); } }
void Program::detachShaders() { // fetch the required shader id buffer size GLint size = 0; glGetProgramiv(id_, GL_ATTACHED_SHADERS, &size); // fetch the shader ids to a buffer std::vector<GLuint> buffer(size); glGetAttachedShaders(id_, size, 0, buffer.data()); // detach all shader objects for (size_t i = 0; i < buffer.size(); ++i) { glDetachShader(id_, buffer[i]); } }
//! Destructor Shader::~Shader() { GLsizei count; //number of actually attached shaders GLuint shaders[3]; //array of potential shader identifiers (vs, fs, gs) // Get all attached shaders glGetAttachedShaders(id, 3, &count, shaders); // Detach and delete all shaders for(int i = 0; i < count; i++) { glDetachShader(id, shaders[i]); glDeleteShader(shaders[i]); } // Delete the program itself glDeleteProgram(id); }
/* Shader program load function. * ARGUMENTS: * - shader program Id: * UINT Prg; * RETURNS: None. */ VOID MP2_RndShaderFree( UINT Prg ) { UINT i, n, shds[5]; if (Prg == 0) return; /* Obtain program shaders count */ glGetAttachedShaders(Prg, 5, &n, shds); for (i = 0; i < n; i++) { glDetachShader(Prg, shds[i]); glDeleteShader(shds[i]); } glDeleteProgram(Prg); } /* End of 'MP2_RndShaderFree' function */
/* ‘ункци¤ удалени¤ шейдерной программы. * ј–√”ћ≈Ќ“џ: * - идентификатор загруженной программы: * UINT ProgId; * ¬ќ«¬–јўј≈ћќ≈ «Ќј„≈Ќ»≈: Ќет. */ VOID OK2_ShadProgClose( UINT ProgId ) { UINT i, n, shdrs[4]; if (ProgId == 0) return; /* получаем присоединенные шейдера */ glGetAttachedShaders(ProgId, 4, &n, shdrs); /* удал¤ем */ for (i = 0; i < n; i++) { glDetachShader(ProgId, shdrs[i]); glDeleteShader(shdrs[i]); } glDeleteProgram(ProgId); } /* End of 'OK2_ShadProgClose' function */
int lite3d_shader_program_link( lite3d_shader_program *program, lite3d_shader *shaders, size_t count) { uint32_t i; GLint isLinked = 0; GLint maxLogLength = 0; SDL_assert(program); lite3d_misc_gl_error_stack_clean(); if (!glIsProgram(program->programID)) { program->programID = glCreateProgram(); } else { /* if is program already created - relocate log string before relink program */ if (program->statusString) { lite3d_free(program->statusString); program->statusString = NULL; } } for (i = 0; i < count; ++i) glAttachShader(program->programID, shaders[i].shaderID); /* linking process */ glLinkProgram(program->programID); LITE3D_CHECK_GL_ERROR; glGetProgramiv(program->programID, GL_LINK_STATUS, &isLinked); program->success = isLinked == GL_TRUE ? LITE3D_TRUE : LITE3D_FALSE; /* get informaion log */ glGetProgramiv(program->programID, GL_INFO_LOG_LENGTH, &maxLogLength); program->statusString = (char *) lite3d_malloc(maxLogLength); glGetProgramInfoLog(program->programID, maxLogLength, &maxLogLength, program->statusString); for (i = 0; i < count; ++i) glDetachShader(program->programID, shaders[i].shaderID); return program->success; }
backlash::Program::Program(const std::vector<Shader> &shaders) : mObject(0), mID(CURRENT_ID++) { if (shaders.size() <= 0) { throw std::runtime_error("No Shaders were provided to create the program."); } // Create the program Object mObject = glCreateProgram(); if (mObject == 0) { throw std::runtime_error("glCreateProgram failed. There is no program object."); } // attach all the shaders for (int i = 0; i < shaders.size(); i++) { glAttachShader(mObject, shaders.at(i).object()); } // link the shaders together glLinkProgram(mObject); // detach all the shaders for (int i = 0; i < shaders.size(); i++) { glDetachShader(mObject, shaders.at(i).object()); } // throw exception if linking has failed. GLint status; glGetProgramiv(mObject, GL_LINK_STATUS, &status); if (status == GL_FALSE) { std::stringstream msg; msg << "Program link failure: "; GLint infoLogLength; glGetProgramiv(mObject, GL_INFO_LOG_LENGTH, &infoLogLength); char* strInfoLog = new char[infoLogLength + 1]; glGetProgramInfoLog(mObject, infoLogLength, NULL, strInfoLog); msg << strInfoLog << std::endl; delete[] strInfoLog; glDeleteProgram(mObject); mObject = 0; throw std::runtime_error(msg.str().c_str()); } }
Program::Program(const std::vector<Shader>& shaders) : _object(0) { if(shaders.size() <= 0) { throw std::runtime_error("No shaders were provided to create the program"); } //Create the program object and check if there was no problems. _object = glCreateProgram(); if(_object == 0) { throw std::runtime_error("glCreateProgram failed"); } //Attach all the shaders. for(unsigned i(0); i != shaders.size(); ++i) { glAttachShader(_object, shaders[i].object()); } //Link the shaders together. glLinkProgram(_object); //Detach all the shaders. for(unsigned i(0); i != shaders.size(); ++i) { glDetachShader(_object, shaders[i].object()); } //Throw exception if linking failed. GLint status; glGetProgramiv(_object, GL_LINK_STATUS, &status); if (status == GL_FALSE) { std::string msg("Program linking failure: "); GLint infoLogLength; glGetProgramiv(_object, GL_INFO_LOG_LENGTH, &infoLogLength); char* strInfoLog = new char[infoLogLength + 1]; glGetProgramInfoLog(_object, infoLogLength, NULL, strInfoLog); msg += strInfoLog; delete[] strInfoLog; glDeleteProgram(_object); _object = 0; throw std::runtime_error(msg); } }