void GPU::Shader::Release()
{
if( m_Id )
{
if( m_VertPg.Id() )
{
glDetachObjectARB( m_Id, m_VertPg.Id() );
m_VertPg.Release();
}
if( m_FragPg.Id() )
{
glDetachObjectARB( m_Id, m_FragPg.Id() );
m_FragPg.Release();
}
if( m_GeomPg.Id() )
{
glDetachObjectARB( m_Id, m_GeomPg.Id() );
m_GeomPg.Release();
}
glDeleteObjectARB( m_Id );
m_Id = 0;
m_Uniforms.clear();
m_Attributes.clear();
}
}
CGLMShaderPair::~CGLMShaderPair( )
{
if (m_program)
{
glDeleteObjectARB( (GLhandleARB)m_program );
m_program = 0;
}
}
Shader::~Shader()
{
ensureGlContext();
// Destroy effect program
if (m_shaderProgram)
glCheck(glDeleteObjectARB(m_shaderProgram));
}
//--------------------------------------------------------------------------------------
// Método para liberar un shader de la memoria de la tarjeta.
//--------------------------------------------------------------------------------------
void CShaderObject::Release (void)
{
if(this->shader)
{
glDeleteObjectARB(this->shader);
this->shader = 0;
}
}
static void
_cogl_shader_free (CoglShader *shader)
{
/* Frees shader resources but its handle is not
released! Do that separately before this! */
_COGL_GET_CONTEXT (ctx, NO_RETVAL);
glDeleteObjectARB (shader->gl_handle);
}
void ShaderProgramGl::end(){
if(inited){
assertGl();
glDeleteObjectARB(handle);
assertGl();
inited= false;
}
}
Shader::~Shader()
{
EnsureGlContext();
// Destroy effect program
if (myShaderProgram)
GLCheck(glDeleteObjectARB(myShaderProgram));
}
/////////////////////////////////////////////////////////
// LinkProgram
//
/////////////////////////////////////////////////////////
bool glsl_program :: LinkARB()
{
int i;
GLsizei length=0;
GLint infoLength;
if(m_programARB) {
glDeleteObjectARB( m_programARB );
gem::utils::glsl::delshader(m_programARB);
m_programARB = 0;
}
m_programARB = glCreateProgramObjectARB();
for (i = 0; i < m_num; i++)
{
glAttachObjectARB( m_programARB, m_shaderObjARB[i] );
}
/* setup geometry shader */
if(glProgramParameteriEXT) {
glProgramParameteriEXT(m_program,GL_GEOMETRY_INPUT_TYPE_EXT,m_geoInType);
glProgramParameteriEXT(m_program,GL_GEOMETRY_OUTPUT_TYPE_EXT,m_geoOutType);
int temp=m_geoOutVertices;
if(temp<0)
glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT,&temp);
glProgramParameteriEXT(m_program,GL_GEOMETRY_VERTICES_OUT_EXT,temp);
}
glLinkProgramARB( m_programARB );
glGetObjectParameterivARB( m_programARB, GL_OBJECT_LINK_STATUS_ARB, &m_linked );
glGetObjectParameterivARB( m_programARB, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infoLength );
GLcharARB*infoLogARB = new GLcharARB[infoLength];
glGetInfoLogARB( m_programARB, infoLength, &length, infoLogARB );
if (length)
{
post("Info_log:");
post("%s", infoLogARB);
}
//post("freeing log");
if(infoLogARB)delete[]infoLogARB;infoLogARB=NULL;
//
// If all went well, make the ProgramObject part of the current state
//
//post("did we link?");
if (m_linked) {
glUseProgramObjectARB( m_programARB );
} else {
glUseProgramObjectARB( 0 );
post("ARB Link failed!");
return false;
}
return true;
}
//-----------------------------------------------------------------------
void GLSLProgram::unloadHighLevelImpl(void)
{
if (isSupported())
{
glDeleteObjectARB(mGLHandle);
}
}
static int shader_free(lua_State *L)
{
GLuint *s = (GLuint*)auxiliar_checkclass(L, "gl{shader}", 1);
glDeleteObjectARB(*s);
lua_pushnumber(L, 1);
return 1;
}
/*virtual*/
void
Shader::removeFromContext(unsigned int contextId)
{
if (handleInContextExists(contextId))
{
glDeleteObjectARB(getResourceHandleForContext(contextId));
setResourceHandleForContext(0, contextId);
}
}
/** * Standard Destructor. * Cleans up the memory automatically. * \param void * \return void * \author <a href="mailto:[email protected]">Jens Schneider</a> * \date Aug.2004 */ GLSLProgram::~GLSLProgram() { if (IsValid()) { if (m_bGLUseARB) glDeleteObjectARB(m_hProgram); else glDeleteProgram(m_hProgram); } m_hProgram=0; }
void ofxShader::unload() {
if (vertexShader) {
glDetachObjectARB(shader, vertexShader);
glDeleteObjectARB(vertexShader);
vertexShader = NULL;
}
if (fragmentShader) {
glDetachObjectARB(shader, fragmentShader);
glDeleteObjectARB(fragmentShader);
fragmentShader = NULL;
}
if (shader) {
glDeleteObjectARB(shader);
shader = NULL;
}
}
STShaderProgram::~STShaderProgram()
{
if(GLEW_VERSION_2_0)
glDeleteProgram(programid);
#ifndef __APPLE__
else
glDeleteObjectARB(programid);
#endif
}
Shader * Shader::loadShader(string name)
{
Shader * s = new Shader();
for (int i = 0; i < 5; i++) name.pop_back();
s->name = name;
string vertPath = name + ".vert";
string fragPath = name + ".frag";
//Start with a handle for the shader program...
GLhandleARB shaderProgramHandle = glCreateProgramObjectARB ();
//glBindAttribLocation (shaderProgramHandle, 0, "mg_vertex");
//glBindAttribLocation (shaderProgramHandle, 1, "uv");
// use glGetAttribLocation instead
GLhandleARB vertObject = makeShader(vertPath.c_str(), GL_VERTEX_SHADER);
GLhandleARB fragObject = makeShader(fragPath.c_str(), GL_FRAGMENT_SHADER);
glAttachObjectARB(shaderProgramHandle, vertObject);
glAttachObjectARB(shaderProgramHandle, fragObject);
glLinkProgramARB (shaderProgramHandle);
//Find out if compilation worked and return the program handle if it did...
int status; glGetObjectParameterivARB (shaderProgramHandle, GL_OBJECT_LINK_STATUS_ARB, &status);
if (status != 0)
{
//return shaderProgramHandle; //Everything OK...
s->shaderProgram = shaderProgramHandle;
s->vertexShader = vertObject;
s->fragmentShader = fragObject;
return s;
}
//It didn't, so log error information...
//::log ("\nFailed to link shader \"%s\"...", name.c_str ());
int length = 0;
glGetObjectParameterivARB (shaderProgramHandle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
glBindFragDataLocation(shaderProgramHandle, 0, "outColour");
const long MAXIMUM_LOG_STRING = 1024; char logString [MAXIMUM_LOG_STRING];
GLsizei messageLength = min (length, MAXIMUM_LOG_STRING);
if (messageLength > 0) {
glGetInfoLogARB (shaderProgramHandle, messageLength, 0, logString);
}
//and detach what was previously attached and discard the program handle that was obtained...
glDetachObjectARB(shaderProgramHandle, fragObject);
glDetachObjectARB(shaderProgramHandle, vertObject);
glDeleteObjectARB (shaderProgramHandle); //Should also detach the attached handles...
return NULL;
}
GLhandleARB ccShaderARB::LoadShaderARB(GLenum type, const char *filename)
{
//Shader creation
GLhandleARB shader = glCreateShaderObjectARB(type);
if(shader == 0)
{
//ccLog::Error("Can't create shader!");
return 0;
}
//code loading
char *src = ReadShaderFile(filename);
if(!src)
{
glDeleteObjectARB(shader);
return 0;
}
glShaderSourceARB(shader, 1, (const GLcharARB**)&src, NULL);
glCompileShaderARB(shader);
//we don't need the program code anymore
delete[] src;
src=0;
//we must check compilation result
/*GLint status = GL_TRUE;
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if(status != GL_TRUE)
{
//log size
GLsizei logSize;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logSize);
//buffer to get log from OpenGL
char* log = new char[logSize+1];
if(!log)
{
ccLog::Warning("Not enough memory to log shader creation...");
return 0;
}
memset(log, 0, logSize+1);
glGetShaderInfoLog(shader, logSize, &logSize, log);
ccLog::Error("Can't compile shader (file:'%s').\nLog: %s",filename,log);
//free memory
delete[] log;
glDeleteShader(shader);
return 0;
}
//*/
return shader;
}
/// This function frees all of our shader data
void GLSLShader::Release()
{
for (std::map<GLint,GLhandleARB>::const_iterator it = m_hShaders.begin(), itend = m_hShaders.end(); it != itend; ++it)
{
GLhandleARB shader = it->second;
if (shader && m_hProgramObject)
glDetachObjectARB(m_hProgramObject, shader);
if (shader)
glDeleteObjectARB(shader);
}
m_hShaders.clear();
// If our program object pointer is valid, free it
if(m_hProgramObject)
{
glDeleteObjectARB(m_hProgramObject);
m_hProgramObject = 0;
}
}
void ofxShader::unload() {
if(bLoaded) {
if (vertexShader) {
glDetachObjectARB(shader, vertexShader);
glDeleteObjectARB(vertexShader);
vertexShader = 0;
}
if (fragmentShader) {
glDetachObjectARB(shader, fragmentShader);
glDeleteObjectARB(fragmentShader);
fragmentShader = 0;
}
if (shader) {
glDeleteObjectARB(shader);
shader = 0;
}
}
bLoaded = false;
}
void crossfader_term(struct crossfader * crossfader) {
GLenum e;
glDeleteTextures(1, &crossfader->tex_output);
glDeleteFramebuffersEXT(1, &crossfader->fb);
glDeleteObjectARB(crossfader->shader);
if((e = glGetError()) != GL_NO_ERROR) FAIL("OpenGL error: %s\n", gluErrorString(e));
memset(crossfader, 0, sizeof *crossfader);
}
void ccShaderARB::reset()
{
if (prog>0)
{
if (vert)
glDetachObjectARB(prog, vert);
if (frag)
glDetachObjectARB(prog, frag);
glDeleteObjectARB(prog);
}
prog=0;
if (vert)
glDeleteObjectARB(vert);
vert=0;
if (frag)
glDeleteObjectARB(frag);
frag=0;
}
void GlProgram::
removeShader(ShaderHandle& handle)
{
//remove the shader from the program
glDetachObjectARB(program, *handle);
//delete the shader
glDeleteObjectARB(*handle);
shaders.erase(handle);
//invalidate the handle
handle = shaders.end();
}
GLShader::~GLShader(void)
{
if(programObject!=0)
{
/* Detach all shaders from the shader program: */
for(HandleList::iterator vsoIt=vertexShaderObjects.begin();vsoIt!=vertexShaderObjects.end();++vsoIt)
glDetachObjectARB(programObject,*vsoIt);
for(HandleList::iterator fsoIt=fragmentShaderObjects.begin();fsoIt!=fragmentShaderObjects.end();++fsoIt)
glDetachObjectARB(programObject,*fsoIt);
/* Delete the shader program: */
glDeleteObjectARB(programObject);
}
/* Delete all shaders: */
for(HandleList::iterator vsoIt=vertexShaderObjects.begin();vsoIt!=vertexShaderObjects.end();++vsoIt)
glDeleteObjectARB(*vsoIt);
for(HandleList::iterator fsoIt=fragmentShaderObjects.begin();fsoIt!=fragmentShaderObjects.end();++fsoIt)
glDeleteObjectARB(*fsoIt);
}
VolumeRayCasting::DataItem::~DataItem(void)
{
/* Delete the display lists: */
glDeleteLists(displayListIds[0],3);
if(haveShaders)
{
/* Delete the shaders: */
glDeleteObjectARB(rayCastingShader);
}
}
void Shader::setup(const char *vs, const char *fs)
{
//Create two new Shader Object IDs
GLhandleARB vid = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
GLhandleARB fid = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
//Pass the shader source code to OpenGL
glShaderSourceARB(vid, 1, &vs, 0);
glShaderSourceARB(fid, 1, &fs, 0);
//Compile the shader files
glCompileShaderARB(vid);
glCompileShaderARB(fid);
char glslLog[1024];
GLsizei glslLogSize;
//Get the error log for the Vertex shader
glGetInfoLogARB(vid, 1024, &glslLogSize, glslLog);
if (glslLogSize)
std::cerr << "Vertex program log: " << glslLog << std::endl;
//Get the error log for the Fragment shader
glGetInfoLogARB(fid, 1024, &glslLogSize, glslLog);
if (glslLogSize)
std::cerr << "Fragment program log: " << glslLog << std::endl;
//Create a new Shader Program
pid = glCreateProgramObjectARB();
//Attach the Vertex and Fragment shaders to the Shader Program
glAttachObjectARB(pid, vid);
glAttachObjectARB(pid, fid);
//Delete shader objects since they have been attached to a program
glDeleteObjectARB(vid);
glDeleteObjectARB(fid);
//Link it!
glLinkProgramARB(pid);
}
void GLSLShaders::unloadShaders()
{
if (!_shadersLoaded)
return;
LBASSERT(_glewContext);
LBASSERT(_program);
glDeleteObjectARB(_program);
_shadersLoaded = false;
_program = 0;
}
static bool CompileShaderObject(GLhandleARB *ShaderHandle,
GLenum ShaderType,
GLsizei SrcStringsCount,
const GLcharARB **SrcStrings)
{
bool Result;
#ifdef USE_OPENGL_20
*ShaderHandle = glCreateShader(ShaderType);
#else
*ShaderHandle = glCreateShaderObjectARB(ShaderType);
#endif
if (*ShaderHandle != 0)
{
GLint CompileStatus;
#ifdef USE_OPENGL_20
glShaderSource(*ShaderHandle,SrcStringsCount,SrcStrings,NULL);
glCompileShader(*ShaderHandle);
glGetShaderiv(*ShaderHandle,GL_COMPILE_STATUS,&CompileStatus);
#else
glShaderSourceARB(*ShaderHandle,SrcStringsCount,SrcStrings,NULL);
glCompileShaderARB(*ShaderHandle);
glGetObjectParameterivARB( *ShaderHandle,
GL_OBJECT_COMPILE_STATUS_ARB,
&CompileStatus);
#endif
Result = CompileStatus;
DumpInfoLog(*ShaderHandle);
if (!Result)
{
#ifdef USE_OPENGL_20
glDeleteShader(*ShaderHandle);
#else
glDeleteObjectARB(*ShaderHandle);
#endif
*ShaderHandle = 0;
}
}
else
{
Result = false;
fprintf(stderr,"error: unable to create GLSL shader object\n");
}
return(Result);
}
/*
* ~ShaderObject - Destructor for ShaderObject.
*/
ShaderObject::~ShaderObject(void) {
if (linkerLog != 0)
free(linkerLog);
for (int i = 0; i < shaderList.size(); i++) {
glDetachObjectARB(shaderObject, shaderList[i]->getProgramObject());
CHECK_GL_ERROR();
if (manageMemory)
delete shaderList[i];
}
glDeleteObjectARB(shaderObject);
CHECK_GL_ERROR();
} // end ~ShaderObject()
void InitScene (void)
{
prog = glCreateProgramObjectARB ();
vert = glCreateShaderObjectARB (GL_VERTEX_SHADER_ARB);
glAttachObjectARB (prog, vert);
glDeleteObjectARB (vert);
load_test_file ("vstest.txt");
glLinkProgramARB (prog);
if (!CheckObjectStatus (prog))
exit (0);
glUseProgramObjectARB (prog);
}
void ClearShaderObject(GLhandleARB GLSL_PO,GLhandleARB Attach_VS,GLhandleARB Attach_TC,GLhandleARB Attach_TE,GLhandleARB Attach_GS,GLhandleARB Attach_PS)
{
if(glIsProgram(GLSL_PO)!=GL_FALSE)
{
if(glIsShader(Attach_VS)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_VS);}
if(glIsShader(Attach_TC)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_TC);}
if(glIsShader(Attach_TE)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_TE);}
if(glIsShader(Attach_GS)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_GS);}
if(glIsShader(Attach_PS)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_PS);}
glDeleteObjectARB(GLSL_PO);
}
}
GLGeometryShader::~GLGeometryShader(void)
{
if(programObject!=0)
{
/* Detach all geometry shaders from the shader program: */
for(HandleList::iterator gsoIt=geometryShaderObjects.begin();gsoIt!=geometryShaderObjects.end();++gsoIt)
glDetachObjectARB(programObject,*gsoIt);
}
/* Delete all geometry shaders: */
for(HandleList::iterator gsoIt=geometryShaderObjects.begin();gsoIt!=geometryShaderObjects.end();++gsoIt)
glDeleteObjectARB(*gsoIt);
}
