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();
}
}
void R_ShutdownGamma(void)
{
if (gammaProgram.program)
{
if (gammaProgram.vertexShader)
{
glDetachObjectARB(gammaProgram.program, gammaProgram.vertexShader);
qglDeleteObjectARB(gammaProgram.vertexShader);
}
if (gammaProgram.fragmentShader)
{
glDetachObjectARB(gammaProgram.program, gammaProgram.fragmentShader);
qglDeleteObjectARB(gammaProgram.fragmentShader);
}
qglDeleteObjectARB(gammaProgram.program);
Com_Memset(&gammaProgram, 0, sizeof(shaderProgram_t));
}
if (screenImage)
{
screenImage = NULL;
}
}
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;
}
static inline void r_destroy_program(uint prog, uint vs, uint fs) {
OPENGL_EVENT_BEGIN(0, __PRETTY_FUNCTION__);
glDetachObjectARB(prog, vs);
glDetachObjectARB(prog, fs);
glDeleteObjectARB(vs);
glDeleteObjectARB(fs);
glDeleteObjectARB(prog);
OPENGL_EVENT_END();
}
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);
}
}
void
ShaderModeData::FreeResources()
{
// Free the program.
if(GLSL_shaders_setup)
{
glDetachObjectARB(p, v);
glDetachObjectARB(p, f);
glDeleteObjectARB(v);
glDeleteObjectARB(f);
glDeleteObjectARB(p);
GLSL_shaders_setup = false;
}
}
void C4Shader::Clear()
{
#ifndef USE_CONSOLE
if (!hProg) return;
// Need to be detached, then deleted
glDetachObjectARB(hProg, hFrag);
glDetachObjectARB(hProg, hVert);
glDeleteObjectARB(hFrag);
glDeleteObjectARB(hVert);
glDeleteObjectARB(hProg);
hFrag = hVert = hProg = 0;
// Clear uniform data
delete[] pUniforms; pUniforms = NULL;
iUniformCount = 0;
#endif
}
GPU::Shader& GPU::Shader::DetachGeomPg()
{
if( m_Id && m_GeomPg.IsInstantiated() )
glDetachObjectARB( m_Id, m_GeomPg.Id() );
m_GeomPg.Release();
return *this;
}
GLuint GLUtil::CreateShaderProgram(GLuint *shaderList, int nShaders) {
if (nShaders > 0) {
GLuint program = glCreateProgramObjectARB();
// attach list of compiled shaders to the shader program
for(size_t iLoop = 0; iLoop < nShaders; iLoop++)
glAttachObjectARB(program, shaderList[iLoop]);
//glBindAttribLocationARB(*program, 0, "position");
glLinkProgramARB(program);
// debugging
if (true)
{
GLchar *strInfoLog = new GLchar[1000];
GLsizei nChars;
glGetInfoLogARB(program, 999, &nChars, strInfoLog);
strInfoLog[999] = '\0';
if (nChars != 0) {
Console::getInstance()->message(CONSOLE_MSG_SYS, "GLSL Linker: %s", strInfoLog);
}
delete[] strInfoLog;
}
// the shaders are no longer needed by the program once compiled
for(size_t iLoop = 0; iLoop < nShaders; iLoop++)
glDetachObjectARB(program, shaderList[iLoop]);
return program;
}
return 0;
}
/*
* link - Link the shader object.
*
* return - bool
*/
bool ShaderObject::link(void) {
if (linked) {
std::cout << "**warning** Object is already linked, trying to link again" << std::endl;
for (int i = 0; i < shaderList.size(); i++) {
glDetachObjectARB(shaderObject, shaderList[i]->getProgramObject());
CHECK_GL_ERROR();
}
}
for (int i = 0; i < shaderList.size(); i++) {
glAttachObjectARB(shaderObject, shaderList[i]->getProgramObject());
CHECK_GL_ERROR();
}
int linkStatus;
glLinkProgramARB(shaderObject);
CHECK_GL_ERROR();
glGetObjectParameterivARB(shaderObject, GL_OBJECT_LINK_STATUS_ARB, &linkStatus);
CHECK_GL_ERROR();
if (linkStatus) {
linked = true;
return true;
} else {
std::cout << "**linker error**" << std::endl;
}
return false;
} // end link()
static int program_detach(lua_State *L)
{
shader_type *p = (shader_type*)lua_touserdata(L, 1);
GLuint *s = (GLuint*)auxiliar_checkclass(L, "gl{shader}", 2);
glDetachObjectARB(p->shader, *s);
return 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;
}
}
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;
}
//--------------------------------------------------------------------------------------
// Método para liberar un programa de la memoria de la tarjeta.
//--------------------------------------------------------------------------------------
void CShaderProgram::Release (void)
{
if(this->vertex.GetHandle())
{
glDetachObjectARB(this->program, this->vertex.GetHandle());
this->vertex.Release();
}
if(this->fragment.GetHandle())
{
glDetachObjectARB(this->program, this->fragment.GetHandle());
this->fragment.Release();
}
if(this->program)
{
glDeleteObjectARB(this->program);
this->program = 0;
}
}
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);
}
void CGLSLLoader::ClearShader(void)
{
if(!g_PO)
return;
if(glIsProgram(g_PO)!=GL_FALSE)
{
if(glIsShader(g_VS)!=GL_FALSE){ glDetachObjectARB(g_PO,g_VS); glDeleteObjectARB(g_VS);}
if(glIsShader(g_TC)!=GL_FALSE){ glDetachObjectARB(g_PO,g_TC); glDeleteObjectARB(g_TC);}
if(glIsShader(g_TE)!=GL_FALSE){ glDetachObjectARB(g_PO,g_TE); glDeleteObjectARB(g_TE);}
if(glIsShader(g_GS)!=GL_FALSE){ glDetachObjectARB(g_PO,g_GS); glDeleteObjectARB(g_GS);}
if(glIsShader(g_PS)!=GL_FALSE){ glDetachObjectARB(g_PO,g_PS); glDeleteObjectARB(g_PS);}
glDeleteObjectARB(g_PS);
}
g_VS=0;
g_TC=0;
g_TE=0;
g_GS=0;
g_PS=0;
g_PO=0;
}
void shader::reload()
{
GLenum err;
//std::cerr << "reloading " << vert << ", " << frag << std::endl;
glDetachObjectARB(shaderobj, vertexshader);
glDetachObjectARB(shaderobj, fragmentshader);
vertexshader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
fragmentshader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
char * source;
source = GetSource(vert);
glShaderSourceARB(vertexshader, 1, (const GLcharARB**)&source, NULL);
source = GetSource(frag);
glShaderSourceARB(fragmentshader, 1, (const GLcharARB**)&source, NULL);
// compile the fragment and vertex shader
glCompileShader(vertexshader);
glCompileShader(fragmentshader);
// attach shaders to shader obj
glAttachObjectARB(shaderobj, vertexshader);
glAttachObjectARB(shaderobj, fragmentshader);
// link the shader obj and check status
glLinkProgramARB(shaderobj);
printInfoLog(shaderobj);
//t_tex = 0;
for(size_t i=0; i<value.size(); i++)
{
if(type.at(i)=='t') continue;//n_tex++;
setUniform(i,value.at(i));
}
if((err=glGetError())!=0) {
printf("\n%s: %d\n", __func__, __LINE__);
exit(1);
}
}
MOboolean moShaderGLSL::Finish()
{
if (m_VertexShader != 0)
{
glDetachObjectARB(m_ProgramObject, m_VertexShader);
m_VertexShader = 0;
}
if (m_FragmentShader != 0)
{
glDetachObjectARB(m_ProgramObject, m_FragmentShader);
m_FragmentShader = 0;
}
if(m_ProgramObject != 0)
{
glDeleteObjectARB(m_ProgramObject);
m_ProgramObject = 0;
}
return moShader::Finish();
}
/*
* ~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()
CShaderMngr::~CShaderMngr(void)
{
for (auto iter = m_Shaders.begin(); iter != m_Shaders.end(); iter++) {
glDetachObjectARB(iter->second->nProgID, iter->second->nShaderID);
glDeleteObjectARB(iter->second->nProgID);
glDeleteObjectARB(iter->second->nShaderID);
delete iter->second;
}
m_Shaders.clear();
}
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);
}
ShaderProgram::~ShaderProgram()
{
Uniform::Iter ui = uniforms.begin();
for (; ui != uniforms.end(); ++ui) {
delete ui->second;
}
Shader::Iter si = shaders.begin();
for (; si != shaders.end(); ++si) {
glDetachObjectARB(handle, (*si)->getHandle());
delete *si;
}
glDeleteObjectARB(handle);
}
void GlProgram::
clear()
{
//detach all the shaders from the program
for (ShaderHandle it=shaders.begin(); it!=shaders.end(); ++it)
glDetachObjectARB(program, *it);
//delete the program
glDeleteObjectARB(program);
//delete all the shaders
for (ShaderHandle it=shaders.begin(); it!=shaders.end(); ++it)
glDeleteObjectARB(*it);
shaders.clear();
}
void GLShader::reset(void)
{
/* Check if the program has already been linked: */
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);
programObject=0;
}
/* Delete all shaders: */
for(HandleList::iterator vsoIt=vertexShaderObjects.begin();vsoIt!=vertexShaderObjects.end();++vsoIt)
glDeleteObjectARB(*vsoIt);
vertexShaderObjects.clear();
for(HandleList::iterator fsoIt=fragmentShaderObjects.begin();fsoIt!=fragmentShaderObjects.end();++fsoIt)
glDeleteObjectARB(*fsoIt);
fragmentShaderObjects.clear();
}
bool GLSLShader::ReCompileShaders( const char* vertex_file, const char* fragment_file )
{
FILE *fp = nullptr;
/*
fopen_s(&fp, vertex_file, "r");
if (fp)
{
if (vertex)
if (!LoadShader( vertex, fp ) ) {
fclose(fp);
return false;
}
fclose(fp);
}
*/
fopen_s(&fp, fragment_file, "r");
if (fp)
{
if (fragment)
glDetachObjectARB( programObj, fragment );
glDeleteObjectARB( fragment );
fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );
if (!LoadShader( fragment, fp ) ) {
fclose(fp);
return false;
}
fclose(fp);
// attach shader to program object
glAttachObjectARB( programObj, fragment );
GLint linked;
// link the program object and print out the info log
glLinkProgramARB( programObj );
glGetObjectParameterivARB( programObj, GL_OBJECT_LINK_STATUS_ARB, &linked );
loadlog( programObj );
return (linked != 0);
}
return true;
}
/// 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;
}
}
GPU::Shader& GPU::Shader::Attach( const PgObject &pg )
{
PgObject *dst = NULL;
switch( pg.Type() )
{
case GL_VERTEX_SHADER_ARB: dst = &m_VertPg; break;
case GL_FRAGMENT_SHADER_ARB: dst = &m_FragPg; break;
case GL_GEOMETRY_SHADER_EXT: dst = &m_GeomPg; break;
}
if( dst )
{
if( m_Id && dst->IsInstantiated() )
glDetachObjectARB( m_Id, dst->Id() );
*dst = pg;
}
return *this;
}
int main(int argc, char **argv)
{
float r = 0.5, g = 0.5, b = 1, ratio = 0;
int dir = 1;
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *mysha;
ALLEGRO_BITMAP *buffer;
const char *tinter_shader_src[] = {
"uniform sampler2D backBuffer;",
"uniform float r;",
"uniform float g;",
"uniform float b;",
"uniform float ratio;",
"void main() {",
" vec4 color;",
" float avg, dr, dg, db;",
" color = texture2D(backBuffer, gl_TexCoord[0].st);",
" avg = (color.r + color.g + color.b) / 3.0;",
" dr = avg * r;",
" dg = avg * g;",
" db = avg * b;",
" color.r = color.r - (ratio * (color.r - dr));",
" color.g = color.g - (ratio * (color.g - dg));",
" color.b = color.b - (ratio * (color.b - db));",
" gl_FragColor = color;",
"}"
};
const int TINTER_LEN = 18;
double start;
GLint loc;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro\n");
}
al_install_keyboard();
al_init_image_addon();
al_set_new_display_flags(ALLEGRO_OPENGL);
display = al_create_display(320, 200);
if (!display) {
abort_example("Error creating display\n");
}
mysha = al_load_bitmap("data/mysha.pcx");
if (!mysha) {
abort_example("Could not load image.\n");
}
buffer = al_create_bitmap(320, 200);
if (!al_have_opengl_extension("GL_EXT_framebuffer_object")
&& !al_have_opengl_extension("GL_ARB_fragment_shader")) {
abort_example("Fragment shaders not supported.\n");
}
tinter_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
glShaderSourceARB(tinter_shader, TINTER_LEN, tinter_shader_src, NULL);
glCompileShaderARB(tinter_shader);
tinter = glCreateProgramObjectARB();
glAttachObjectARB(tinter, tinter_shader);
glLinkProgramARB(tinter);
loc = glGetUniformLocationARB(tinter, "backBuffer");
glUniform1iARB(loc, al_get_opengl_texture(buffer));
start = al_get_time();
while (1) {
double now, diff;
ALLEGRO_KEYBOARD_STATE state;
al_get_keyboard_state(&state);
if (al_key_down(&state, ALLEGRO_KEY_ESCAPE)) {
break;
}
now = al_get_time();
diff = now - start;
start = now;
ratio += diff * 0.5 * dir;
if (dir < 0 && ratio < 0) {
ratio = 0;
dir = -dir;
}
else if (dir > 0 && ratio > 1) {
ratio = 1;
dir = -dir;
}
al_set_target_bitmap(buffer);
glUseProgramObjectARB(tinter);
loc = glGetUniformLocationARB(tinter, "ratio");
glUniform1fARB(loc, ratio);
loc = glGetUniformLocationARB(tinter, "r");
glUniform1fARB(loc, r);
loc = glGetUniformLocationARB(tinter, "g");
glUniform1fARB(loc, g);
loc = glGetUniformLocationARB(tinter, "b");
glUniform1fARB(loc, b);
al_draw_bitmap(mysha, 0, 0, 0);
glUseProgramObjectARB(0);
al_set_target_backbuffer(display);
al_draw_bitmap(buffer, 0, 0, 0);
al_flip_display();
al_rest(0.001);
}
glDetachObjectARB(tinter, tinter_shader);
glDeleteObjectARB(tinter_shader);
al_uninstall_system();
return 0;
}
