/////////////////////////////////////////////////////////////////
// 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;
}
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;
}
}
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;
}
}
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);
}
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);
}
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;
}
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);
}
}
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);
}
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;
}
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 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;
}
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;
}
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;
}
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;
}
}
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;
}
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;
}
void initShader(){
for (int i = 0; i != shadercount; i++) {
shaderPrograms[i] = glCreateProgramObjectARB();
glAttachObjectARB(shaderPrograms[i*2], shaders[i]);
glAttachObjectARB(shaderPrograms[i*2+1], shaders[i]);
glLinkProgramARB(shaderPrograms[i]);
}
}
void CGLSL_Light_Attach(GLhandleARB * GLSL_PO,GLhandleARB Attach_VS,GLhandleARB Attach_TC,GLhandleARB Attach_TE,GLhandleARB Attach_GS,GLhandleARB Attach_PS)
{
if(!GLSL_PO) return;
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);
}
int
main()
{
GLenum shader_prog, shader_vert, shader_frag;
int i;
char buf[1024];
const GLcharARB *vertex_shader_code, *fragment_shader_code;
GLint loc;
assert((vertex_shader_code = loadShader("shader.vert")));
assert((fragment_shader_code = loadShader("shader.frag")));
assert(!SDL_Init(SDL_INIT_EVERYTHING));
atexit(SDL_Quit);
SDL_GL_SET_ATTR(RED_SIZE, 8);
SDL_GL_SET_ATTR(GREEN_SIZE, 8);
SDL_GL_SET_ATTR(BLUE_SIZE, 8);
SDL_GL_SET_ATTR(DEPTH_SIZE, 16);
SDL_GL_SET_ATTR(DOUBLEBUFFER, 1);
assert(SDL_SetVideoMode(SCRW, SCRH, SCRBPP, SDL_OPENGL /*| SDL_FULLSCREEN*/));
/* puts((const char *)glGetString(GL_EXTENSIONS));*/
DO_GL_PROCS(DEFINE_GL_PROC)
assert((shader_prog = glCreateProgramObjectARB()));
assert((shader_vert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)));
assert((shader_frag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB)));
i = strlen(vertex_shader_code);
printf("vert len: %d\n", i);
glShaderSourceARB(shader_vert, 1, &vertex_shader_code, &i);
i = strlen(fragment_shader_code);
printf("frag len: %d\n", i);
glShaderSourceARB(shader_frag, 1, &fragment_shader_code, &i);
glCompileShaderARB(shader_vert);
glCompileShaderARB(shader_frag);
glAttachObjectARB(shader_prog, shader_vert);
glAttachObjectARB(shader_prog, shader_frag);
glLinkProgramARB(shader_prog);
i = 0; glGetInfoLogARB(shader_vert, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("vert error: \"%s\"\n", buf);
i = 0; glGetInfoLogARB(shader_frag, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("frag error: \"%s\"\n", buf);
i = 0; glGetInfoLogARB(shader_prog, sizeof(buf) - 1, &i, buf); buf[i] = 0; printf("prog error: \"%s\"\n", buf);
glUseProgramObjectARB(shader_prog);
loc = glGetUniformLocationARB(shader_prog, "time");
while (!SDL_GetKeyState(0)[SDLK_ESCAPE]) {
float time = (float)SDL_GetTicks() / 2000.0f;
SDL_PumpEvents();
glUniform1fARB(loc, time);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBegin(GL_QUADS);
glVertex3f(-1.0f, 1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glVertex3f(1.0f, -1.0f, 0.0f);
glVertex3f(-1.0f, -1.0f, 0.0f);
glEnd();
SDL_GL_SwapBuffers();
}
return 0;
}
bool GlslProgram :: loadShaders ( Data * vertexShaderData, Data * fragmentShaderData )
{
ok = false;
// check whether we should create program object
if ( program == 0 )
program = glCreateProgramObjectARB();
// check for errors
if ( !checkGlError () )
return false;
// create a vertex shader object and a fragment shader object
if ( vertexShaderData != NULL )
{
vertexShader = glCreateShaderObjectARB ( GL_VERTEX_SHADER_ARB );
log += "Loading vertex shader\n";
if ( !loadShader ( vertexShader, vertexShaderData ) )
return false;
// attach shaders to program object
glAttachObjectARB ( program, vertexShader );
}
if ( fragmentShaderData != NULL )
{
fragmentShader = glCreateShaderObjectARB ( GL_FRAGMENT_SHADER_ARB );
log += "Loading fragment shader\n";
if ( !loadShader ( fragmentShader, fragmentShaderData ) )
return false;
// attach shaders to program object
glAttachObjectARB ( program, fragmentShader );
}
GLint linked;
log += "Linking programs\n";
// link the program object and print out the info log
glLinkProgramARB ( program );
/**/ if ( !checkGlError () ) // check for errors
/**/ return false;
glGetObjectParameterivARB ( program, GL_OBJECT_LINK_STATUS_ARB, &linked );
loadLog ( program );
if ( !linked )
return false;
return ok = true;
}
void GLCanvas::InitShaders() {
std::cout << "initialize shaders" << std::endl;
CheckForGLSL();
program = glCreateProgramObjectARB();
vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
HandleGLError("Failed to create program or shader objects");
glAttachObjectARB(program,vertex_shader);
glAttachObjectARB(program,fragment_shader);
HandleGLError("Failed to attach shaders to program");
}
bool CGLSLLoader::LoadShader2(const wchar_t* ShaderFullName,int ShaderLevel)
{
if(!ShaderFullName) return false;
if(ShaderLevel>=2)
if(!g_VS)
{
wchar_t* VSfilename=ADDTwoChar(ShaderFullName,L".vs");
g_VS=CompileShader(VSfilename,GL_VERTEX_SHADER_ARB);
delete[] VSfilename;
}
if(ShaderLevel>=4)
if(!g_TC)
{
wchar_t* TCfilename=ADDTwoChar(ShaderFullName,L".tc");
g_TC=CompileShader(TCfilename,GL_TESS_CONTROL_SHADER);
delete[] TCfilename;
}
if(ShaderLevel>=4)
if(!g_TE)
{
wchar_t* TEfilename=ADDTwoChar(ShaderFullName,L".te");
g_TE=CompileShader(TEfilename,GL_TESS_EVALUATION_SHADER);
delete[] TEfilename;
}
if(ShaderLevel>=3)
if(!g_GS)
{
wchar_t* GSfilename=ADDTwoChar(ShaderFullName,L".gs");
g_GS=CompileShader(GSfilename,GL_GEOMETRY_SHADER);
delete[] GSfilename;
}
if(ShaderLevel>=2)
if(!g_PS)
{
wchar_t* PSfilename=ADDTwoChar(ShaderFullName,L".ps");
g_PS=CompileShader(PSfilename,GL_FRAGMENT_SHADER_ARB);
delete[] PSfilename;
}
g_PO = glCreateProgramObjectARB();
if(ShaderLevel>=2) if(g_VS) glAttachObjectARB( g_PO, g_VS );
if(ShaderLevel>=4) if(g_TC) glAttachObjectARB( g_PO, g_TC );
if(ShaderLevel>=4) if(g_TE) glAttachObjectARB( g_PO, g_TE );
if(ShaderLevel>=3) if(g_GS) glAttachObjectARB( g_PO, g_GS );
if(ShaderLevel>=2) if(g_PS) glAttachObjectARB( g_PO, g_PS );
if(!GetGLSLLinkSTATUS( g_PO ))
{
ClearShader();
return false;
}
return true;
}
bool CreateShader(char *VShader, char *PShader, GLhandleARB *glContext) {
printf("Loading vertex shader:%s\n", VShader) ;
printf("Loading fragment shader:%s\n", PShader) ;
char error[4096];
int result;
GLhandleARB glVertexShader;
GLhandleARB glPixelShader;
// Create the program object.
*glContext = glCreateProgramObjectARB();
// Load the vertex shader.
char *ShaderCode = loadShader(VShader);
if(!ShaderCode) return false;
glVertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
glShaderSourceARB(glVertexShader, 1, (const char**)&ShaderCode, NULL);
glCompileShaderARB(glVertexShader);
printInfoLog(glVertexShader) ;
glGetObjectParameterivARB(glVertexShader, GL_OBJECT_COMPILE_STATUS_ARB, &result);
glAttachObjectARB(*glContext, glVertexShader);
delete[] ShaderCode;
ShaderCode = NULL;
// Load the pixel shader.
ShaderCode = loadShader(PShader);
if(!ShaderCode) return false;
glPixelShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
glShaderSourceARB(glPixelShader, 1, (const char**)&ShaderCode, NULL);
glCompileShaderARB(glPixelShader);
printInfoLog(glPixelShader) ;
glGetObjectParameterivARB(glPixelShader, GL_OBJECT_COMPILE_STATUS_ARB, &result);
glAttachObjectARB(*glContext, glPixelShader);
delete[] ShaderCode;
ShaderCode = NULL;
// Link our shaders.
glLinkProgramARB(*glContext);
glGetObjectParameterivARB(*glContext, GL_OBJECT_LINK_STATUS_ARB, &result);
if(!result) {
glGetInfoLogARB(*glContext, sizeof(error), NULL, error);
fprintf(stderr, "Error linking shaders...") ;
return false;
}
glDeleteObjectARB(glVertexShader);
glDeleteObjectARB(glPixelShader);
return true;
}
bool GLSLShader::LoadShaders( const char* vertex_file, const char* fragment_file )
{
Free();
FILE *fp = nullptr;
fopen_s(&fp, vertex_file, "r");
if (fp)
{
vertex = glCreateShaderObjectARB( GL_VERTEX_SHADER_ARB );
LoadShader( vertex, fp );
fclose(fp);
}
fopen_s(&fp, fragment_file, "r");
if (fp)
{
fragment = glCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );
LoadShader( fragment, fp );
fclose(fp);
}
if (vertex > 0 && fragment > 0)
{
programObj = glCreateProgramObjectARB();
// check for errors
//if ( checkopenglerror ) return false;
// attach shader to program object
glAttachObjectARB( programObj, vertex );
// attach shader to program object
glAttachObjectARB( programObj, fragment );
GLint linked;
// link the program object and print out the info log
glLinkProgramARB( programObj );
CHECK_GL_ERROR();
//if ( checkopenglerror ) return false;
glGetObjectParameterivARB( programObj, GL_OBJECT_LINK_STATUS_ARB, &linked );
loadlog( programObj );
return (linked != 0);
}
return false;
}
bool ShaderProgramGl::link(string &messages){
assertGl();
VertexShaderGl *vertexShaderGl= static_cast<VertexShaderGl*>(vertexShader);
FragmentShaderGl *fragmentShaderGl= static_cast<FragmentShaderGl*>(fragmentShader);
const ShaderSource *vss= vertexShaderGl->getSource();
const ShaderSource *fss= fragmentShaderGl->getSource();
messages= "Linking program: " + vss->getPathInfo() + ", " + fss->getPathInfo() + "\n";
//attach
glAttachObjectARB(handle, vertexShaderGl->getHandle());
glAttachObjectARB(handle, fragmentShaderGl->getHandle());
assertGl();
//bind attributes
for(int i=0; i<attributes.size(); ++i){
//int a= attributes[i].second;
//string s= attributes[i].first;
glBindAttribLocationARB(handle, attributes[i].second, attributes[i].first.c_str());
}
assertGl();
//link
glLinkProgramARB(handle);
glValidateProgramARB(handle);
assertGl();
//log
GLint logLength= 0;
glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &logLength);
char *buffer= new char[logLength+1];
glGetInfoLogARB(handle, logLength+1, NULL, buffer);
messages+= buffer;
delete [] buffer;
assertGl();
//status
GLint status= false;
glGetObjectParameterivARB(handle, GL_OBJECT_LINK_STATUS_ARB, &status);
assertGl();
return status!=0;
}
int glLoadShader(const char* vs_file,const char* fs_file)
{
unsigned int progobj;
unsigned int shader[2];
char* text[2];
int i;
progobj=glCreateProgram();
text[0]=ReadShaderText(vs_file);
text[1]=ReadShaderText(fs_file);
if(text[0]) shader[0]=glCreateShader(GL_VERTEX_SHADER);
if(text[1]) shader[1]=glCreateShader(GL_FRAGMENT_SHADER);
for(i=0;i<2;++i)
{
if(!shader[i]) continue;
glAttachObjectARB(progobj,shader[i]);
glShaderSource(shader[i],1,(const char**)&text[i],NULL);
glCompileShader(shader[i]);
free(text[i]);
}
glLinkProgram(progobj);
return progobj;
}
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 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);
}
}
void loadShadowShader()
{
GLhandleARB vertexShaderHandle;
GLhandleARB fragmentShaderHandle;
vertexShaderHandle = loadShader("shadow.vert",GL_VERTEX_SHADER);
fragmentShaderHandle = loadShader("shadow.frag",GL_FRAGMENT_SHADER);
shadowShaderId = glCreateProgramObjectARB();
glAttachObjectARB(shadowShaderId,vertexShaderHandle);
glAttachObjectARB(shadowShaderId,fragmentShaderHandle);
glLinkProgramARB(shadowShaderId);
shadowMapUniform = glGetUniformLocationARB(shadowShaderId,"ShadowMap");
}
