Example #1
0
	//-----------------------------------------------------------------------
	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;
		}
	}
Example #2
0
	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);
	}
Example #3
0
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;
   }
}
Example #4
0
 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;
}
Example #6
0
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;
}
Example #7
0
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;
}
Example #8
0
    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;
    }
Example #9
0
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;
	}
}
Example #10
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);
}
Example #11
0
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;
}
Example #12
0
 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";
     }
 }
Example #13
0
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;
}
Example #15
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);
    }
Example #16
0
//----------------------------------------------------------------------------
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");
}
Example #18
0
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;
}
Example #19
0
File: SHADER.CPP Project: CGSG/TLR
/* 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 */
Example #20
0
	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);
	}
Example #21
0
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();
    }
  }
}
Example #22
0
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());
	}
}
Example #24
0
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]);
    }
}
Example #25
0
//! 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);
}
Example #26
0
/* 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 */
Example #27
0
/* ‘ункци¤ удалени¤ шейдерной программы.
 * ј–√”ћ≈Ќ“џ:
 *   - идентификатор загруженной программы:
 *       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;
}
Example #29
0
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());
    } 
}
Example #30
0
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);
    }
}