static void RB_BloomDownSample( void ) {
GLenum target;
int width, height;
GLint loc;
GL_SelectTexture(0);
qglDisable(GL_TEXTURE_2D);
qglEnable(GL_TEXTURE_RECTANGLE_ARB);
target = GL_TEXTURE_RECTANGLE_ARB;
width = glConfig.vidWidth;
height = glConfig.vidHeight;
qglBindTexture(target, tr.backBufferTexture);
qglCopyTexSubImage2D(target, 0, 0, 0, 0, 0, glConfig.vidWidth, glConfig.vidHeight);
GL_SelectTexture(1);
qglDisable(GL_TEXTURE_2D);
qglEnable(GL_TEXTURE_RECTANGLE_ARB);
qglBindTexture(target, tr.bloomTexture);
qglUseProgramObjectARB(tr.downSample1Sp);
loc = qglGetUniformLocationARB(tr.downSample1Sp, "backBufferTex");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get backBufferTex", __FUNCTION__);
}
qglUniform1iARB(loc, 0);
//qglDisable(GL_BLEND);
qglBegin(GL_QUADS);
qglMultiTexCoord2iARB(GL_TEXTURE0_ARB, 0, 0);
qglMultiTexCoord2iARB(GL_TEXTURE1_ARB, 0, 0);
qglVertex2i(0, tr.bloomHeight);
qglMultiTexCoord2iARB(GL_TEXTURE0_ARB, width, 0);
qglMultiTexCoord2iARB(GL_TEXTURE1_ARB, width, 0);
qglVertex2i(tr.bloomWidth, tr.bloomHeight);
qglMultiTexCoord2iARB(GL_TEXTURE0_ARB, width, height);
qglMultiTexCoord2iARB(GL_TEXTURE1_ARB, width, height);
qglVertex2i(tr.bloomWidth, 0);
qglMultiTexCoord2iARB(GL_TEXTURE0_ARB, 0, height);
qglMultiTexCoord2iARB(GL_TEXTURE1_ARB, 0, height);
qglVertex2i(0, 0);
qglEnd();
qglUseProgramObjectARB(0);
qglDisable(GL_TEXTURE_RECTANGLE_ARB);
qglDisable(GL_TEXTURE_2D);
GL_SelectTexture(0);
qglDisable(GL_TEXTURE_RECTANGLE_ARB);
qglEnable(GL_TEXTURE_2D);
}
static void RB_BloomBrightness( void ) {
GLenum target;
int width, height;
GLint loc;
GL_SelectTexture(0);
qglDisable(GL_TEXTURE_2D);
qglEnable(GL_TEXTURE_RECTANGLE_ARB);
target = GL_TEXTURE_RECTANGLE_ARB;
width = tr.bloomWidth;
height = tr.bloomHeight;
qglBindTexture(target, tr.bloomTexture);
qglCopyTexSubImage2D(target, 0, 0, 0, 0, glConfig.vidHeight - height, width, height);
qglUseProgramObjectARB(tr.brightPassSp);
loc = qglGetUniformLocationARB(tr.brightPassSp, "backBufferTex");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get backBufferTex", __FUNCTION__);
}
qglUniform1iARB(loc, 0);
loc = qglGetUniformLocationARB(tr.brightPassSp, "p_brightthreshold");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get p_brightthreshold", __FUNCTION__);
}
qglUniform1fARB(loc, (GLfloat)r_BloomBrightThreshold->value);
qglBegin(GL_QUADS);
qglTexCoord2i(0, 0);
qglVertex2i(0, height);
qglTexCoord2i(width, 0);
qglVertex2i(width, height);
qglTexCoord2i(width, height);
qglVertex2i(width, 0);
qglTexCoord2i(0, height);
qglVertex2i(0, 0);
qglEnd();
qglUseProgramObjectARB(0);
qglDisable(GL_TEXTURE_RECTANGLE_ARB);
qglEnable(GL_TEXTURE_2D);
}
/*
image unit 1 contains the diffuse map
image unit 2 contains the cube map
image unit 3 contains the normal map (not yet)
image unit 4 contains the specular map (not yet)
texture coordinate unit 1 contains the texture coordinates
*/
void R_Shader_StartLightRendering() {
assert( R_Shader_CanRenderLights() );
/*
what it needs to do:
-set the blend mode
-set uniforms (lightDirection and viewerDirection) and samplers
*/
glEnable( GL_BLEND );
glBlendFunc( GL_ONE, GL_ONE );
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
qglUseProgramObjectARB( r_refdef.lightShader.programObject );
// TODO: move the sampler initialization into Init!
// sample initialization
qglUniform1iARB( r_refdef.lightShader.diffuseSampler, 0 );
qglUniform1iARB( r_refdef.lightShader.cubemapSampler, 1 );
//glUniform1iARB( r_refdef.lightShader.normalSampler, 2 );
//glUniform1iARB( r_refdef.lightShader.specularSampler, 3 );
// setup the light position (view-space)
r_refdef.lightShader.worldToViewMatrix = GetWorldToViewMatrix();
}
void Gui_Render()
{
const text_shader_description *shader = renderer.shaderManager->getTextShader();
screenSize[0] = screen_info.w;
screenSize[1] = screen_info.h;
qglUseProgramObjectARB(shader->program);
qglUniform1iARB(shader->sampler, 0);
qglUniform2fvARB(shader->screenSize, 1, screenSize);
qglUniform1fARB(shader->colorReplace, 0.0f);
qglPushAttrib(GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
qglPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT | GL_CLIENT_VERTEX_ARRAY_BIT);
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
qglPolygonMode(GL_FRONT, GL_FILL);
qglFrontFace(GL_CCW);
qglEnable(GL_BLEND);
qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
qglDisable(GL_ALPHA_TEST);
if(World_GetPlayer() && main_inventory_manager)
{
Gui_DrawInventory(engine_frame_time);
}
Gui_DrawNotifier(engine_frame_time);
qglUseProgramObjectARB(shader->program);
qglDepthMask(GL_FALSE);
qglPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
qglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if(screen_info.crosshair != 0)
{
Gui_DrawCrosshair();
}
Gui_DrawBars();
qglUniform1fARB(shader->colorReplace, 1.0f);
GLText_RenderStrings();
Con_Draw(engine_frame_time);
qglUniform1fARB(shader->colorReplace, 0.0f);
qglDepthMask(GL_TRUE);
qglPopClientAttrib();
qglPopAttrib();
}
void Gui_DrawLoadScreen(int value)
{
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
qglPushAttrib(GL_ENABLE_BIT | GL_PIXEL_MODE_BIT | GL_COLOR_BUFFER_BIT);
qglPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
qglPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE);
qglPixelStorei(GL_UNPACK_ALIGNMENT, 1);
qglEnableClientState(GL_VERTEX_ARRAY);
qglEnableClientState(GL_TEXTURE_COORD_ARRAY);
qglEnableClientState(GL_COLOR_ARRAY);
qglDisableClientState(GL_NORMAL_ARRAY);
qglEnable(GL_BLEND);
qglEnable(GL_TEXTURE_2D);
qglDisable(GL_ALPHA_TEST);
qglDepthMask(GL_FALSE);
qglPolygonMode(GL_FRONT, GL_FILL);
qglFrontFace(GL_CCW);
const GLfloat color_w[4] = {1.0f, 1.0f, 1.0f, 1.0f};
const text_shader_description *shader = renderer.shaderManager->getTextShader();
screenSize[0] = screen_info.w;
screenSize[1] = screen_info.h;
qglUseProgramObjectARB(shader->program);
qglUniform1iARB(shader->sampler, 0);
qglUniform2fvARB(shader->screenSize, 1, screenSize);
Gui_DrawRect(0.0, 0.0, screen_info.w, screen_info.h, color_w, color_w, color_w, color_w, BM_OPAQUE, load_screen_tex);
if(value >= 0)
{
Bar[BAR_LOADING].Show(value);
}
qglDepthMask(GL_TRUE);
qglPopClientAttrib();
qglPopAttrib();
Engine_GLSwapWindow();
}
void GLSL_SetUniformInt(shaderProgram_t *program, int uniformNum, GLint value)
{
GLint *uniforms = program->uniforms;
GLint *compare = (GLint *)(program->uniformBuffer + program->uniformBufferOffsets[uniformNum]);
if (uniforms[uniformNum] == -1)
return;
if (uniformsInfo[uniformNum].type != GLSL_INT)
{
ri.Printf( PRINT_WARNING, "GLSL_SetUniformInt: wrong type for uniform %i in program %s\n", uniformNum, program->name);
return;
}
if (value == *compare)
{
return;
}
*compare = value;
qglUniform1iARB(uniforms[uniformNum], value);
}
GLvoid APIENTRY GLDSA_ProgramUniform1i(GLuint program, GLint location, GLint v0)
{
GL_UseProgramObject(program);
qglUniform1iARB(location, v0);
}
/*
==================
RB_GLSL_DrawInteraction
==================
*/
static void RB_GLSL_DrawInteraction( const drawInteraction_t *din ) {
// load all the shader parameters
if ( din->ambientLight ) {
// ---> sikk - Included non-power-of-two/frag position conversion
// screen power of two correction factor, assuming the copy to _currentRender
// also copied an extra row and column for the bilerp
float parm[ 4 ];
int w = backEnd.viewDef->viewport.x2 - backEnd.viewDef->viewport.x1 + 1;
int h = backEnd.viewDef->viewport.y2 - backEnd.viewDef->viewport.y1 + 1;
parm[0] = (float)w / globalImages->currentRenderImage->uploadWidth;
parm[1] = (float)h / globalImages->currentRenderImage->uploadHeight;
parm[2] = parm[0] / w; // sikk - added - one less fragment shader instruction
parm[3] = parm[1] / h; // sikk - added - one less fragment shader instruction
qglUniform4fvARB( interactionAmbShader.nonPoT, 1, parm );
// window coord to 0.0 to 1.0 conversion
parm[0] = 1.0 / w;
parm[1] = 1.0 / h;
parm[2] = w; // sikk - added - can be useful to have resolution size in shader
parm[3] = h; // sikk - added - can be useful to have resolution size in shader
qglUniform4fvARB( interactionAmbShader.invRes, 1, parm );
// <--- sikk - Included non-power-of-two/frag position conversion
qglUniform4fvARB( interactionAmbShader.localLightOrigin, 1, din->localLightOrigin.ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.localViewOrigin, 1, din->localViewOrigin.ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.lightProjectionS, 1, din->lightProjection[0].ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.lightProjectionT, 1, din->lightProjection[1].ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.lightProjectionQ, 1, din->lightProjection[2].ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.lightFalloff, 1, din->lightProjection[3].ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.bumpMatrixS, 1, din->bumpMatrix[0].ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.bumpMatrixT, 1, din->bumpMatrix[1].ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.diffuseMatrixS, 1, din->diffuseMatrix[0].ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.diffuseMatrixT, 1, din->diffuseMatrix[1].ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.specularMatrixS, 1, din->specularMatrix[0].ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.specularMatrixT, 1, din->specularMatrix[1].ToFloatPtr() );
// ---> sikk - Include model matrix for to-world-space transformations
const struct viewEntity_s *space = backEnd.currentSpace;
qglUniformMatrix4fvARB( interactionAmbShader.modelMatrix, 1, 0, space->modelMatrix );
// <--- sikk - Include model matrix for to-world-space transformations
static const float ignore[ 4 ] = { 0.0, 1.0, 1.0, 1.0 };
static const float modulate[ 4 ] = { 1.0, 0.0, 1.0, 1.0 };
static const float inv_modulate[ 4 ] = { -1.0, 1.0, 1.0, 1.0 };
switch ( din->vertexColor ) {
case SVC_IGNORE:
qglUniform4fvARB( interactionAmbShader.colorMAD, 1, ignore );
break;
case SVC_MODULATE:
qglUniform4fvARB( interactionAmbShader.colorMAD, 1, modulate );
break;
case SVC_INVERSE_MODULATE:
qglUniform4fvARB( interactionAmbShader.colorMAD, 1, inv_modulate );
break;
}
// set the constant color
qglUniform4fvARB( interactionAmbShader.diffuseColor, 1, din->diffuseColor.ToFloatPtr() );
qglUniform4fvARB( interactionAmbShader.specularColor, 1, din->specularColor.ToFloatPtr() );
} else {
// ---> sikk - Included non-power-of-two/frag position conversion
// screen power of two correction factor, assuming the copy to _currentRender
// also copied an extra row and column for the bilerp
float parm[ 4 ];
int w = backEnd.viewDef->viewport.x2 - backEnd.viewDef->viewport.x1 + 1;
int h = backEnd.viewDef->viewport.y2 - backEnd.viewDef->viewport.y1 + 1;
parm[0] = (float)w / globalImages->currentRenderImage->uploadWidth;
parm[1] = (float)h / globalImages->currentRenderImage->uploadHeight;
parm[2] = parm[0] / w; // sikk - added - one less fragment shader instruction
parm[3] = parm[1] / h; // sikk - added - one less fragment shader instruction
qglUniform4fvARB( interactionDirShader.nonPoT, 1, parm );
// window coord to 0.0 to 1.0 conversion
parm[0] = 1.0 / w;
parm[1] = 1.0 / h;
parm[2] = w; // sikk - added - can be useful to have resolution size in shader
parm[3] = h; // sikk - added - can be useful to have resolution size in shader
qglUniform4fvARB( interactionDirShader.invRes, 1, parm );
// <--- sikk - Included non-power-of-two/frag position conversion
qglUniform4fvARB( interactionDirShader.localLightOrigin, 1, din->localLightOrigin.ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.localViewOrigin, 1, din->localViewOrigin.ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.lightProjectionS, 1, din->lightProjection[0].ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.lightProjectionT, 1, din->lightProjection[1].ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.lightProjectionQ, 1, din->lightProjection[2].ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.lightFalloff, 1, din->lightProjection[3].ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.bumpMatrixS, 1, din->bumpMatrix[0].ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.bumpMatrixT, 1, din->bumpMatrix[1].ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.diffuseMatrixS, 1, din->diffuseMatrix[0].ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.diffuseMatrixT, 1, din->diffuseMatrix[1].ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.specularMatrixS, 1, din->specularMatrix[0].ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.specularMatrixT, 1, din->specularMatrix[1].ToFloatPtr() );
// ---> sikk - Include model matrix for to-world-space transformations
const struct viewEntity_s *space = backEnd.currentSpace;
qglUniformMatrix4fvARB( interactionDirShader.modelMatrix, 1, 0, space->modelMatrix );
// <--- sikk - Include model matrix for to-world-space transformations
if ( !backEnd.vLight->lightDef->parms.pointLight ) { // 2D Light Shader (projected lights)
qglUniform1iARB( interactionDirShader.falloffType, 2 );
//qglUseProgramObjectARB( interactionDirShader.program );
//qglUniform1iARB( interactionDirShader.u_lightProjectionTexture, 0 );
//qglUseProgramObjectARB( 0 );
} else { // 3D Light Shader (point lights)
if ( backEnd.vLight->lightDef->parms.parallel ) { // shader specific for sun light (no attenuation)
qglUniform1iARB( interactionDirShader.falloffType, 1 );
} else { // default quadratic attenuation
qglUniform1iARB( interactionDirShader.falloffType, 0 );
}
}
static const float ignore[ 4 ] = { 0.0, 1.0, 1.0, 1.0 };
static const float modulate[ 4 ] = { 1.0, 0.0, 1.0, 1.0 };
static const float inv_modulate[ 4 ] = { -1.0, 1.0, 1.0, 1.0 };
switch ( din->vertexColor ) {
case SVC_IGNORE:
qglUniform4fvARB( interactionDirShader.colorMAD, 1, ignore );
break;
case SVC_MODULATE:
qglUniform4fvARB( interactionDirShader.colorMAD, 1, modulate );
break;
case SVC_INVERSE_MODULATE:
qglUniform4fvARB( interactionDirShader.colorMAD, 1, inv_modulate );
break;
}
// set the constant colors
qglUniform4fvARB( interactionDirShader.diffuseColor, 1, din->diffuseColor.ToFloatPtr() );
qglUniform4fvARB( interactionDirShader.specularColor, 1, din->specularColor.ToFloatPtr() );
}
// set the textures
// texture 0 will be the light projection texture
GL_SelectTextureNoClient( 0 );
din->lightImage->Bind();
if ( !din->ambientLight ) {
GL_SelectTextureNoClient( 16 );
din->lightImage->Bind();
}
// texture 1 will be the light falloff texture
GL_SelectTextureNoClient( 1 );
din->lightFalloffImage->Bind();
// texture 1 will be the per-surface bump map
GL_SelectTextureNoClient( 2 );
din->bumpImage->Bind();
// texture 2 is the per-surface diffuse map
GL_SelectTextureNoClient( 3 );
din->diffuseImage->Bind();
// texture 3 is the per-surface specular map
GL_SelectTextureNoClient( 4 );
din->specularImage->Bind();
// texture 4 is the ssao buffer
GL_SelectTextureNoClient( 5 );
globalImages->ssaoImage->Bind();
// ---> sikk - Auxilary textures for interaction shaders
// per-surface auxilary texture 0 - 9
for ( int i = 0; i < din->surf->material->GetNumInteractionImages(); i++ ) {
GL_SelectTextureNoClient( i + 6 );
din->surf->material->GetInteractionImage( i )->Bind();
}
// <--- sikk - Auxilary textures for interaction shaders
// draw it
RB_DrawElementsWithCounters( din->surf->geo );
}
/*
==================
RB_GLSL_InitShaders
==================
*/
static bool RB_GLSL_InitShaders( ) {
// load interation shaders
R_LoadGLSLShader( "interaction_Dir.vs", &interactionDirShader, GL_VERTEX_SHADER_ARB );
R_LoadGLSLShader( "interaction_Dir.fs", &interactionDirShader, GL_FRAGMENT_SHADER_ARB );
if ( !R_LinkGLSLShader( &interactionDirShader, true ) && !R_ValidateGLSLProgram( &interactionDirShader ) ) {
return false;
} else {
// set uniform locations
interactionDirShader.u_lightCubeTexture = qglGetUniformLocationARB( interactionDirShader.program, "u_lightCubeTexture" );
interactionDirShader.u_lightProjectionTexture = qglGetUniformLocationARB( interactionDirShader.program, "u_lightProjectionTexture" );
interactionDirShader.u_lightFalloffTexture = qglGetUniformLocationARB( interactionDirShader.program, "u_lightFalloffTexture" );
interactionDirShader.u_normalTexture = qglGetUniformLocationARB( interactionDirShader.program, "u_normalTexture" );
interactionDirShader.u_diffuseTexture = qglGetUniformLocationARB( interactionDirShader.program, "u_diffuseTexture" );
interactionDirShader.u_specularTexture = qglGetUniformLocationARB( interactionDirShader.program, "u_specularTexture" );
interactionDirShader.u_ssaoTexture = qglGetUniformLocationARB( interactionDirShader.program, "u_ssaoTexture" );
interactionDirShader.u_aux0Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux0Texture" );
interactionDirShader.u_aux1Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux1Texture" );
interactionDirShader.u_aux2Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux2Texture" );
interactionDirShader.u_aux3Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux3Texture" );
interactionDirShader.u_aux4Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux4Texture" );
interactionDirShader.u_aux5Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux5Texture" );
interactionDirShader.u_aux6Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux6Texture" );
interactionDirShader.u_aux7Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux7Texture" );
interactionDirShader.u_aux8Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux8Texture" );
interactionDirShader.u_aux9Texture = qglGetUniformLocationARB( interactionDirShader.program, "u_aux9Texture" );
interactionDirShader.modelMatrix = qglGetUniformLocationARB( interactionDirShader.program, "u_modelMatrix" );
interactionDirShader.localLightOrigin = qglGetUniformLocationARB( interactionDirShader.program, "u_lightOrigin" );
interactionDirShader.localViewOrigin = qglGetUniformLocationARB( interactionDirShader.program, "u_viewOrigin" );
interactionDirShader.lightProjectionS = qglGetUniformLocationARB( interactionDirShader.program, "u_lightProjectionS" );
interactionDirShader.lightProjectionT = qglGetUniformLocationARB( interactionDirShader.program, "u_lightProjectionT" );
interactionDirShader.lightProjectionQ = qglGetUniformLocationARB( interactionDirShader.program, "u_lightProjectionQ" );
interactionDirShader.lightFalloff = qglGetUniformLocationARB( interactionDirShader.program, "u_lightFalloff" );
interactionDirShader.bumpMatrixS = qglGetUniformLocationARB( interactionDirShader.program, "u_bumpMatrixS" );
interactionDirShader.bumpMatrixT = qglGetUniformLocationARB( interactionDirShader.program, "u_bumpMatrixT" );
interactionDirShader.diffuseMatrixS = qglGetUniformLocationARB( interactionDirShader.program, "u_diffuseMatrixS" );
interactionDirShader.diffuseMatrixT = qglGetUniformLocationARB( interactionDirShader.program, "u_diffuseMatrixT" );
interactionDirShader.specularMatrixS = qglGetUniformLocationARB( interactionDirShader.program, "u_specularMatrixS" );
interactionDirShader.specularMatrixT = qglGetUniformLocationARB( interactionDirShader.program, "u_specularMatrixT" );
interactionDirShader.specularMatrixT = qglGetUniformLocationARB( interactionDirShader.program, "u_specularMatrixT" );
interactionDirShader.colorMAD = qglGetUniformLocationARB( interactionDirShader.program, "u_colorMAD" );
interactionDirShader.diffuseColor = qglGetUniformLocationARB( interactionDirShader.program, "u_diffuseColor" );
interactionDirShader.specularColor = qglGetUniformLocationARB( interactionDirShader.program, "u_specularColor" );
interactionDirShader.falloffType = qglGetUniformLocationARB( interactionDirShader.program, "u_falloffType" );
interactionDirShader.specExp = qglGetUniformLocationARB( interactionDirShader.program, "u_specExp" );
interactionDirShader.localParms[0] = qglGetUniformLocationARB( interactionDirShader.program, "u_localParm0" );
interactionDirShader.localParms[1] = qglGetUniformLocationARB( interactionDirShader.program, "u_localParm1" );
interactionDirShader.localParms[2] = qglGetUniformLocationARB( interactionDirShader.program, "u_localParm2" );
interactionDirShader.localParms[3] = qglGetUniformLocationARB( interactionDirShader.program, "u_localParm3" );
interactionDirShader.localParms[4] = qglGetUniformLocationARB( interactionDirShader.program, "u_localParm4" );
interactionDirShader.localParms[5] = qglGetUniformLocationARB( interactionDirShader.program, "u_localParm5" );
interactionDirShader.localParms[6] = qglGetUniformLocationARB( interactionDirShader.program, "u_localParm6" );
interactionDirShader.localParms[7] = qglGetUniformLocationARB( interactionDirShader.program, "u_localParm7" );
// set texture locations
qglUseProgramObjectARB( interactionDirShader.program );
qglUniform1iARB( interactionDirShader.u_lightCubeTexture, 0 );
qglUniform1iARB( interactionDirShader.u_lightProjectionTexture, 16 );
qglUniform1iARB( interactionDirShader.u_lightFalloffTexture, 1 );
qglUniform1iARB( interactionDirShader.u_normalTexture, 2 );
qglUniform1iARB( interactionDirShader.u_diffuseTexture, 3 );
qglUniform1iARB( interactionDirShader.u_specularTexture, 4 );
qglUniform1iARB( interactionDirShader.u_ssaoTexture, 5 );
qglUniform1iARB( interactionDirShader.u_aux0Texture, 6 );
qglUniform1iARB( interactionDirShader.u_aux1Texture, 7 );
qglUniform1iARB( interactionDirShader.u_aux2Texture, 8 );
qglUniform1iARB( interactionDirShader.u_aux3Texture, 9 );
qglUniform1iARB( interactionDirShader.u_aux4Texture, 10 );
qglUniform1iARB( interactionDirShader.u_aux5Texture, 11 );
qglUniform1iARB( interactionDirShader.u_aux6Texture, 12 );
qglUniform1iARB( interactionDirShader.u_aux7Texture, 13 );
qglUniform1iARB( interactionDirShader.u_aux8Texture, 14 );
qglUniform1iARB( interactionDirShader.u_aux9Texture, 15 );
qglUseProgramObjectARB( 0 );
}
// load ambient interation shaders
R_LoadGLSLShader( "interaction_Amb.vs", &interactionAmbShader, GL_VERTEX_SHADER_ARB );
R_LoadGLSLShader( "interaction_Amb.fs", &interactionAmbShader, GL_FRAGMENT_SHADER_ARB );
if ( !R_LinkGLSLShader( &interactionAmbShader, true ) && !R_ValidateGLSLProgram( &interactionAmbShader ) ) {
return false;
} else {
// set uniform locations
interactionAmbShader.u_lightCubeTexture = qglGetUniformLocationARB( interactionAmbShader.program, "u_lightCubeTexture" );
interactionAmbShader.u_lightFalloffTexture = qglGetUniformLocationARB( interactionAmbShader.program, "u_lightFalloffTexture" );
interactionAmbShader.u_normalTexture = qglGetUniformLocationARB( interactionAmbShader.program, "u_normalTexture" );
interactionAmbShader.u_diffuseTexture = qglGetUniformLocationARB( interactionAmbShader.program, "u_diffuseTexture" );
interactionAmbShader.u_specularTexture = qglGetUniformLocationARB( interactionAmbShader.program, "u_specularTexture" );
interactionAmbShader.u_ssaoTexture = qglGetUniformLocationARB( interactionAmbShader.program, "u_ssaoTexture" );
interactionAmbShader.u_aux0Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux0Texture" );
interactionAmbShader.u_aux1Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux1Texture" );
interactionAmbShader.u_aux2Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux2Texture" );
interactionAmbShader.u_aux3Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux3Texture" );
interactionAmbShader.u_aux4Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux4Texture" );
interactionAmbShader.u_aux5Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux5Texture" );
interactionAmbShader.u_aux6Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux6Texture" );
interactionAmbShader.u_aux7Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux7Texture" );
interactionAmbShader.u_aux8Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux8Texture" );
interactionAmbShader.u_aux9Texture = qglGetUniformLocationARB( interactionAmbShader.program, "u_aux9Texture" );
interactionAmbShader.modelMatrix = qglGetUniformLocationARB( interactionAmbShader.program, "u_modelMatrix" );
interactionAmbShader.localLightOrigin = qglGetUniformLocationARB( interactionAmbShader.program, "u_lightOrigin" );
interactionAmbShader.localViewOrigin = qglGetUniformLocationARB( interactionAmbShader.program, "u_viewOrigin" );
interactionAmbShader.lightProjectionS = qglGetUniformLocationARB( interactionAmbShader.program, "u_lightProjectionS" );
interactionAmbShader.lightProjectionT = qglGetUniformLocationARB( interactionAmbShader.program, "u_lightProjectionT" );
interactionAmbShader.lightProjectionQ = qglGetUniformLocationARB( interactionAmbShader.program, "u_lightProjectionQ" );
interactionAmbShader.lightFalloff = qglGetUniformLocationARB( interactionAmbShader.program, "u_lightFalloff" );
interactionAmbShader.bumpMatrixS = qglGetUniformLocationARB( interactionAmbShader.program, "u_bumpMatrixS" );
interactionAmbShader.bumpMatrixT = qglGetUniformLocationARB( interactionAmbShader.program, "u_bumpMatrixT" );
interactionAmbShader.diffuseMatrixS = qglGetUniformLocationARB( interactionAmbShader.program, "u_diffuseMatrixS" );
interactionAmbShader.diffuseMatrixT = qglGetUniformLocationARB( interactionAmbShader.program, "u_diffuseMatrixT" );
interactionAmbShader.specularMatrixS = qglGetUniformLocationARB( interactionAmbShader.program, "u_specularMatrixS" );
interactionAmbShader.specularMatrixT = qglGetUniformLocationARB( interactionAmbShader.program, "u_specularMatrixT" );
interactionAmbShader.colorMAD = qglGetUniformLocationARB( interactionAmbShader.program, "u_colorMAD" );
interactionAmbShader.diffuseColor = qglGetUniformLocationARB( interactionAmbShader.program, "u_diffuseColor" );
interactionAmbShader.specularColor = qglGetUniformLocationARB( interactionAmbShader.program, "u_specularColor" );
interactionAmbShader.specExp = qglGetUniformLocationARB( interactionAmbShader.program, "u_specExp" );
interactionAmbShader.localParms[0] = qglGetUniformLocationARB( interactionAmbShader.program, "u_localParm0" );
interactionAmbShader.localParms[1] = qglGetUniformLocationARB( interactionAmbShader.program, "u_localParm1" );
interactionAmbShader.localParms[2] = qglGetUniformLocationARB( interactionAmbShader.program, "u_localParm2" );
interactionAmbShader.localParms[3] = qglGetUniformLocationARB( interactionAmbShader.program, "u_localParm3" );
interactionAmbShader.localParms[4] = qglGetUniformLocationARB( interactionAmbShader.program, "u_localParm4" );
interactionAmbShader.localParms[5] = qglGetUniformLocationARB( interactionAmbShader.program, "u_localParm5" );
interactionAmbShader.localParms[6] = qglGetUniformLocationARB( interactionAmbShader.program, "u_localParm6" );
interactionAmbShader.localParms[7] = qglGetUniformLocationARB( interactionAmbShader.program, "u_localParm7" );
// set texture locations
qglUseProgramObjectARB( interactionAmbShader.program );
qglUniform1iARB( interactionAmbShader.u_lightCubeTexture, 0 );
qglUniform1iARB( interactionAmbShader.u_lightFalloffTexture, 1 );
qglUniform1iARB( interactionAmbShader.u_normalTexture, 2 );
qglUniform1iARB( interactionAmbShader.u_diffuseTexture, 3 );
qglUniform1iARB( interactionAmbShader.u_specularTexture, 4 );
qglUniform1iARB( interactionAmbShader.u_ssaoTexture, 5 );
qglUniform1iARB( interactionAmbShader.u_aux0Texture, 6 );
qglUniform1iARB( interactionAmbShader.u_aux1Texture, 7 );
qglUniform1iARB( interactionAmbShader.u_aux2Texture, 8 );
qglUniform1iARB( interactionAmbShader.u_aux3Texture, 9 );
qglUniform1iARB( interactionAmbShader.u_aux4Texture, 10 );
qglUniform1iARB( interactionAmbShader.u_aux5Texture, 11 );
qglUniform1iARB( interactionAmbShader.u_aux6Texture, 12 );
qglUniform1iARB( interactionAmbShader.u_aux7Texture, 13 );
qglUniform1iARB( interactionAmbShader.u_aux8Texture, 14 );
qglUniform1iARB( interactionAmbShader.u_aux9Texture, 15 );
qglUseProgramObjectARB( 0 );
}
// load stencil shadow extrusion shaders
R_LoadGLSLShader( "stencilshadow.vs", &stencilShadowShader, GL_VERTEX_SHADER_ARB );
R_LoadGLSLShader( "stencilshadow.fs", &stencilShadowShader, GL_FRAGMENT_SHADER_ARB );
if ( !R_LinkGLSLShader( &stencilShadowShader, false ) && !R_ValidateGLSLProgram( &stencilShadowShader ) ) {
return false;
} else {
// set uniform locations
stencilShadowShader.localLightOrigin = qglGetUniformLocationARB( stencilShadowShader.program, "u_lightOrigin" );
}
return true;
}
void RB_ColorCorrect( void ) {
GLint loc;
GLenum target;
int width, height;
int shift;
float mul;
if ( !r_enablePostProcess->integer || !r_enableColorCorrect->integer || !glsl ) {
return;
}
GL_SelectTexture(0);
qglDisable(GL_TEXTURE_2D);
qglEnable(GL_TEXTURE_RECTANGLE_ARB);
target = GL_TEXTURE_RECTANGLE_ARB;
width = glConfig.vidWidth;
height = glConfig.vidHeight;
qglBindTexture(target, tr.backBufferTexture);
qglCopyTexSubImage2D(target, 0, 0, 0, 0, 0, glConfig.vidWidth, glConfig.vidHeight);
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
RB_SetGL2D();
GL_State( GLS_DEPTHTEST_DISABLE );
qglUseProgramObjectARB(tr.colorCorrectSp);
loc = qglGetUniformLocationARB(tr.colorCorrectSp, "p_gammaRecip");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get p_gammaRecip", __FUNCTION__);
}
qglUniform1fARB(loc, (GLfloat)(1.0 / r_gamma->value));
//mul = r_overBrightBitsValue->value;
mul = r_overBrightBits->value;
if (mul < 0.0) {
mul = 0.0;
}
shift = tr.overbrightBits;
loc = qglGetUniformLocationARB(tr.colorCorrectSp, "p_overbright");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get p_overbright", __FUNCTION__);
}
qglUniform1fARB(loc, (GLfloat)((float)(1 << shift) * mul));
loc = qglGetUniformLocationARB(tr.colorCorrectSp, "p_contrast");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get p_contrast", __FUNCTION__);
}
qglUniform1fARB(loc, (GLfloat)r_contrast->value);
loc = qglGetUniformLocationARB(tr.colorCorrectSp, "backBufferTex");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get backBufferTex", __FUNCTION__);
}
qglUniform1iARB(loc, 0);
qglBegin(GL_QUADS);
qglTexCoord2i(0, 0);
qglVertex2i(0, height);
qglTexCoord2i(width, 0);
qglVertex2i(width, height);
qglTexCoord2i(width, height);
qglVertex2i(width, 0);
qglTexCoord2i(0, height);
qglVertex2i(0, 0);
qglEnd();
qglUseProgramObjectARB(0);
qglDisable(GL_TEXTURE_RECTANGLE_ARB);
qglEnable(GL_TEXTURE_2D);
}
static void RB_BloomCombine( void ) {
GLenum target;
int width, height;
GLint loc;
GL_SelectTexture(0);
qglDisable(GL_TEXTURE_2D);
qglEnable(GL_TEXTURE_RECTANGLE_ARB);
target = GL_TEXTURE_RECTANGLE_ARB;
width = tr.bloomWidth;
height = tr.bloomHeight;
qglBindTexture(target, tr.bloomTexture);
qglCopyTexSubImage2D(target, 0, 0, 0, 0, glConfig.vidHeight - height, width, height);
qglUseProgramObjectARB(tr.combineSp);
qglBindTexture(target, tr.backBufferTexture);
loc = qglGetUniformLocationARB(tr.combineSp, "backBufferTex");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get backBufferTex", __FUNCTION__);
}
qglUniform1iARB(loc, 0);
GL_SelectTexture(1);
qglDisable(GL_TEXTURE_2D);
qglEnable(GL_TEXTURE_RECTANGLE_ARB);
qglBindTexture(target, tr.bloomTexture);
loc = qglGetUniformLocationARB(tr.combineSp, "bloomTex");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get bloomTex", __FUNCTION__);
}
qglUniform1iARB(loc, 1);
loc = qglGetUniformLocationARB(tr.combineSp, "p_bloomsaturation");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get p_bloomsaturation", __FUNCTION__);
}
qglUniform1fARB(loc, (GLfloat)r_BloomSaturation->value);
loc = qglGetUniformLocationARB(tr.combineSp, "p_scenesaturation");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get p_scenesaturation", __FUNCTION__);
}
qglUniform1fARB(loc, (GLfloat)r_BloomSceneSaturation->value);
loc = qglGetUniformLocationARB(tr.combineSp, "p_bloomintensity");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get p_bloomintensity", __FUNCTION__);
}
qglUniform1fARB(loc, (GLfloat)r_BloomIntensity->value);
loc = qglGetUniformLocationARB(tr.combineSp, "p_sceneintensity");
if (loc < 0) {
Com_Error(ERR_DROP, "%s() couldn't get p_sceneintensity", __FUNCTION__);
}
qglUniform1fARB(loc, (GLfloat)r_BloomSceneIntensity->value);
width = glConfig.vidWidth;
height = glConfig.vidHeight;
qglBegin(GL_QUADS);
qglMultiTexCoord2iARB(GL_TEXTURE0_ARB, 0, 0);
qglMultiTexCoord2iARB(GL_TEXTURE1_ARB, 0, 0);
qglVertex2i(0, height);
qglMultiTexCoord2iARB(GL_TEXTURE0_ARB, width, 0);
qglMultiTexCoord2iARB(GL_TEXTURE1_ARB, tr.bloomWidth, 0);
qglVertex2i(width, height);
qglMultiTexCoord2iARB(GL_TEXTURE0_ARB, width, height);
qglMultiTexCoord2iARB(GL_TEXTURE1_ARB, tr.bloomWidth, tr.bloomHeight);
qglVertex2i(width, 0);
qglMultiTexCoord2iARB(GL_TEXTURE0_ARB, 0, height);
qglMultiTexCoord2iARB(GL_TEXTURE1_ARB, 0, tr.bloomHeight);
qglVertex2i(0, 0);
qglEnd();
qglUseProgramObjectARB(0);
GL_SelectTexture(1);
qglDisable(GL_TEXTURE_RECTANGLE_ARB);
qglDisable(GL_TEXTURE_2D);
GL_SelectTexture(0);
qglDisable(GL_TEXTURE_RECTANGLE_ARB);
qglEnable(GL_TEXTURE_2D);
}
static bool RB_GLSL_InitShaders( ) {
// load interation shaders
R_LoadGLSLShader( "interaction.vertex", &interactionShader, GL_VERTEX_SHADER_ARB );
R_LoadGLSLShader( "interaction.fragment", &interactionShader, GL_FRAGMENT_SHADER_ARB );
if ( interactionShader.fragmentShader == -1 ||
interactionShader.vertexShader == -1 ||
!R_LinkGLSLShader( &interactionShader, true ) &&
!R_ValidateGLSLProgram( &interactionShader ) )
{
if (interactionShader.fragmentShader != -1)
qglDeleteShader(interactionShader.fragmentShader);
if (interactionShader.vertexShader != -1)
qglDeleteShader(interactionShader.vertexShader);
interactionShader.fragmentShader = -1;
interactionShader.vertexShader = -1;
common->Printf( "GLSL interactionShader failed to init.\n" );
return false;
} else {
// set uniform locations
interactionShader.u_normalTexture = qglGetUniformLocationARB( interactionShader.program, "u_normalTexture" );
interactionShader.u_lightFalloffTexture = qglGetUniformLocationARB( interactionShader.program, "u_lightFalloffTexture" );
interactionShader.u_lightProjectionTexture = qglGetUniformLocationARB( interactionShader.program, "u_lightProjectionTexture" );
interactionShader.u_diffuseTexture = qglGetUniformLocationARB( interactionShader.program, "u_diffuseTexture" );
interactionShader.u_specularTexture = qglGetUniformLocationARB( interactionShader.program, "u_specularTexture" );
interactionShader.modelMatrix = qglGetUniformLocationARB( interactionShader.program, "u_modelMatrix" );
interactionShader.localLightOrigin = qglGetUniformLocationARB( interactionShader.program, "u_lightOrigin" );
interactionShader.localViewOrigin = qglGetUniformLocationARB( interactionShader.program, "u_viewOrigin" );
interactionShader.lightProjectionS = qglGetUniformLocationARB( interactionShader.program, "u_lightProjectionS" );
interactionShader.lightProjectionT = qglGetUniformLocationARB( interactionShader.program, "u_lightProjectionT" );
interactionShader.lightProjectionQ = qglGetUniformLocationARB( interactionShader.program, "u_lightProjectionQ" );
interactionShader.lightFalloff = qglGetUniformLocationARB( interactionShader.program, "u_lightFalloff" );
interactionShader.bumpMatrixS = qglGetUniformLocationARB( interactionShader.program, "u_bumpMatrixS" );
interactionShader.bumpMatrixT = qglGetUniformLocationARB( interactionShader.program, "u_bumpMatrixT" );
interactionShader.diffuseMatrixS = qglGetUniformLocationARB( interactionShader.program, "u_diffuseMatrixS" );
interactionShader.diffuseMatrixT = qglGetUniformLocationARB( interactionShader.program, "u_diffuseMatrixT" );
interactionShader.specularMatrixS = qglGetUniformLocationARB( interactionShader.program, "u_specularMatrixS" );
interactionShader.specularMatrixT = qglGetUniformLocationARB( interactionShader.program, "u_specularMatrixT" );
interactionShader.colorModulate = qglGetUniformLocationARB( interactionShader.program, "u_colorModulate" );
interactionShader.colorAdd = qglGetUniformLocationARB( interactionShader.program, "u_colorAdd" );
interactionShader.diffuseColor = qglGetUniformLocationARB( interactionShader.program, "u_diffuseColor" );
interactionShader.specularColor = qglGetUniformLocationARB( interactionShader.program, "u_specularColor" );
// set texture locations
qglUseProgramObjectARB( interactionShader.program );
qglUniform1iARB( interactionShader.u_normalTexture, 0 );
qglUniform1iARB( interactionShader.u_lightFalloffTexture, 1 );
qglUniform1iARB( interactionShader.u_lightProjectionTexture, 2 );
qglUniform1iARB( interactionShader.u_diffuseTexture, 3 );
qglUniform1iARB( interactionShader.u_specularTexture, 4 );
qglUseProgramObjectARB( 0 );
}
// load ambient interation shaders
R_LoadGLSLShader( "ambientInteraction.vertex", &ambientInteractionShader, GL_VERTEX_SHADER_ARB );
R_LoadGLSLShader( "ambientInteraction.fragment", &ambientInteractionShader, GL_FRAGMENT_SHADER_ARB );
if ( ambientInteractionShader.fragmentShader == -1 ||
ambientInteractionShader.vertexShader == -1 ||
!R_LinkGLSLShader( &ambientInteractionShader, true ) && !R_ValidateGLSLProgram( &ambientInteractionShader ) )
{
if (ambientInteractionShader.fragmentShader != -1)
qglDeleteShader(ambientInteractionShader.fragmentShader);
if (ambientInteractionShader.vertexShader != -1)
qglDeleteShader(ambientInteractionShader.vertexShader);
ambientInteractionShader.fragmentShader = -1;
ambientInteractionShader.vertexShader = -1;
common->Printf( "GLSL ambientInteractionShader failed to init.\n" );
return false;
} else {
// set uniform locations
ambientInteractionShader.u_normalTexture = qglGetUniformLocationARB( ambientInteractionShader.program, "u_normalTexture" );
ambientInteractionShader.u_lightFalloffTexture = qglGetUniformLocationARB( ambientInteractionShader.program, "u_lightFalloffTexture" );
ambientInteractionShader.u_lightProjectionTexture = qglGetUniformLocationARB( ambientInteractionShader.program, "u_lightProjectionTexture" );
ambientInteractionShader.u_diffuseTexture = qglGetUniformLocationARB( ambientInteractionShader.program, "u_diffuseTexture" );
ambientInteractionShader.modelMatrix = qglGetUniformLocationARB( ambientInteractionShader.program, "u_modelMatrix" );
ambientInteractionShader.localLightOrigin = qglGetUniformLocationARB( ambientInteractionShader.program, "u_lightOrigin" );
ambientInteractionShader.lightProjectionS = qglGetUniformLocationARB( ambientInteractionShader.program, "u_lightProjectionS" );
ambientInteractionShader.lightProjectionT = qglGetUniformLocationARB( ambientInteractionShader.program, "u_lightProjectionT" );
ambientInteractionShader.lightProjectionQ = qglGetUniformLocationARB( ambientInteractionShader.program, "u_lightProjectionQ" );
ambientInteractionShader.lightFalloff = qglGetUniformLocationARB( ambientInteractionShader.program, "u_lightFalloff" );
ambientInteractionShader.bumpMatrixS = qglGetUniformLocationARB( ambientInteractionShader.program, "u_bumpMatrixS" );
ambientInteractionShader.bumpMatrixT = qglGetUniformLocationARB( ambientInteractionShader.program, "u_bumpMatrixT" );
ambientInteractionShader.diffuseMatrixS = qglGetUniformLocationARB( ambientInteractionShader.program, "u_diffuseMatrixS" );
ambientInteractionShader.diffuseMatrixT = qglGetUniformLocationARB( ambientInteractionShader.program, "u_diffuseMatrixT" );
ambientInteractionShader.colorModulate = qglGetUniformLocationARB( ambientInteractionShader.program, "u_colorModulate" );
ambientInteractionShader.colorAdd = qglGetUniformLocationARB( ambientInteractionShader.program, "u_colorAdd" );
ambientInteractionShader.diffuseColor = qglGetUniformLocationARB( ambientInteractionShader.program, "u_diffuseColor" );
// set texture locations
qglUseProgramObjectARB( ambientInteractionShader.program );
qglUniform1iARB( ambientInteractionShader.u_normalTexture, 0 );
qglUniform1iARB( ambientInteractionShader.u_lightFalloffTexture, 1 );
qglUniform1iARB( ambientInteractionShader.u_lightProjectionTexture, 2 );
qglUniform1iARB( ambientInteractionShader.u_diffuseTexture, 3 );
qglUseProgramObjectARB( 0 );
}
// load stencil shadow extrusion shaders
R_LoadGLSLShader( "stencilshadow.vertex", &stencilShadowShader, GL_VERTEX_SHADER_ARB );
R_LoadGLSLShader( "stencilshadow.fragment", &stencilShadowShader, GL_FRAGMENT_SHADER_ARB );
if ( stencilShadowShader.fragmentShader == -1 ||
stencilShadowShader.vertexShader == -1 ||
!R_LinkGLSLShader( &stencilShadowShader, false ) && !R_ValidateGLSLProgram( &stencilShadowShader ) ) {
if (stencilShadowShader.fragmentShader != -1)
qglDeleteShader(stencilShadowShader.fragmentShader);
if (stencilShadowShader.vertexShader != -1)
qglDeleteShader(stencilShadowShader.vertexShader);
stencilShadowShader.fragmentShader = -1;
stencilShadowShader.vertexShader = -1;
common->Printf( "GLSL stencilShadowShader failed to init.\n" );
return false;
} else {
// set uniform locations
stencilShadowShader.localLightOrigin = qglGetUniformLocationARB( stencilShadowShader.program, "u_lightOrigin" );
}
return true;
}
