int LinkShaderProg (GLhandleARB *progP)
{
int i = 0;
GLint bLinked;
if (!progP) {
progP = &genShaderProg;
if (!*progP)
return 0;
if (gameOpts->ogl.bGlTexMerge)
i |= 1;
if (gameStates.render.nLightingMethod)
i |= 2;
if (!i)
return 0;
if (!CreateShaderFunc (progP, &mainFS, &mainVS, progFS [i - 1], progVS [i - 1], 0)) {
DeleteShaderProg (progP);
return 0;
}
}
glLinkProgram (*progP);
glGetObjectParameteriv (*progP, GL_OBJECT_LINK_STATUS_ARB, &bLinked);
if (bLinked)
return 1;
PrintLog (" Couldn't link shader programs\n");
PrintShaderInfoLog (*progP, 1);
DeleteShaderProg (progP);
return 0;
}
void CGLShader::Compile()
{
GLint compiled;
glCompileShader(m_shader);
glGetShaderiv(m_shader, GL_COMPILE_STATUS, &compiled);
if (!compiled)
{
std::cout << "Vertex shader not compiled.\n";
PrintShaderInfoLog();
}
}
Shader::Shader(const std::string& vertex_shader_source, const std::string& fragment_shader_source) :program(0),
vertex_shader(0),
fragment_shader(0)
{
// Create Shader And Program Objects
program = glCreateProgram();
vertex_shader = glCreateShader(GL_VERTEX_SHADER);
fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
// Load Shader Sources
char* temp = (char*)vertex_shader_source.c_str();
glShaderSource(vertex_shader, 1, (const char**)&temp, NULL);
temp = (char*)fragment_shader_source.c_str();
glShaderSource(fragment_shader, 1, (const char**)&temp, NULL);
// Compile The Shaders
fprintf(stderr, "Compiling...");
glCompileShader(vertex_shader);
PrintShaderInfoLog(vertex_shader);
glCompileShader(fragment_shader);
PrintShaderInfoLog(fragment_shader);
fprintf(stderr, "done.\n");
// Attach The Shader Objects To The Program Object
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
// Link The Program Object
fprintf(stderr, "Linking...");
glLinkProgram(program);
fprintf(stderr, "done.\n");
PrintProgramInfoLog(program);
fprintf(stderr, "===================\n");
checkGLError();
}
//--------------------------------------------------------------
//
//--------------------------------------------------------------
bool Shader::CompileSource(GLuint shaderId, char* shaderType)
{
GLint compiled;
// Compile a shader
glCompileShader(shaderId);
glGetShaderiv(shaderId, GL_COMPILE_STATUS, &compiled);
if ( compiled == GL_FALSE )
{
cerr << "Failed to compile " << shaderName.c_str() << shaderType << " shader." << endl;
return false;
}
PrintShaderInfoLog(shaderId);
return true;
}
GLuint Shader::LoadShader(std::string filename, GLenum shaderType)
{
std::string str = ReadShaderSource(filename);
const GLchar * shaderSource = (const GLchar *)str.c_str();
GLuint shader = glCreateShader(shaderType);
glShaderSource(shader, 1, &shaderSource, NULL);
glCompileShader(shader);
if (!ShaderIsCompiled(shader))
{
PrintShaderInfoLog(shader);
return 0;
}
return shader;
}
int Shader::CompileProgram(const char* vs, const char* fs, const char* gs)
{
vertSrc = vs;
fragSrc = fs;
geomSrc = gs;
const GLchar* vertexShaderSrc = (const GLchar*) vertSrc;
const GLchar* fragmentShaderSrc = (const GLchar*) fragSrc;
const GLchar* geometryShaderSrc = (const GLchar*) geomSrc;
DeleteFile("shader_vertex.log");
DeleteFile("shader_fragment.log");
DeleteFile("shader_geometry.log");
DeleteFile("shader_link.log");
DeleteFile("shader_validation.log");
GLenum vertexShader = 0;
GLenum fragmentShader = 0;
GLenum geometryShader = 0;
if(!vertSrc.IsEmpty())
{
vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSrc, NULL);
glCompileShader(vertexShader);
if(!IsProgramCompiled(vertexShader))
{
PrintShaderInfoLog(vertexShader, "shader_vertex.log");
error = "Vertex shader compilation error:\n\n" + compileError;
glDeleteShader(vertexShader);
return -1;
}
}
if(!fragSrc.IsEmpty())
{
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSrc, NULL);
glCompileShader(fragmentShader);
if(!IsProgramCompiled(fragmentShader))
{
PrintShaderInfoLog(fragmentShader, "shader_fragment.log");
error = "Fragment shader compilation error:\n\n" + compileError;
glDeleteShader(fragmentShader);
return -1;
}
}
if(!geomSrc.IsEmpty())
{
geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
glShaderSource(geometryShader, 1, &geometryShaderSrc, NULL);
glCompileShader(geometryShader);
if(!IsProgramCompiled(geometryShader))
{
PrintShaderInfoLog(geometryShader, "shader_geometry.log");
error = "Geometry shader compilation error:\n\n" + compileError;
glDeleteShader(geometryShader);
return -1;
}
}
program = glCreateProgram();
if(program > 0)
{
if(vertexShader > 0)
glAttachShader(program, vertexShader);
if(fragmentShader > 0)
glAttachShader(program, fragmentShader);
if(geometryShader > 0)
glAttachShader(program, geometryShader);
glLinkProgram(program);
if(!IsProgramLinked(program))
{
PrintProgramInfoLog(program, "shader_link.log");
PrintProgramValidationLog(program, "shader_validation.log");
glDeleteProgram(program);
program = -1;
}
}
else
program = -1;
return program;
}
int CreateShaderFunc (GLhandleARB *progP, GLhandleARB *fsP, GLhandleARB *vsP,
const char *fsName, const char *vsName, int bFromFile)
{
GLhandleARB fs, vs;
GLint bFragCompiled, bVertCompiled;
if (!gameStates.ogl.bShadersOk)
return 0;
if (!CreateShaderProg (progP))
return 0;
if (*fsP) {
glDeleteObject (*fsP);
*fsP = 0;
}
if (*vsP) {
glDeleteObject (*vsP);
*vsP = 0;
}
if (!(vs = glCreateShaderObject (GL_VERTEX_SHADER)))
return 0;
if (!(fs = glCreateShaderObject (GL_FRAGMENT_SHADER))) {
glDeleteObject (vs);
return 0;
}
#if DBG_SHADERS
if (bFromFile) {
vsName = LoadShader (vsName);
fsName = LoadShader (fsName);
if (!vsName || !fsName)
return 0;
}
#endif
glShaderSource (vs, 1, reinterpret_cast<const GLcharARB **> (&vsName), NULL);
glShaderSource (fs, 1, reinterpret_cast<const GLcharARB **> (&fsName), NULL);
#if DBG_SHADERS
if (bFromFile) {
delete[] vsName;
delete[] fsName;
}
#endif
glCompileShader (vs);
glCompileShader (fs);
glGetObjectParameteriv (vs, GL_OBJECT_COMPILE_STATUS_ARB, &bVertCompiled);
glGetObjectParameteriv (fs, GL_OBJECT_COMPILE_STATUS_ARB, &bFragCompiled);
if (!bVertCompiled || !bFragCompiled) {
if (!bVertCompiled) {
PrintLog (" Couldn't compile vertex shader\n \"%s\"\n", vsName);
PrintShaderInfoLog (vs, 0);
}
if (!bFragCompiled) {
PrintLog (" Couldn't compile fragment shader\n \"%s\"\n", fsName);
PrintShaderInfoLog (fs, 0);
}
return 0;
}
glAttachObject (*progP, vs);
glAttachObject (*progP, fs);
*fsP = fs;
*vsP = vs;
return 1;
}
