void Shader::Reload()
{
GLuint vs, fs;
// create ids for our vertex and frag shaders
vs = glCreateShader(GL_VERTEX_SHADER);
fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(vs, 1, &vss, NULL);
glShaderSource(fs, 1, &fss, NULL);
glCompileShader(vs);
glCompileShader(fs);
// create program, attach shaders, link.
id = glCreateProgram();
glAttachShader(id, vs);
glAttachShader(id, fs);
glBindAttribLocation(id, VERTEX_ARRAY, "VPos");
glBindAttribLocation(id, NORMAL_ARRAY, "VNor");
glBindAttribLocation(id, COORD_ARRAY, "VCoords");
glLinkProgram(id);
// We're done with these now.
glDetachShader(id, vs);
glDetachShader(id, fs);
glDeleteShader(vs);
glDeleteShader(fs);
// print out shader logs.
std::string log = getShaderLog(vs);
if (!log.empty())
Log->Print("Vertex shader log: %s", log.c_str());
log = getShaderLog(fs);
if (!log.empty())
Log->Print("Fragment shader log: %s", log.c_str());
log = getProgramLog(id);
if (!log.empty())
{
Log->Print("Shader program log: %s", log.c_str());
// XXX
Log->Print("catastrophic shader error. committing suicide.");
exit(2);
}
this->Bind();
}
/**
* Create a GLSL program object from vertex and fragment shader files.
*
* @param vShaderFile The vertex shader filename
* @param fShaderFile The fragment shader filename
* @return handle to the GLSL program
*/
GLuint createGLSLProgram(const char* vertexSource, const char* fragmentSource)
{
GLuint vertexShader;
GLuint fragmentShader;
char* log;
_program = glCreateProgram();
// Create vertex shader
vertexShader = createShader(vertexSource, GL_VERTEX_SHADER);
// Check for compile errors
if(!shaderCompileStatus(vertexShader))
{
log = getShaderLog(vertexShader);
fprintf(stderr, "Could not compile vertex shader:\n%s\n", log);
free(log);
terminate(EXIT_FAILURE);
}
// Create fragment shader
fragmentShader = createShader(fragmentSource, GL_FRAGMENT_SHADER);
// Check for compile errors
if(!shaderCompileStatus(fragmentShader))
{
log = getShaderLog(fragmentShader);
fprintf(stderr, "Could not compile fragment shader:\n%s\n", log);
free(log);
terminate(EXIT_FAILURE);
}
// Attach the shaders to the program
glAttachShader(_program, vertexShader);
glAttachShader(_program, fragmentShader);
// Link the program
glLinkProgram(_program);
// Check for linker errors
if(!programLinkStatus(_program))
{
log = getProgramLog(_program);
fprintf(stderr, "GLSL program filed to link:\n%s\n", log);
free(log);
terminate(EXIT_FAILURE);
}
return _program;
}
GLuint loadShader(const std::string& path, GLenum shaderType)
{
GLuint shaderID = 0;
std::string shaderString;
std::ifstream srcFile(path.c_str());
if (!srcFile) { throw std::runtime_error("Unable to open file."); }
shaderString.assign(std::istreambuf_iterator<char>(srcFile), std::istreambuf_iterator<char>());
shaderID = glCreateShader(shaderType);
const GLchar* shaderSrc = shaderString.c_str();
glShaderSource(shaderID, 1, (const GLchar**)&shaderSrc, NULL);
glCompileShader(shaderID);
GLint shaderCompiled = GL_FALSE;
glGetShaderiv(shaderID, GL_COMPILE_STATUS, &shaderCompiled);
if (shaderCompiled != GL_TRUE)
{
std::string msg{ getShaderLog(shaderID) };
glDeleteShader(shaderID);
throw std::runtime_error(msg);
}
return shaderID;
}
//--------------------------------------------------------------
// compile OpenGL33 shader
GLuint mgLinuxGL33Support::compileShader(
const char* source,
GLenum shaderType)
{
// Create shader objects
GLuint shader = glCreateShader(shaderType);
const GLchar* strings[1];
strings[0] = (GLchar *) source;
glShaderSource(shader, 1, strings, NULL);
const char* typeStr = (shaderType == GL_VERTEX_SHADER) ? "vertex" : "fragment";
glCompileShader(shader);
mgString log;
getShaderLog(shader, log);
log.trim();
if (log.isEmpty())
mgDebug("%s shader compiled.", typeStr);
else mgDebug("%s shader log:\n%s", typeStr, (const char*) log);
// Check for errors
GLint testVal;
glGetShaderiv(shader, GL_COMPILE_STATUS, &testVal);
if (testVal == GL_FALSE)
{
mgDebug("%s shader compilation failed.", typeStr);
return 0;
}
return shader;
}
void GlslProg::loadShader( const char *shaderSource, GLint shaderType )
{
GLuint handle = glCreateShader( shaderType );
glShaderSource( handle, 1, reinterpret_cast<const GLchar**>( &shaderSource ), NULL );
glCompileShader( handle );
GLint status;
glGetShaderiv( (GLuint) handle, GL_COMPILE_STATUS, &status );
if( status != GL_TRUE ) {
std::string log = getShaderLog( (GLuint)handle );
throw GlslProgCompileExc( log, shaderType );
}
glAttachShader( mObj->mHandle, handle );
}
int ShaderManager::checkErrorStatus(GLuint shaderObject, GLuint type)
{
GLint correct;
glGetShaderiv(shaderObject, type, &correct);
if (correct)
{
return 0;
}
else
{
getShaderLog(shaderObject);
return -1;
}
}
bool GLShader::compileShader(const char* source)
{
FZ_ASSERT(m_shader == 0, "Shader is already compiled");
m_shader = glCreateShader(m_shaderType);
glShaderSource(m_shader, 1, &source, NULL);
glCompileShader(m_shader);
GLint status;
glGetShaderiv(m_shader, GL_COMPILE_STATUS, &status);
if(!status) {
FZLOGERROR("GLShader: Error compiling %s.",shaderTypeToText(m_shaderType));
FZLOGERROR("%s", getShaderLog().c_str());
}
CHECK_GL_ERROR_DEBUG();
return !!status;
}
GLuint setupShaders() {
char *vs = NULL,*fs = NULL,*fs2 = NULL;
GLuint p,v,f;
v = glCreateShader(GL_VERTEX_SHADER);
f = glCreateShader(GL_FRAGMENT_SHADER);
vs = textFileRead((char *)vertexFileName);
fs = textFileRead((char *)fragmentFileName);
const char * vv = vs;
const char * ff = fs;
glShaderSource(v, 1, &vv,NULL);
glShaderSource(f, 1, &ff,NULL);
free(vs);free(fs);
GLint shaderCompiled;
printf("compiling vertex shader...\n");
glCompileShader(v);
glGetShaderiv(v, GL_COMPILE_STATUS, &shaderCompiled);
if(shaderCompiled == GL_FALSE)
{
char * info = getShaderLog(shaderCompiled);
if(info != NULL)printf("%s\n", info);
else printf("NULL error info.\n");
}
else
{
printf("Vertex shader compiled!\n");
}
printf("compiling fragment shader...\n");
glCompileShader(f);
glGetShaderiv(f, GL_COMPILE_STATUS, &shaderCompiled);
if(shaderCompiled == GL_FALSE)
{
char * info = getShaderLog(shaderCompiled);
if(info != NULL)printf("%s\n", info);
else printf("NULL error info.\n");
}
else
{
printf("Fragment shader compiled!\n");
}
printShaderInfoLog(v);
printShaderInfoLog(f);
p = glCreateProgram();
glAttachShader(p,v);
glAttachShader(p,f);
// glBindFragDataLocation(p, 0, "outputF");
glLinkProgram(p);
printProgramInfoLog(p);
vertexLoc = glGetAttribLocation(p,"position");
colorLoc = glGetAttribLocation(p, "color");
printf("vertexLoc: %d\n", vertexLoc);
printf("colorLoc: %d\n", colorLoc);
projMatrixLoc = glGetUniformLocation(p, "projMatrix");
viewMatrixLoc = glGetUniformLocation(p, "viewMatrix");
return(p);
}
