// Compile shaders
void PrepareShader(GLint shaderNum)
{
char fullFileName[255];
GLchar *vsString;
// Create shader objects and specify shader text
const GLchar *vsStringPtr[1];
GLint success;
sprintf(fullFileName, "./shaders/%s.vs", shaderNames[shaderNum]);
vsString = LoadShaderText(fullFileName);
if (!vsString)
{
fprintf(stderr, "Unable to load \"%s\"\n", fullFileName);
Sleep(5000);
exit(0);
}
vShader[shaderNum] = glCreateShader(GL_VERTEX_SHADER);
vsStringPtr[0] = vsString;
glShaderSource(vShader[shaderNum], 1, vsStringPtr, NULL);
free(vsString);
// Compile shaders and check for any errors
glCompileShader(vShader[shaderNum]);
glGetShaderiv(vShader[shaderNum], GL_COMPILE_STATUS, &success);
if (!success)
{
GLchar infoLog[MAX_INFO_LOG_SIZE];
glGetShaderInfoLog(vShader[shaderNum], MAX_INFO_LOG_SIZE, NULL, infoLog);
fprintf(stderr, "Error in vertex shader #%d compilation!\n", shaderNum);
fprintf(stderr, "Info log: %s\n", infoLog);
Sleep(10000);
exit(0);
}
// Create program object, attach shader, then link
progObj[shaderNum] = glCreateProgram();
glAttachShader(progObj[shaderNum], vShader[shaderNum]);
glLinkProgram(progObj[shaderNum]);
glGetProgramiv(progObj[shaderNum], GL_LINK_STATUS, &success);
if (!success)
{
GLchar infoLog[MAX_INFO_LOG_SIZE];
glGetProgramInfoLog(progObj[shaderNum], MAX_INFO_LOG_SIZE, NULL, infoLog);
fprintf(stderr, "Error in program #%d linkage!\n", shaderNum);
fprintf(stderr, "Info log: %s\n", infoLog);
Sleep(10000);
exit(0);
}
lightPosLoc = glGetUniformLocation(progObj[0], "lightPos");
mv2Loc = glGetUniformLocation(progObj[0], "mv2");
mv2ITLoc = glGetUniformLocation(progObj[0], "mv2IT");
weightLoc = glGetAttribLocation(progObj[0], "weight");
// Program object has changed, so we should revalidate
needsValidation[shaderNum] = GL_TRUE;
}
bool Shader::install()
{
printf("--------------------------------\n");
printf("Building shader...\n");
program = glCreateProgram();
bool allStagesCompiled = true;
for ( unsigned int i = 0; i < shaderStages.size(); ++i )
{
GLint compiled;
const GLchar* source = LoadShaderText(shaderStages[i].filePath);
const GLchar* fullSource[2];
fullSource[0] = shaderStages[i].preprocessor;
fullSource[1] = source;
GLuint shader = glCreateShader(shaderStages[i].type);
glShaderSource(shader, 2, &fullSource[0], NULL);
glCompileShader(shader);
glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
printf("error when compiling shader: %s \n\n", shaderStages[i].filePath);
printShaderInfoLog(shader);
allStagesCompiled = false;
}
else
printf("Shader stage: %s compiled\n", shaderStages[i].filePath);
glAttachShader(program, shader);
}
if ( !allStagesCompiled )
{
printf("*** Using fixed function pipeline ***\n");
printf("--------------------------------\n");
throw std::runtime_error("Shader compile failed\n");
return false;
}
GLint linked;
// glBindFragDataLocationEXT(program, 0, "basicFrag");
if ( varyings.size() > 0 )
glTransformFeedbackVaryings(program, varyings.size(), &varyings[0], GL_SEPARATE_ATTRIBS);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &linked);
if (!linked)
{
printProgramInfoLog();
printf("linking of shader failed...\n");
printf("*** Using fixed function pipeline ***\n");
printf("--------------------------------\n");
throw std::runtime_error("Shader link failed\n");
return false;
}
glUseProgram(program); // turn on programmable pipeline
printf("Link success...\n");
printf("--------------------------------\n");
return true;
}
//---------------------------------------------------------------
void ofxShader::loadShader(string fragmentName, string vertexName){
fragmentName = ofToDataPath(fragmentName);
vertexName = ofToDataPath(vertexName);
bLoaded = false;
if (GLEE_ARB_shader_objects){
// ---------------------------------- (a) load in the shaders
char *vs = NULL,*fs = NULL;
vs = LoadShaderText(vertexName.c_str());
fs = LoadShaderText(fragmentName.c_str());
vertexShader = (GLhandleARB)glCreateShader(GL_VERTEX_SHADER);
fragmentShader = (GLhandleARB)glCreateShader(GL_FRAGMENT_SHADER);
if( vs == NULL || fs == NULL ){
printf("unable to load %s \n", vertexName.c_str());
return;
}
GLint length = strlen(vs);
glShaderSourceARB(vertexShader, 1, (const char**)&vs, &length);
length = strlen(fs);
glShaderSourceARB(fragmentShader, 1, (const char**)&fs, &length);
char infobuffer[1000];
GLsizei infobufferlen = 0;
// ----------------------------------- (b) compile the shaders
// try to compile "vertex shader"
glCompileShaderARB(vertexShader);
//please add compile status check in:
GLint compileStatus = 0;
glGetObjectParameterivARB( vertexShader, GL_COMPILE_STATUS, &compileStatus );
printf("vertexShader status = %i \n", compileStatus);
if(compileStatus == 0)
{
printf("vertexShader erroorrr");
exit (0);
}
/*
glGetInfoLogARB(vertexShader, 999, &infobufferlen, infobuffer);
if (infobufferlen != 0){
infobuffer[infobufferlen] = 0;
printf("vertexShader reports0: %s \n", infobuffer);
return;
}
*/
// ------------------------------------
// try to compile "fragment shader"
glCompileShaderARB(fragmentShader);
glGetObjectParameterivARB( fragmentShader, GL_COMPILE_STATUS, &compileStatus );
printf("fragmentShader status %i \n", compileStatus);
if(compileStatus == 0)
{
printf("fragmentShader erroorrr");
//exit (0);
}
/* // per a que funcioni el shader te que estar comentat
glGetInfoLogARB(fragmentShader, 999, &infobufferlen, infobuffer);
if (infobufferlen != 0){
infobuffer[infobufferlen] = 0;
printf("fragmentShader reports: %s \n", infobuffer);
return;
}*/
// ----------------------------------- (c) link the shaders
shader = glCreateProgramObjectARB();
glAttachObjectARB(shader,vertexShader);
glAttachObjectARB(shader,fragmentShader);
glLinkProgramARB(shader);
bLoaded = true;
} else {
printf("sorry, it looks like you can't run 'ARB_shader_objects' \n please check the capabilites of your graphics card (http://www.ozone3d.net/gpu_caps_viewer/) \n");
}
}
// Compile shaders
void PrepareShader(GLint shaderNum)
{
char fullFileName[255];
GLubyte *vsString;
// Create low-level shader objects and specify shader text
if (lowLevelAvailable)
{
GLint errorPos;
sprintf(fullFileName, ".\\shaders\\%s.vp", shaderNames[shaderNum]);
vsString = LoadShaderText(fullFileName);
if (!vsString)
{
fprintf(stderr, "Unable to load \"%s\"\n", fullFileName);
usleep(5000);
exit(0);
}
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, ids[shaderNum]);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen((const char *)vsString), vsString);
free(vsString);
glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorPos);
if (errorPos != -1)
{
fprintf(stderr, "Error in low-level vertex shader #%d at position %d!\n", shaderNum, errorPos);
fprintf(stderr, "Error string: %s\n", glGetString(GL_PROGRAM_ERROR_STRING_ARB));
usleep(5000);
exit(0);
}
}
// Create high-level shader objects and specify shader text
if (highLevelAvailable)
{
GLcharARB *vsStringPtr[1];
GLint success;
sprintf(fullFileName, ".\\shaders\\%s.vs", shaderNames[shaderNum]);
vsString = LoadShaderText(fullFileName);
if (!vsString)
{
fprintf(stderr, "Unable to load \"%s\"\n", fullFileName);
usleep(5000);
exit(0);
}
vShader[shaderNum] = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
vsStringPtr[0] = (GLcharARB *)vsString;
glShaderSourceARB(vShader[shaderNum], 1, (const GLcharARB **)vsStringPtr, NULL);
free(vsString);
// Compile shaders and check for any errors
glCompileShaderARB(vShader[shaderNum]);
glGetObjectParameterivARB(vShader[shaderNum], GL_OBJECT_COMPILE_STATUS_ARB, &success);
if (!success)
{
GLbyte infoLog[MAX_INFO_LOG_SIZE];
glGetInfoLogARB(vShader[shaderNum], MAX_INFO_LOG_SIZE, NULL, (GLcharARB *)infoLog);
fprintf(stderr, "Error in high-level vertex shader #%d compilation!\n", shaderNum);
fprintf(stderr, "Info log: %s\n", infoLog);
usleep(10000);
exit(0);
}
// Create program object, attach shader, then link
progObj[shaderNum] = glCreateProgramObjectARB();
glAttachObjectARB(progObj[shaderNum], vShader[shaderNum]);
glLinkProgramARB(progObj[shaderNum]);
glGetObjectParameterivARB(progObj[shaderNum], GL_OBJECT_LINK_STATUS_ARB, &success);
if (!success)
{
GLbyte infoLog[MAX_INFO_LOG_SIZE];
glGetInfoLogARB(progObj[shaderNum], MAX_INFO_LOG_SIZE, NULL, (GLcharARB *)infoLog);
fprintf(stderr, "Error in high-level program #%d linkage!\n", shaderNum);
fprintf(stderr, "Info log: %s\n", infoLog);
usleep(10000);
exit(0);
}
lightPosLoc = glGetUniformLocationARB(progObj[0], "lightPos");
mv2Loc = glGetUniformLocationARB(progObj[0], "mv2");
mv2ITLoc = glGetUniformLocationARB(progObj[0], "mv2IT");
weightLoc = glGetAttribLocationARB(progObj[0], "weight");
// Program object has changed, so we should revalidate
needsValidation[shaderNum] = GL_TRUE;
}
}
// Compile shaders
void PrepareShader(GLint shaderNum)
{
char fullFileName[255];
GLchar *shString;
const GLchar *shStringPtr[1];
GLint success;
// Create shader objects and specify shader text
sprintf(fullFileName, "./shaders/%s.vs", shaderNames[shaderNum]);
shString = LoadShaderText(fullFileName);
if (!shString)
{
fprintf(stderr, "Unable to load \"%s\"\n", fullFileName);
Sleep(5000);
exit(0);
}
vShader[shaderNum] = glCreateShader(GL_VERTEX_SHADER);
shStringPtr[0] = shString;
glShaderSource(vShader[shaderNum], 1, shStringPtr, NULL);
free(shString);
// Compile shaders and check for any errors
glCompileShader(vShader[shaderNum]);
glGetShaderiv(vShader[shaderNum], GL_COMPILE_STATUS, &success);
if (!success)
{
GLchar infoLog[MAX_INFO_LOG_SIZE];
glGetShaderInfoLog(vShader[shaderNum], MAX_INFO_LOG_SIZE, NULL, infoLog);
fprintf(stderr, "Error in vertex shader #%d compilation!\n", shaderNum);
fprintf(stderr, "Info log: %s\n", infoLog);
Sleep(10000);
exit(0);
}
sprintf(fullFileName, "./shaders/%s.fs", shaderNames[shaderNum]);
shString = LoadShaderText(fullFileName);
if (!shString)
{
fprintf(stderr, "Unable to load \"%s\"\n", fullFileName);
Sleep(5000);
exit(0);
}
fShader[shaderNum] = glCreateShader(GL_FRAGMENT_SHADER);
shStringPtr[0] = shString;
glShaderSource(fShader[shaderNum], 1, shStringPtr, NULL);
free(shString);
// Compile shaders and check for any errors
glCompileShader(fShader[shaderNum]);
glGetShaderiv(fShader[shaderNum], GL_COMPILE_STATUS, &success);
if (!success)
{
GLchar infoLog[MAX_INFO_LOG_SIZE];
glGetShaderInfoLog(fShader[shaderNum], MAX_INFO_LOG_SIZE, NULL, infoLog);
fprintf(stderr, "Error in fragment shader #%d compilation!\n", shaderNum);
fprintf(stderr, "Info log: %s\n", infoLog);
Sleep(10000);
exit(0);
}
else
{
GLchar infoLog[MAX_INFO_LOG_SIZE];
glGetShaderInfoLog(fShader[shaderNum], MAX_INFO_LOG_SIZE, NULL, infoLog);
//fprintf(stderr, "Fragment shader #%d info log: %s\n", shaderNum, infoLog);
}
// Create program object, attach shader, then link
progObj[shaderNum] = glCreateProgram();
glAttachShader(progObj[shaderNum], vShader[shaderNum]);
glAttachShader(progObj[shaderNum], fShader[shaderNum]);
glLinkProgram(progObj[shaderNum]);
glGetProgramiv(progObj[shaderNum], GL_LINK_STATUS, &success);
if (!success)
{
GLchar infoLog[MAX_INFO_LOG_SIZE];
glGetProgramInfoLog(progObj[shaderNum], MAX_INFO_LOG_SIZE, NULL, infoLog);
fprintf(stderr, "Error in program #%d linkage!\n", shaderNum);
fprintf(stderr, "Info log: %s\n", infoLog);
Sleep(10000);
exit(0);
}
else
{
GLchar infoLog[MAX_INFO_LOG_SIZE];
glGetProgramInfoLog(progObj[shaderNum], MAX_INFO_LOG_SIZE, NULL, infoLog);
//fprintf(stderr, "Program #%d info log: %s\n", shaderNum, infoLog);
}
// Program object has changed, so we should revalidate
needsValidation[shaderNum] = GL_TRUE;
}
