/*
=================
R_LinkGLSLShader
links the GLSL vertex and fragment shaders together to form a GLSL program
=================
*/
bool R_LinkGLSLShader( shaderProgram_t *shaderProgram, bool needsAttributes ) {
GLint linked;
shaderProgram->program = qglCreateProgramObjectARB( );
qglAttachObjectARB( shaderProgram->program, shaderProgram->vertexShader );
qglAttachObjectARB( shaderProgram->program, shaderProgram->fragmentShader );
if ( needsAttributes ) {
qglBindAttribLocationARB( shaderProgram->program, 8, "attr_TexCoord" );
qglBindAttribLocationARB( shaderProgram->program, 9, "attr_Tangent" );
qglBindAttribLocationARB( shaderProgram->program, 10, "attr_Bitangent" );
qglBindAttribLocationARB( shaderProgram->program, 11, "attr_Normal" );
}
qglLinkProgramARB( shaderProgram->program );
qglGetObjectParameterivARB( shaderProgram->program, GL_OBJECT_LINK_STATUS_ARB, &linked );
if ( !linked ) {
common->Printf( "R_LinkGLSLShader: program failed to link\n" );
return false;
}
return true;
}
static void R_InitFragmentShader( const char *filename, GLhandleARB *fragmentShader, GLhandleARB *program, GLhandleARB vertexShader, const char *fallbackShader ) {
int len;
int slen;
void *shaderSource;
char *text;
qboolean fallback = qfalse;
if ( !glsl ) {
return;
}
Com_VPrintf( "^5%s ->\n", filename );
*fragmentShader = qglCreateShaderObjectARB( GL_FRAGMENT_SHADER_ARB );
len = ri.FS_ReadFile( filename, &shaderSource );
if ( len <= 0 ) {
len = strlen(fallbackShader);
if ( len ) {
Com_VPrintf( "^1using fallback shader\n" );
//ri.FS_FreeFile(shaderSource);
//shaderSource = (void *)fallbackShader;
fallback = qtrue;
} else {
Com_VPrintf( "^1couldn't find file\n" );
R_DeleteGlslShadersAndPrograms();
glsl = qfalse;
return;
}
}
slen = strlen(ShaderExtensions);
text = (char *)malloc(len + slen + 3);
if (!text) {
Com_VPrintf( "R_InitFragmentShader() couldn't allocate memory for GLSL shader file\n" );
if ( !fallbackShader ) ri.FS_FreeFile(shaderSource);
qglDeleteObjectARB(*fragmentShader);
return;
}
Com_sprintf( text, len + slen + 3, "%s\n%s\n", ShaderExtensions, fallback ? fallbackShader : (char *)shaderSource );
qglShaderSourceARB(*fragmentShader, 1, (const char **)&text, NULL);
qglCompileShaderARB(*fragmentShader);
printGlslLog(*fragmentShader);
if ( !fallbackShader ) ri.FS_FreeFile(shaderSource);
free(text);
*program = qglCreateProgramObjectARB();
qglAttachObjectARB(*program, vertexShader);
qglAttachObjectARB(*program, *fragmentShader);
qglLinkProgramARB(*program);
printGlslLog(*program);
//Com_VPrintf("\n");
}
static GLhandleARB R_CompileGLSLShader( GLhandleARB programObject, GLenum shaderType, unsigned int sourceStringCount, const char *sourceStrings[] ) {
GLhandleARB shaderObject;
GLint shaderCompiled;
const char *shaderName;
int i;
char compileLog[ 4096 ];
if( shaderType == GL_VERTEX_SHADER_ARB ) {
shaderName = "vertex shader";
} else {
shaderName = "fragment shader";
}
// run a basic error check
for (i = 0 ; i < sourceStringCount ; i++)
{
if (sourceStrings[i] == 0)
{
Con_Printf("R_CompileGLSLShader: string #%i of %s is NULL!\n", i, shaderName);
return 0;
}
}
// R_CheckError();
shaderObject = qglCreateShaderObjectARB( shaderType );
if( shaderObject == 0 )
{
// R_CheckError();
return 0;
}
if( sourceStringCount != 0 ) {
qglShaderSourceARB( shaderObject, sourceStringCount, sourceStrings, NULL);
qglCompileShaderARB( shaderObject );
// R_CheckError();
qglGetObjectParameterivARB( shaderObject, GL_OBJECT_COMPILE_STATUS_ARB, &shaderCompiled );
qglGetInfoLogARB( shaderObject, sizeof(compileLog), NULL, compileLog);
if( *compileLog ) {
Con_Printf("%s compile log:\n%s\n", shaderName, compileLog);
}
if( !shaderCompiled ) {
qglDeleteObjectARB( shaderObject );
// R_CheckError();
return 0;
}
}
// TODO: check whether an empty shader object can be compiled!
qglAttachObjectARB( programObject, shaderObject);
qglDeleteObjectARB( shaderObject );
//R_CheckError();
return shaderObject;
}
static int GLSL_CompileGPUShader(GLhandleARB program, GLhandleARB *prevShader, const GLcharARB *buffer, int size, GLenum shaderType)
{
GLint compiled;
GLhandleARB shader;
shader = qglCreateShaderObjectARB(shaderType);
qglShaderSourceARB(shader, 1, (const GLcharARB **)&buffer, &size);
// compile shader
qglCompileShaderARB(shader);
// check if shader compiled
qglGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
if(!compiled)
{
GLSL_PrintShaderSource(shader);
GLSL_PrintInfoLog(shader, qfalse);
ri.Error(ERR_DROP, "Couldn't compile shader");
return 0;
}
//GLSL_PrintInfoLog(shader, qtrue);
//GLSL_PrintShaderSource(shader);
if (*prevShader)
{
qglDetachObjectARB(program, *prevShader);
qglDeleteObjectARB(*prevShader);
}
// attach shader to program
qglAttachObjectARB(program, shader);
*prevShader = shader;
return 1;
}
