/////////////////////////////////////////////////////////////////
// Load a pair of shaders, compile, and link together. Specify the complete
// path and file name of each ASCII shader file. Note, there is no support for
// just loading say a vertex program... you have to do both.
GLhandleARB gltLoadShaderPair(const char *szVertexProg, const char *szFragmentProg)
{
// Temporary Shader objects
GLhandleARB hVertexShader;
GLhandleARB hFragmentShader;
GLhandleARB hReturn = 0;
GLint testVal;
// Create shader objects
hVertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
hFragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
// Load them. If fail clean up and return null
if(bLoadShaderFile(szVertexProg, hVertexShader) == false)
{
glDeleteObjectARB(hVertexShader);
glDeleteObjectARB(hFragmentShader);
return NULL;
}
if(bLoadShaderFile(szFragmentProg, hFragmentShader) == false)
{
glDeleteObjectARB(hVertexShader);
glDeleteObjectARB(hFragmentShader);
return NULL;
}
// Compile them
glCompileShaderARB(hVertexShader);
glCompileShaderARB(hFragmentShader);
// Check for errors
glGetObjectParameterivARB(hVertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &testVal);
if(testVal == GL_FALSE)
{
glDeleteObjectARB(hVertexShader);
glDeleteObjectARB(hFragmentShader);
return NULL;
}
glGetObjectParameterivARB(hFragmentShader, GL_OBJECT_COMPILE_STATUS_ARB, &testVal);
if(testVal == GL_FALSE)
{
glDeleteObjectARB(hVertexShader);
glDeleteObjectARB(hFragmentShader);
return NULL;
}
// Link them - assuming it works...
hReturn = glCreateProgramObjectARB();
glAttachObjectARB(hReturn, hVertexShader);
glAttachObjectARB(hReturn, hFragmentShader);
glLinkProgramARB(hReturn);
// These are no longer needed
glDeleteObjectARB(hVertexShader);
glDeleteObjectARB(hFragmentShader);
return hReturn;
}
//-----------------------------------------------------------------------------
bool CreateGLSLShader(char *vsFile, char *psFile, GLhandleARB &shader)
{
bool ret = false;
// Create the shader.
shader = glCreateProgramObjectARB();
// Load the vertex shader.
if(LoadShader(vsFile, GL_VERTEX_SHADER_ARB, shader) == false)
return false;
// Load the pixel shader.
if(LoadShader(psFile, GL_FRAGMENT_SHADER_ARB, shader) == false)
return false;
// Link together the vertex and pixel shaders.
glLinkProgramARB(shader);
GLint link = 0;
char error[1024];
glGetObjectParameterivARB(shader, GL_OBJECT_LINK_STATUS_ARB, &link);
if(!link)
{
// Get the error message and display it.
glGetInfoLogARB(shader, sizeof(error), NULL, error);
printf("Error linking shader...\n%s\n", error);
return false;
}
return true;
}
GLuint Shader::SIG_CreateProgram(GLuint vs, GLuint fs)
{
GLuint prog = glCreateProgram();
if (vs != 0) {
glAttachShader(prog, vs);
}
if (fs != 0) {
glAttachShader(prog, fs);
}
glLinkProgramARB(prog);
int linkStatus;
glGetProgramiv(prog, GL_LINK_STATUS, &linkStatus);
if (linkStatus != GL_TRUE) {
m_valid = false;
int bufflen = 1;
glGetProgramivARB(prog, GL_INFO_LOG_LENGTH, &bufflen);
GLchar* log_string = new char[bufflen + 1];
glGetProgramInfoLog(prog, bufflen, 0, log_string);
SIG_LOG("SHADER_PROGRAM_ERROR: Could not link program:");
SIG_LOG(log_string);
glDeleteProgram(prog);
return 0;
}
return prog;
}
void MGLContext::createFX(unsigned int * fxId, unsigned int vertexShaderId, unsigned int pixelShaderId)
{
*fxId = (unsigned int)(unsigned long)glCreateProgramObjectARB();
glAttachObjectARB((GLhandleARB)*fxId, (GLhandleARB)vertexShaderId);
glAttachObjectARB((GLhandleARB)*fxId, (GLhandleARB)pixelShaderId);
glLinkProgramARB((GLhandleARB)*fxId);
}
void
Shader::setup(const char *vs, const char *fs)
{
//fprintf(stdout, "vs, fs = %p, %p\n", vs, fs);
//GLuint vid = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
//GLuint fid = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
GLhandleARB vid = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
GLhandleARB fid = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
glShaderSourceARB(vid, 1, &vs, 0);
glShaderSourceARB(fid, 1, &fs, 0);
glCompileShaderARB(vid);
glCompileShaderARB(fid);
char glslLog[1024];
GLsizei glslLogSize;
glGetInfoLogARB(vid, 1024, &glslLogSize, glslLog);
if (glslLogSize)
printf("vertex program log: %s\n", glslLog);
glGetInfoLogARB(fid, 1024, &glslLogSize, glslLog);
if (glslLogSize)
printf("fragment program log: %s\n", glslLog);
pid = glCreateProgramObjectARB();
glAttachObjectARB(pid, vid);
glAttachObjectARB(pid, fid);
// delete shader objects as soon as they have been attached to a program
glDeleteObjectARB(vid);
glDeleteObjectARB(fid);
glLinkProgramARB(pid);
}
bool ShaderObject::LinkProgram()
{
glLinkProgramARB( Handle );
GLint compiledStatus;
glGetProgramiv( Handle, GL_LINK_STATUS, &compiledStatus );
Compiled = ( compiledStatus == GL_TRUE );
if ( Compiled )
{
glBindAttribLocation( Handle, VERTEX_ATTRIBUTE_TEXTURE_COORDINATES, "Attrib_TexCoords" );
glBindAttribLocation( Handle, VERTEX_ATTRIBUTE_NORMAL, "Attrib_Normal" );
glBindAttribLocation( Handle, VERTEX_ATTRIBUTE_TANGENT, "Attrib_Tangent" );
glBindAttribLocation( Handle, VERTEX_ATTRIBUTE_COLOR, "Attrib_Color" );
glBindAttribLocation( Handle, VERTEX_ATTRIBUTE_POSITION, "Attrib_Position" );
} else {
int infoLogLen = 0;
int charsWritten = 0;
GLchar *infoLog;
glGetProgramiv( Handle, GL_INFO_LOG_LENGTH, &infoLogLen );
std::string LogMessage;
if (infoLogLen > 0)
{
infoLog = new GLchar[infoLogLen];
glGetProgramInfoLog ( Handle, infoLogLen, &charsWritten, infoLog );
LogMessage = std::string( infoLog );
delete [] infoLog;
}
std::cout<<"Problem with compiling shader (Handle="<<Handle<<"):\n"<<LogMessage<<std::endl;
}
return Compiled;
}
bool CShaderMngr::_compileShader(shaderData *pData, GLenum nShaderType)
{
pData->nShaderID = glCreateShaderObjectARB(nShaderType);
if (pData->nShaderID == 0) return false; //creating the shader object failed
glShaderSourceARB(pData->nShaderID, 1, (const_cast<const GLcharARB**>(&pData->pSrc)), &(pData->nLen));
glCompileShader(pData->nShaderID);
int sz;
char errLog[4096];
glGetShaderInfoLog(pData->nShaderID, 4096, &sz, errLog);
GLint bResult;
glGetShaderiv(pData->nShaderID, GL_COMPILE_STATUS, &bResult);
if (bResult != GL_TRUE) return false; //Compilation failed
pData->nProgID = glCreateProgramObjectARB();
glAttachObjectARB(pData->nProgID, pData->nShaderID);
glLinkProgramARB(pData->nProgID);
glGetProgramiv(pData->nProgID, GL_LINK_STATUS, &bResult);
return (bResult==GL_TRUE);
}
void GLShader::linkShader(void)
{
if(programObject!=0)
Misc::throwStdErr("GLShader::linkShader: Attempt to link shader program multiple times");
/* Create the program object: */
programObject=glCreateProgramObjectARB();
/* Attach all previously compiled shaders to the program object: */
for(HandleList::iterator vsoIt=vertexShaderObjects.begin();vsoIt!=vertexShaderObjects.end();++vsoIt)
glAttachObjectARB(programObject,*vsoIt);
for(HandleList::iterator fsoIt=fragmentShaderObjects.begin();fsoIt!=fragmentShaderObjects.end();++fsoIt)
glAttachObjectARB(programObject,*fsoIt);
/* Link the program: */
glLinkProgramARB(programObject);
/* Check if the program linked successfully: */
GLint linkStatus;
glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus);
if(!linkStatus)
{
/* Get some more detailed information: */
GLcharARB linkLogBuffer[2048];
GLsizei linkLogSize;
glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer);
/* Signal an error: */
Misc::throwStdErr("GLShader::linkShader: Error \"%s\" while linking shader program",linkLogBuffer);
}
}
GL_Controller::Shader::Shader(const char* vsfn, const char* fsfn)
{
vertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
fragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
std::string vertexShaderSource = ReadFile(vsfn);
std::string fragmentShaderSource = ReadFile(fsfn);
const char* v = vertexShaderSource.c_str();
const char* f = fragmentShaderSource.c_str();
glShaderSourceARB(vertexShader, 1, &v, NULL);
glShaderSourceARB(fragmentShader, 1, &f, NULL);
glCompileShaderARB(vertexShader);
glCompileShaderARB(fragmentShader);
printInfoLog(vertexShader);
printInfoLog(fragmentShader);
shaderProgram = glCreateProgramObjectARB();
glAttachObjectARB(shaderProgram, vertexShader);
glAttachObjectARB(shaderProgram, fragmentShader);
glLinkProgramARB(shaderProgram);
printInfoLog(shaderProgram);
glUseProgramObjectARB(shaderProgram);
}
void shadertest::initShader() {
filehandler fragtext(fragment_shader_path);
filehandler verttext(vertex_shader_path);
const char * fs = (const char*) fragtext.getFileAsCharString();
const char * vs = (const char*) verttext.getFileAsCharString();
shaderprogram = glCreateProgramObjectARB();
fragShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
vertShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
glShaderSourceARB(fragShader, 1, &fs, NULL);
glShaderSourceARB(vertShader, 1, &vs, NULL);
glCompileShaderARB(vertShader);
glCompileShaderARB(fragShader);
glAttachObjectARB(shaderprogram, fragShader);
glAttachObjectARB(shaderprogram, vertShader);
glLinkProgramARB(shaderprogram);
glGenTextures(1, &img);
glBindTexture(GL_TEXTURE_2D, img);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 800, 600, 0, GL_BGR,
GL_UNSIGNED_BYTE, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glGenFramebuffersEXT(1, &fbo);
}
shader::shader(char* vert, char* frag)
{
//std::cerr << "creating shaders : " << vert << ", " << frag << std::endl;
this->vert=vert;
this->frag=frag;
uniformIdx = 0;
n_tex = 0;
// create shader objects
shaderobj = glCreateProgramObjectARB();
vertexshader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
fragmentshader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
// get source code for fragment and vertex shader
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);
}
static GLuint loadVertexShader(const char * source) {
GLuint shader = glCreateProgramObjectARB();
if(!shader) {
LogWarning << "failed to create program object";
return 0;
}
GLuint obj = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
if(!obj) {
LogWarning << "failed to create shader object";
glDeleteObjectARB(shader);
return 0;
}
glShaderSourceARB(obj, 1, &source, NULL);
glCompileShaderARB(obj);
if(!checkShader(obj, "compile", GL_OBJECT_COMPILE_STATUS_ARB)) {
glDeleteObjectARB(obj);
glDeleteObjectARB(shader);
return 0;
}
glAttachObjectARB(shader, obj);
glDeleteObjectARB(obj);
glLinkProgramARB(shader);
if(!checkShader(shader, "link", GL_OBJECT_LINK_STATUS_ARB)) {
glDeleteObjectARB(shader);
return 0;
}
return shader;
}
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;
}
void GlProgram::
link()
{
//attach all previously compiled shaders to the program object
for(ShaderHandle it=shaders.begin(); it!=shaders.end(); ++it)
glAttachObjectARB(program, *it);
//link the program
glLinkProgramARB(program);
//check if the program linked successfully
GLint linkStatus;
glGetObjectParameterivARB(program, GL_OBJECT_LINK_STATUS_ARB, &linkStatus);
if (!linkStatus)
{
//get some more detailed information
GLcharARB linkLogBuffer[2048];
GLsizei linkLogSize;
glGetInfoLogARB(program, sizeof(linkLogBuffer), &linkLogSize,
linkLogBuffer);
//signal an error
Misc::throwStdErr("GLProgram::link: Error \"%s\" while linking shader "
"program", linkLogBuffer);
}
}
GLhandleARB glLinkShader(GLhandleARB vertexShaderObject,GLhandleARB fragmentShaderObject)
{
/* Create the program object: */
GLhandleARB programObject=glCreateProgramObjectARB();
/* Attach all shader objects to the shader program: */
glAttachObjectARB(programObject,vertexShaderObject);
glAttachObjectARB(programObject,fragmentShaderObject);
/* Link the program: */
glLinkProgramARB(programObject);
/* Check if the program linked successfully: */
GLint linkStatus;
glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus);
if(!linkStatus)
{
/* Get some more detailed information: */
GLcharARB linkLogBuffer[2048];
GLsizei linkLogSize;
glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer);
/* Delete the program object: */
glDeleteObjectARB(programObject);
/* Signal an error: */
Misc::throwStdErr("glLinkShader: Error \"%s\" while linking shader program",linkLogBuffer);
}
return programObject;
}
Program::Program(GLRenderer& renderer, VertexProgram&& vertex, FragmentProgram&& fragment) :
_renderer(renderer),
_nbTextures(0),
_vertexProgram(std::move(vertex)),
_fragmentProgram(std::move(fragment))
{
for (auto& it: this->_attributes)
it = -1;
if (glLinkProgram != nullptr)
{
GLCHECK(this->_program = glCreateProgram());
GLCHECK(glAttachShader(this->_program, this->_vertexProgram.GetShader()));
GLCHECK(glAttachShader(this->_program, this->_fragmentProgram.GetShader()));
GLCHECK(glLinkProgram(this->_program));
}
else if (glLinkProgramARB != nullptr)
{
GLCHECK(this->_program = glCreateProgramObjectARB());
GLCHECK(glAttachObjectARB(this->_program, this->_vertexProgram.GetShader()));
GLCHECK(glAttachObjectARB(this->_program, this->_fragmentProgram.GetShader()));
GLCHECK(glLinkProgramARB(this->_program));
}
else
throw std::runtime_error("glLinkProgram unsupported");
for (int t = 0; t < (int)VertexAttributeUsage::Max; ++t)
{
auto& param = this->GetParameter(VertexAttributeUsage::typeToName[(VertexAttributeUsage::Type)t]);
this->_shaderParameters[t] = param.IsUseable() ? ¶m : 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()
bool CGLSL_Light_Link(GLhandleARB * GLSL_PO,GLhandleARB Attach_VS,GLhandleARB Attach_TC,GLhandleARB Attach_TE,GLhandleARB Attach_GS,GLhandleARB Attach_PS)
{
if(!GLSL_PO) return false;
GLSL_PO[0]=glCreateProgramObjectARB();
if(Attach_VS) glAttachObjectARB(GLSL_PO[0],Attach_VS);
if(Attach_TC) glAttachObjectARB(GLSL_PO[0],Attach_TC);
if(Attach_TE) glAttachObjectARB(GLSL_PO[0],Attach_TE);
if(Attach_GS) glAttachObjectARB(GLSL_PO[0],Attach_GS);
if(Attach_PS) glAttachObjectARB(GLSL_PO[0],Attach_PS);
glBindAttribLocation(GLSL_PO[0],AbLoc_Pos, "Position_in" );
glBindAttribLocation(GLSL_PO[0],AbLoc_Tex0, "TexCoord0_in" );
glBindAttribLocation(GLSL_PO[0],AbLoc_Normal, "Normal_in" );
glBindAttribLocation(GLSL_PO[0],AbLoc_Color, "Color_in" );
glBindAttribLocation(GLSL_PO[0],AbLoc_Tangent, "Tangent_in" );
GLint bLinked=0;
glLinkProgramARB( GLSL_PO[0] );
glGetObjectParameterivARB( GLSL_PO[0], GL_OBJECT_LINK_STATUS_ARB, &bLinked );
CTALogSys TALogSysCS;
if(bLinked) TALogSysCS.ADDhtmLog("GLSL Link LOG");
else TALogSysCS.ADDhtmLog("ERROR: GLSL Link Fail.","#FF0000");
char * logbuffer=GetGLSLInfoLog(GLSL_PO[0]);
TALogSysCS.ADDhtmLog(logbuffer);
TALogSysCS.WriteLOGFile(true);
TALogSysCS.ClearLOG();
delete[] logbuffer;
return bLinked!=0?true:false;
}
static void
link_shader_arb (GLuint *program, GLuint vert, GLuint frag)
{
GLint gl_status;
*program = glCreateProgramObjectARB ();
glAttachObjectARB (*program, vert);
glAttachObjectARB (*program, frag);
glLinkProgramARB (*program);
glGetObjectParameterivARB (*program, GL_OBJECT_LINK_STATUS_ARB, &gl_status);
if (gl_status == GL_FALSE) {
GLint log_size;
glGetObjectParameterivARB (*program, GL_OBJECT_INFO_LOG_LENGTH_ARB, &log_size);
if (0 < log_size) {
char *log = _cairo_malloc (log_size);
GLint chars;
log[log_size - 1] = '\0';
glGetInfoLogARB (*program, log_size, &chars, log);
printf ("OpenGL shader link failed:\n%s\n", log);
free (log);
} else {
printf ("OpenGL shader link failed.\n");
}
ASSERT_NOT_REACHED;
}
}
bool LinkShader(GLhandleARB GLSL_programObj)
{
GLint bLinked=0;
glLinkProgramARB( GLSL_programObj );
glGetObjectParameterivARB( GLSL_programObj, GL_OBJECT_LINK_STATUS_ARB, &bLinked );
return bLinked!=0?true:false;
}
bool CGLSLLoader::GetGLSLLinkSTATUS(GLhandleARB g_programObj)
{
GLint bLinked=false;
glLinkProgramARB( g_programObj );
glGetObjectParameterivARB( g_programObj, GL_OBJECT_LINK_STATUS_ARB, &bLinked );
if( bLinked == false )
{
char * logbuffer=GetGLSLInfoLog(g_programObj);
GLSLLOG.ADDhtmLog("ERROR: GLSL Link Fail.","#FF0000");
GLSLLOG.ADDhtmLog(logbuffer);
GLSLLOG.WriteLOGFile(true);
GLSLLOG.ClearLOG();
delete[] logbuffer;
return false;
}
else
{
char * logbuffer=GetGLSLInfoLog(g_programObj);
GLSLLOG.ADDhtmLog("GLSL Link LOG");
GLSLLOG.ADDhtmLog(logbuffer);
GLSLLOG.WriteLOGFile(true);
GLSLLOG.ClearLOG();
delete[] logbuffer;
}
GLSLLOG.ClearLOG();
return true;
}
void ShaderProgram::initialize()
{
GLint status;
handle = glCreateProgramObjectARB();
if (handle == 0)
throw Exception("failed to create program");
// Add all shaders
Shader::Iter i = shaders.begin();
for (; i != shaders.end(); ++i) {
glAttachObjectARB(handle, (*i)->getHandle());
}
// Link
glLinkProgramARB(handle);
glGetObjectParameterivARB(handle, GL_OBJECT_LINK_STATUS_ARB, &status);
if (status != GL_TRUE) {
std::string errors;
GLint len;
// Get size of info log
glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &len);
if (len > 1) {
errors.resize(len);
glGetInfoLogARB(handle, len, NULL, &errors[0]);
}
throw Exception("shader program link failed\n" + errors);
}
}
GLhandleARB glLinkShader(const std::vector<GLhandleARB>& shaderObjects)
{
/* Create the program object: */
GLhandleARB programObject=glCreateProgramObjectARB();
/* Attach all shader objects to the shader program: */
for(std::vector<GLhandleARB>::const_iterator soIt=shaderObjects.begin();soIt!=shaderObjects.end();++soIt)
glAttachObjectARB(programObject,*soIt);
/* Link the program: */
glLinkProgramARB(programObject);
/* Check if the program linked successfully: */
GLint linkStatus;
glGetObjectParameterivARB(programObject,GL_OBJECT_LINK_STATUS_ARB,&linkStatus);
if(!linkStatus)
{
/* Get some more detailed information: */
GLcharARB linkLogBuffer[2048];
GLsizei linkLogSize;
glGetInfoLogARB(programObject,sizeof(linkLogBuffer),&linkLogSize,linkLogBuffer);
/* Delete the program object: */
glDeleteObjectARB(programObject);
/* Signal an error: */
Misc::throwStdErr("glLinkShader: Error \"%s\" while linking shader program",linkLogBuffer);
}
return programObject;
}
bool ccShaderARB::loadProgram(const char *vertexShaderFile, const char *pixelShaderFile)
{
assert(vertexShaderFile || pixelShaderFile);
reset();
assert(prog == 0);
if (vertexShaderFile)
vert=LoadShaderARB(GL_VERTEX_SHADER_ARB,vertexShaderFile);
if (pixelShaderFile)
frag=LoadShaderARB(GL_FRAGMENT_SHADER_ARB,pixelShaderFile);
if (!frag && !vert)
{
//ccLog::Warning("No shader loaded! Wrong filename?");
return false;
}
//creating program
prog = glCreateProgramObjectARB();
//attaching shaders
if (vert)
glAttachObjectARB(prog,vert);
if (frag)
glAttachObjectARB(prog,frag);
//linking
glLinkProgramARB(prog);
//we check for success
/*GLint linkStatus = GL_TRUE;
glGetProgramiv(prog, GL_LINK_STATUS, &linkStatus);
if(linkStatus != GL_TRUE)
{
GLint logSize = 0;
glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logSize);
char* log = new char[logSize+1];
if(log)
{
memset(log, '\0', logSize + 1);
glGetProgramInfoLog(prog, logSize, &logSize, log);
ccLog::Error("Can't create shader program! (%s)", log);
delete[] log;
}
else ccLog::Error("Can't create shader program! (unable to get GL log)");
glDeleteProgram(prog);
prog = 0;
}
//*/
stop();
return true;
}
bool Shader::init(Text* _vertexShader, Text* _fragmentShader, const StringDict& _parameters)
{
if (!GL_EXTENSION_GLSL)
{
return false;
}
if (isError())
{
error("opengl", "Real error before GLSL. Flushing");
}
vertexShader = _vertexShader;
fragmentShader = _fragmentShader;
parameters = _parameters;
log_msg("opengl glsl", "Compiling " + getShaderDecription());
programId = glCreateProgramObjectARB();
if (isError())
{
return false;
}
vertexShaderId = glCreateShaderObjectARB (GL_VERTEX_SHADER_ARB);
if (!loadShader(vertexShaderId, vertexShader, parameters))
{
loadLog(programId);
return false;
}
glAttachObjectARB(programId, vertexShaderId);
fragmentShaderId = glCreateShaderObjectARB (GL_FRAGMENT_SHADER_ARB);
if (!loadShader(fragmentShaderId, fragmentShader, parameters))
{
loadLog(programId);
return false;
}
glAttachObjectARB(programId, fragmentShaderId);
GLint linked;
glLinkProgramARB(programId);
if (isError())
{
return false;
}
glGetObjectParameterivARB(programId, GL_OBJECT_LINK_STATUS_ARB, &linked);
loadLog(programId);
if (!linked)
{
return false;
}
return true;
}
GLhandleARB build_shader(const char* vert,const char* frag) {
GLhandleARB shadowShaderId;
shadowShaderId = glCreateProgramObjectARB();
glAttachObjectARB(shadowShaderId,vert?compile_shader(vert,GL_VERTEX_SHADER):0);
glAttachObjectARB(shadowShaderId,frag?compile_shader(frag,GL_FRAGMENT_SHADER):0);
glLinkProgramARB(shadowShaderId);
return shadowShaderId;
}
/////////////////////////////////////////////////////////
// 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 ofxShader::setup(string fragmentName, string vertexName) {
bLoaded = false;
if (GLEE_ARB_shader_objects) {
vertexShader = (GLhandleARB) glCreateShader(GL_VERTEX_SHADER);
fragmentShader = (GLhandleARB) glCreateShader(GL_FRAGMENT_SHADER);
string vs = loadShaderText(vertexName);
string fs = loadShaderText(fragmentName);
const char* vsptr = vs.c_str();
const char* fsptr = fs.c_str();
int vssize = vs.size();
int fssize = fs.size();
glShaderSourceARB(vertexShader, 1, &vsptr, &vssize);
glShaderSourceARB(fragmentShader, 1, &fsptr, &fssize);
glCompileShaderARB(vertexShader);
//please add compile status check in:
//GLint compileStatus = 0;
//glGetObjectParameterivARB( vertexShader, GL_COMPILE_STATUS, &compileStatus );
//printf("%i \n", compileStatus);
char infobuffer[1000];
GLsizei infobufferlen = 0;
glGetInfoLogARB(vertexShader, 999, &infobufferlen, infobuffer);
if (infobufferlen != 0) {
infobuffer[infobufferlen] = 0;
printf("vertexShader reports: %s \n", infobuffer);
return;
}
glCompileShaderARB(fragmentShader);
//glGetObjectParameterivARB( fragmentShader, GL_COMPILE_STATUS, &compileStatus );
//printf("%i \n", compileStatus);
glGetInfoLogARB(fragmentShader, 999, &infobufferlen, infobuffer);
if (infobufferlen != 0) {
infobuffer[infobufferlen] = 0;
printf("fragmentShader reports: %s \n", infobuffer);
return;
}
shader = glCreateProgramObjectARB();
glAttachObjectARB(shader, vertexShader);
glAttachObjectARB(shader, fragmentShader);
glLinkProgramARB(shader);
bLoaded = true;
} else {
cout << "Sorry, it looks like you can't run 'ARB_shader_objects'." << endl;
cout << "Please check the capabilites of your graphics card." << endl;
cout << "http://www.ozone3d.net/gpu_caps_viewer/)" << endl;
}
}
bool Shader::SetShaderFile(char* sVSFileName, char* sFSFileName)
{
if (glIsProgram(m_Program))
{
CleanUp();
}
if (!ReadVertextShader(sVSFileName) || !ReadFragmentShader(sFSFileName))
{
return false;
}
GLint vertCompiled, fragCompiled; //状态值
GLint linked;
//创建shader对象
m_Vert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
m_Frag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
const GLcharARB *vv = m_VertexShader;
const GLcharARB *ff = m_FragmentShader;
//添加shader
glShaderSourceARB(m_Vert,1,&vv,NULL);
glShaderSourceARB(m_Frag,1,&ff,NULL);
//编译shader
glCompileShaderARB(m_Vert);
printOpenGLError(); //检查OpenGL错误
//glGetObjectParameterivARB(m_Vert, GL_OBJECT_COMPILE_STATUS_ARB, &vertCompiled);
glGetShaderiv(m_Vert, GL_COMPILE_STATUS, &vertCompiled);
printInfoLog(m_Vert);
glCompileShaderARB(m_Frag);
printOpenGLError(); //检查OpenGL错误
//glGetObjectParameterivARB(m_Frag, GL_OBJECT_COMPILE_STATUS_ARB, &fragCompiled);
glGetShaderiv(m_Frag, GL_COMPILE_STATUS, &fragCompiled);
printInfoLog(m_Frag);
if (!vertCompiled || !fragCompiled)
return false;
//创建程序对象
m_Program = glCreateProgramObjectARB();
//绑定shader到程序对象
glAttachObjectARB(m_Program,m_Vert);
glAttachObjectARB(m_Program,m_Frag);
//链接程序
glLinkProgramARB(m_Program);
printOpenGLError(); //检查OpenGL错误
//glGetObjectParameterivARB(m_Program, GL_OBJECT_COMPILE_STATUS_ARB, &linked);
glGetProgramiv(m_Program, GL_LINK_STATUS, &linked);
printInfoLog(m_Program);
if (!linked)
return false;
UseShader(true);
return true;
}
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;
}
