//----------------------------------------------------------------------- void GLSLProgram::attachChildShader(const String& name) { // is the name valid and already loaded? // check with the high level program manager to see if it was loaded HighLevelGpuProgramPtr hlProgram = HighLevelGpuProgramManager::getSingleton().getByName(name); if (!hlProgram.isNull()) { if (hlProgram->getSyntaxCode() == "glsl") { // make sure attached program source gets loaded and compiled // don't need a low level implementation for attached shader objects // loadHighLevelImpl will only load the source and compile once // so don't worry about calling it several times GLSLProgram* childShader = static_cast<GLSLProgram*>(hlProgram.getPointer()); // load the source and attach the child shader only if supported if (isSupported()) { childShader->loadHighLevelImpl(); // add to the container mAttachedGLSLPrograms.push_back( childShader ); mAttachedShaderNames += name + " "; } } } }
//----------------------------------------------------------------------- void GLSLProgram::attachToProgramObject( const GLhandleARB programObject ) { glAttachObjectARB( programObject, mGLHandle ); checkForGLSLError( "GLSLLinkProgram::GLSLLinkProgram", "Error attaching " + mName + " shader object to GLSL Program Object", programObject ); // attach child objects GLSLProgramContainerIterator childprogramcurrent = mAttachedGLSLPrograms.begin(); GLSLProgramContainerIterator childprogramend = mAttachedGLSLPrograms.end(); while (childprogramcurrent != childprogramend) { GLSLProgram* childShader = *childprogramcurrent; // bug in ATI GLSL linker : modules without main function must be recompiled each time // they are linked to a different program object // don't check for compile errors since there won't be any // *** minor inconvenience until ATI fixes there driver childShader->compile(false); childShader->attachToProgramObject( programObject ); ++childprogramcurrent; } }
//----------------------------------------------------------------------- void GLSLProgram::buildConstantDefinitions() const { // We need an accurate list of all the uniforms in the shader, but we // can't get at them until we link all the shaders into a program object. // Therefore instead, parse the source code manually and extract the uniforms createParameterMappingStructures(true); if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS)) { GLSLProgramPipelineManager::getSingleton().extractConstantDefs(mSource, *mConstantDefs.get(), mName); } else { GLSLLinkProgramManager::getSingleton().extractConstantDefs(mSource, *mConstantDefs.get(), mName); } // Also parse any attached sources for (GLSLProgramContainer::const_iterator i = mAttachedGLSLPrograms.begin(); i != mAttachedGLSLPrograms.end(); ++i) { GLSLProgram* childShader = *i; if(Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS)) { GLSLProgramPipelineManager::getSingleton().extractConstantDefs(childShader->getSource(), *mConstantDefs.get(), childShader->getName()); } else { GLSLLinkProgramManager::getSingleton().extractConstantDefs(childShader->getSource(), *mConstantDefs.get(), childShader->getName()); } } }
GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName, std::string vertString, std::string fragString) { GLSLProgram* prog = GetShader(vertName, fragName,vertString, fragString); assert(prog != NULL); prog->use(); return prog; }
GLSLProgram* ShaderManager::UseShader(const char* vertName, const char* fragName) { GLSLProgram* prog = GetShader(vertName, fragName); assert(prog != NULL); prog->use(); return prog; }
/////////////////////////////////////////////////////////////////////////////// // This function does any needed initialization on the rendering context. // This is the first opportunity to do any OpenGL related tasks. void SetupRC() { glClearColor(0.0f, 0.0f, 0.0f, 1.0f ); prog.compileShaderFromFile("subroutine.vert", GLSLShader::VERTEX); prog.compileShaderFromFile("subroutine.frag", GLSLShader::FRAGMENT); prog.link(); prog.use(); glEnable(GL_DEPTH_TEST); plane = new VBOPlane(50.0f, 50.0f, 1, 1); teapot = new VBOTeapot(14, mat4(1.0f)); view = glm::lookAt(vec3(0.0f,0.0f,10.0f), vec3(0.0f,0.0f,0.0f), vec3(0.0f,1.0f,0.0f)); prog.setUniform("Light.Position", vec4(0.0f,0.0f,0.0f,1.0f)); prog.setUniform("Light.La", 0.4f, 0.4f, 0.4f); prog.setUniform("Light.Ld", 1.0f, 1.0f, 1.0f); prog.setUniform("Light.Ls", 1.0f, 1.0f, 1.0f); prog.setUniform("Material.Kd", 0.9f, 0.5f, 0.3f); prog.setUniform("Material.Ka", 0.9f, 0.5f, 0.3f); prog.setUniform("Material.Ks", 0.8f, 0.8f, 0.8f); prog.setUniform("Material.Shininess", 100.0f); }
void HelloGLSL::customInit() { try { glslProgram.loadShader(GLSLShaderType::VERTEX, g_programName + "/" + "HelloGLSL.vert"); glslProgram.loadShader(GLSLShaderType::FRAGMENT, g_programName + "/" + "HelloGLSL.frag"); } catch (GLSLProgramException& e) { printf("%s\n", e.what()); system("pause"); exit(EXIT_FAILURE); } glslProgram.link(); glGenBuffers(1, &positionBufferObject); glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject); glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STATIC_DRAW); glGenVertexArrays(1, &vao); glBindVertexArray(vao); GLint positionLoc = glslProgram.getAttributeLocation("position"); glEnableVertexAttribArray(positionLoc); glVertexAttribPointer(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, 0); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); }
void Model::drawModel(GLSLProgram &shader) const { for (size_t i=0; i<materials_.size(); ++i) { if (materials_[i].map_Kd != "") { glUniform1f(shader("useTextureMap"), 1.0); //use texture GLint whichID[1]; glActiveTexture(GL_TEXTURE0); glGetIntegerv(GL_TEXTURE_BINDING_2D, whichID); if (whichID[0] != textures_[i]) { glBindTexture(GL_TEXTURE_2D, textures_[i]); } } else { glUniform1f(shader("useTextureMap"), 0.0); glUniform3fv(shader("materialKd"), 1 , glm::value_ptr(materials_[i].Kd)); if (shader.isActive(shader("materialKs"))) glUniform3fv(shader("materialKs"), 1 , glm::value_ptr(materials_[i].Ks)); if (shader.isActive(shader("materialKa"))) glUniform3fv(shader("materialKa"), 1 , glm::value_ptr(materials_[i].Ka)); if (shader.isActive(shader("materialNs"))) glUniform1f(shader("materialNs"), materials_[i].Ns); } if (materials_.size() == 1) glDrawElements(GL_TRIANGLES, indices_.size(), GL_UNSIGNED_SHORT, 0); else glDrawElements(GL_TRIANGLES, materials_[i].count, GL_UNSIGNED_SHORT, (const GLvoid*)(&indices_[materials_[i].offset])); } }
void OgroInvasion::customInit() { filename = g_programName + "/" + "Lenna.png"; try { glslProgram.loadShader(GLSLShaderType::VERTEX, g_programName + "/" + "shader.vert"); glslProgram.loadShader(GLSLShaderType::FRAGMENT, g_programName + "/" + "shader.frag"); } catch (GLSLProgramException& e) { printf("%s\n", e.what()); system("pause"); exit(EXIT_FAILURE); } glslProgram.link(); GLint vertexAttribLoc = glslProgram.getAttributeLocation("vVertex"); //quad vertices and indices glm::vec2 vertices[4]; GLushort indices[6]; vertices[0] = glm::vec2(0.0f, 0.0f); vertices[1] = glm::vec2(1.0f, 0.0f); vertices[2] = glm::vec2(1.0f, 1.0f); vertices[3] = glm::vec2(0.0f, 1.0f); GLushort* id = indices; *id++ = 0; *id++ = 1; *id++ = 2; *id++ = 0; *id++ = 2; *id++ = 3; glGenVertexArrays(1, &vaoID); glBindVertexArray(vaoID); glGenBuffers(1, &vboVerticesID); glGenBuffers(1, &vboIndicesID); glBindBuffer(GL_ARRAY_BUFFER, vboVerticesID); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboIndicesID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glVertexAttribPointer(vertexAttribLoc, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0)); glEnableVertexAttribArray(vertexAttribLoc); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); mTexture = new Texture(filename); mTexture->load(); mTexture->activateTexture(0); // GL_TEXTURE0 glslProgram.setUniform("textureMap", 0); // GL_TEXTURE0 }
void reloadShaders() { GLSLProgram* hold = new GLSLProgram(); hold->compileShaders("C:/Users/josh/Desktop/Shader/Shaders/vertex.glsl", "C:/Users/josh/Desktop/Shader/Shaders/fragment.glsl"); hold->addAttribute("vertexPosition"); hold->linkShaders(); _Program = *hold; }
//------------------------------------------------------------------------------ static void drawStencils() { g_samplesProgram.Use( ); const float scale = 0.02f; glUniform1f(g_samplesProgram.GetUniformScale(), scale); glUniformMatrix4fv(g_samplesProgram.GetUniformModelViewMatrix(), 1, GL_FALSE, g_transformData.ModelViewMatrix); glUniformMatrix4fv(g_samplesProgram.GetUniformProjectionMatrix(), 1, GL_FALSE, g_transformData.ProjectionMatrix); glBindVertexArray(g_stencilsVAO); glBindBuffer(GL_ARRAY_BUFFER, g_stencilOutput->BindDstBuffer()); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*9, 0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*9, (void*)(sizeof(GLfloat)*3)); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*9, (void*)(sizeof(GLfloat)*6)); glDrawArrays(GL_POINTS, 0, g_stencilOutput->GetNumStencils()); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glBindVertexArray(0); glUseProgram(0); }
void setMatrices() { mat4 mv = view * model; prog.setUniform("ModelViewMatrix", mv); prog.setUniform("NormalMatrix", mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) )); prog.setUniform("MVP", projection * mv); }
void initializeShaders() { colorProgram.compileShaders("Shaders/color.vertex", "Shaders/color.fragment"); colorProgram.addAttribute("vertexPosition"); colorProgram.addAttribute("vertexColor"); colorProgram.addAttribute("vertexUV"); colorProgram.linkShaders(); }
void Shader::setGeometryShaderParameters(Ogre::RenderOperation::OperationType in, Ogre::RenderOperation::OperationType out, int max) { GLSLProgram* t = static_cast<GLSLProgram*> (geometry.getPointer()); t->setInputOperationType(in); t->setOutputOperationType(out); t->setMaxOutputVertices(max); }
void Renderer::init(GLSLProgram & shader) { setProjectionMatrix(30,1, 1, -100, projection); shader.use(); shader.setUniformMatrix4fv("projectionMatrix", projection); shader.unuse(); }
void SkyBox::Render() { glBindVertexArray(_vao); GLSLProgram* p = _material->Program(); p->SetUniform("draw_sky_box", true); glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0); p->SetUniform("draw_sky_box", false); }
GLSLProgram* GLSLProgram::createFromStrings(const char *vertSrc, const char *fragSrc) { GLSLProgram *prog = new GLSLProgram(); if (prog->setSourceFromStrings(vertSrc, fragSrc)) { return prog; } else { delete prog; return NULL; } }
void PlaneModelData::useMaterial(GLSLProgram const& prog) const { prog.setUniform("material.ambient", *reinterpret_cast<glm::vec3 const*>(material.ambient)); prog.setUniform("material.diffuse", *reinterpret_cast<glm::vec3 const*>(material.diffuse)); prog.setUniform("material.specular", *reinterpret_cast<glm::vec3 const*>(material.specular)); prog.setUniform("material.shininess", material.shininess); glActiveTexture(GL_TEXTURE0 + 5); glBindTexture(GL_TEXTURE_2D, (GLuint) material.texture1_map.user_ptr); }
GLSLProgram* GLSLProgram::createFromFiles(const char *vertFilename, const char *fragFilename) { GLSLProgram *prog = new GLSLProgram(); if (prog->setSourceFromFiles(vertFilename, fragFilename)) { return prog; } else { delete prog; return NULL; } }
void CascadedShadowMap::sendToShader(string sShader) { GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader(sShader); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D,m_shadowMaps[0]->getTexture()); glslProgram->sendUniform("shadowMap[0]",4); glActiveTexture(GL_TEXTURE5); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D,m_shadowMaps[1]->getTexture()); glslProgram->sendUniform("shadowMap[1]",5); glActiveTexture(GL_TEXTURE6); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D,m_shadowMaps[2]->getTexture()); glslProgram->sendUniform("shadowMap[2]",6); glActiveTexture(GL_TEXTURE7); glEnable(GL_TEXTURE_2D); glBindTexture(GL_TEXTURE_2D,m_shadowMaps[3]->getTexture()); glslProgram->sendUniform("shadowMap[3]",7); glslProgram->sendUniform("slices[0]",m_nSlices[0]); glslProgram->sendUniform("slices[1]",m_nSlices[1]); glslProgram->sendUniform("slices[2]",m_nSlices[2]); m_m4LightMatrix[0] = glm::translate(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * glm::scale(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * m_m4LightMatrix[0]; m_m4LightMatrix[1] = glm::translate(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * glm::scale(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * m_m4LightMatrix[1]; m_m4LightMatrix[2] = glm::translate(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * glm::scale(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * m_m4LightMatrix[2]; m_m4LightMatrix[3] = glm::translate(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * glm::scale(glm::mat4(1.0f),glm::vec3(0.5f,0.5f,0.5f)) * m_m4LightMatrix[3]; glslProgram->sendUniform("lightMatrix[0]", &m_m4LightMatrix[0][0][0]); glslProgram->sendUniform("lightMatrix[1]", &m_m4LightMatrix[1][0][0]); glslProgram->sendUniform("lightMatrix[2]", &m_m4LightMatrix[2][0][0]); glslProgram->sendUniform("lightMatrix[3]", &m_m4LightMatrix[3][0][0]); }
GLSLProgram* ShaderManager::Load(const char* vertName, const char*fragName) { GLSLProgram* prog = new GLSLProgram(); if (!prog->compileShaderFromFile(vertName, GLSLShader::VERTEX)) { printf("Vertex shader failed to compile!\n%s", prog->log().c_str()); sLog(Level::Severe) << "Vertex shader <" << vertName << "> failed to compile." << prog->log(); assert(false && "Vertex shader failed to compile"); return NULL; } if (!prog->compileShaderFromFile(fragName, GLSLShader::FRAGMENT)) { printf("Fragment shader failed to compile!\n%s", prog->log().c_str()); sLog(Level::Severe) << "Fragment shader <" << fragName << "> failed to compile." << prog->log(); assert(false && "Fragment shader failed to compile"); return NULL; } if (!prog->link()) { printf("Shader program failed to link!\n%s", prog->log().c_str()); sLog(Level::Severe) << "Shader program failed to link." << prog->log(); assert(false && "Shader program failed to link."); return NULL; } assert(prog != NULL); return prog; }
void CascadedShadowMap::buildShadowMaps(Camera *camera, View *view, DirectLight *light) { //Profiler::getInstance()->startProfile("Build Shadow Maps"); float nSlice[] = {0.0, m_nSlices[0], m_nSlices[1], m_nSlices[2], 1.0}; Frustum *frustum = new Frustum(); frustum->getFrustum(camera, view); m_shadowMaps[3]->bind(); glClearDepth(1.0); glClear(GL_DEPTH_BUFFER_BIT); glDisable(GL_CULL_FACE); for (int i=0; i<4; i++) { Camera *lightCamera = createLightCamera(nSlice[i],nSlice[i+1],camera,view,light); View *lightView = createLightView(nSlice[i],nSlice[i+1],camera,lightCamera,view,frustum); Frustum *lightFrustum = new Frustum(); lightFrustum->getOrthoFrustum(lightCamera,lightView); MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f)); m_shadowMaps[i]->bind(); glClearDepth(1.0); glEnable(GL_DEPTH_TEST); glClear(GL_DEPTH_BUFFER_BIT); glPushAttrib( GL_VIEWPORT_BIT ); glViewport( 0, 0, m_nSize, m_nSize); lightView->use3D(false); GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("DirectShadow"); glslProgram->use(); glm::mat4 cameraMat = glm::mat4(1.0f); cameraMat = lightCamera->transformToMatrix(cameraMat); m_m4LightMatrix[i] = MatrixManager::getInstance()->getMatrix4(PROJECTION) * cameraMat; MatrixManager::getInstance()->putMatrix4(MODELVIEW, cameraMat); glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]); glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex"); SceneManager::getInstance()->draw("DirectShadow"); glslProgram->disable(); glPopAttrib(); m_shadowMaps[i]->unbind(); delete lightCamera; delete lightView; delete lightFrustum; } glEnable(GL_CULL_FACE); //Profiler::getInstance()->endProfile(); }
void Actor::drawActor(string sShader) { GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader(sShader); glslProgram->sendUniform("modelviewMatrix", &MatrixManager::getInstance()->getMatrix4(MODELVIEW)[0][0]); if (sShader == "Basic" || sShader == "GBuffer" || sShader == "BuildVoxels") { glslProgram->sendUniform("normalMatrix", &MatrixManager::getInstance()->getMatrix3(NORMAL)[0][0],false,3); MaterialManager::getInstance()->getMaterial(*m_psMaterial)->sendToShader(sShader); } ModelManager::getInstance()->getModel(*m_psModel)->draw(); }
void HelloGLSL::onRender() { glslProgram.use(); glBindVertexArray(vao); glDrawArrays(GL_TRIANGLES, 0, 3); glslProgram.unUse(); glBindVertexArray(0); }
/////////////////////////////////////////////////////////////////////////////// // Called to draw scene void RenderScene(void) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); mat4 mv = view * model; prog.setUniform("ModelViewMatrix", mv); prog.setUniform("NormalMatrix", mat3( vec3(mv[0]), vec3(mv[1]), vec3(mv[2]) )); prog.setUniform("MVP", projection * mv); current->render(); }
void OgroInvasion::onRender() { glslProgram.use(); glBindVertexArray(vaoID); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, nullptr); glBindVertexArray(0); glslProgram.unUse(); }
void glslProcess() { GLSLProgram glprog; glprog.SetGstap(true); glprog.SetVerbose(true); if(!glprog.Create("D:\\v0.vert", "D:\\v0.frag")) { return ; } glprog.Use(); }
void MainGraphicsWidget::voxelRender() { VoxelGrid::getInstance()->buildVoxels(m_lightBuffer->getLight()); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); MatrixManager::getInstance()->putMatrix4(MODELVIEW, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix4(PROJECTION, glm::mat4(1.0f)); MatrixManager::getInstance()->putMatrix3(NORMAL, glm::mat3(1.0f)); view->viewport(); view->use3D(true); camera->transform(); GLSLProgram *glslProgram = ShaderManager::getInstance()->getShader("Voxel"); glslProgram->use(); glBindFragDataLocation(glslProgram->getHandle(), 0, "fragColor"); glBindAttribLocation(glslProgram->getHandle(), 0, "v_vertex"); glslProgram->sendUniform("projectionMatrix", &MatrixManager::getInstance()->getMatrix4(PROJECTION)[0][0]); glslProgram->sendUniform("modelviewMatrix", &MatrixManager::getInstance()->getMatrix4(MODELVIEW)[0][0]); glm::mat4 cameraInverse = glm::mat4(1.0); cameraInverse = camera->transformToMatrix(cameraInverse); cameraInverse = glm::inverse(cameraInverse); glslProgram->sendUniform("invCameraMatrix", &cameraInverse[0][0]); glslProgram->sendUniform("worldSize", WORLD_SIZE); //glslProgram->sendUniform("numVoxels", VOXEL_SIZE); //glslProgram->sendUniform("mipLevel", VoxelGrid::getInstance()->getMipLevel()); int mipFactor = pow(2.0, VoxelGrid::getInstance()->getMipLevel()); glActiveTexture(GL_TEXTURE8); glEnable(GL_TEXTURE_3D); VoxelGrid::getInstance()->bind(VoxelGrid::getInstance()->getMipLevel()); glslProgram->sendUniform("voxelmap", 8); //glEnable(GL_POINT_SMOOTH); glPointSize(10.0f*mipFactor); float voxelWidth = (float)WORLD_SIZE / (float)VOXEL_SIZE * mipFactor; glBegin(GL_POINTS); for (float x=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); x<(WORLD_SIZE/2.0); x+=voxelWidth) { for (float y=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); y<(WORLD_SIZE/2.0); y+=voxelWidth) { for (float z=-(WORLD_SIZE/2.0)+(voxelWidth/2.0); z<(WORLD_SIZE/2.0); z+=voxelWidth) { glVertex3f(x,y,z); } } } glEnd(); glslProgram->disable(); }
void PlaneModelData::drawInstances(GLSLProgram const& prog) const { glBindVertexArray(modelVAO); useMaterial(prog); BOOST_FOREACH(DrawInstance const& inst, drawInst) { prog.setUniform("modelMatrix", inst.modelMatrix); prog.setUniform("tint", inst.tint); glDrawElements(GL_TRIANGLE_STRIP, NUM_INDICES, GL_UNSIGNED_BYTE, NULL); }
//----------------------------------------------------------------------- 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; } }