/*
** GL_SelectTexture
*/
void GL_SelectTexture( int unit )
{
if ( glState.currenttmu == unit )
{
return;
}
if ( unit == 0 )
{
qglActiveTextureARB( GL_TEXTURE0_ARB );
GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE0_ARB )\n" );
qglClientActiveTextureARB( GL_TEXTURE0_ARB );
GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE0_ARB )\n" );
}
else if ( unit == 1 )
{
qglActiveTextureARB( GL_TEXTURE1_ARB );
GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE1_ARB )\n" );
qglClientActiveTextureARB( GL_TEXTURE1_ARB );
GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE1_ARB )\n" );
} else {
ri.Error( ERR_DROP, "GL_SelectTexture: unit = %i", unit );
}
glState.currenttmu = unit;
}
void GL_BindNullTextures()
{
int i;
if (glRefConfig.directStateAccess)
{
for (i = 0; i < NUM_TEXTURE_BUNDLES; i++)
{
qglBindMultiTexture(GL_TEXTURE0_ARB + i, GL_TEXTURE_2D, 0);
glDsaState.textures[i] = 0;
}
}
else
{
for (i = 0; i < NUM_TEXTURE_BUNDLES; i++)
{
qglActiveTextureARB(GL_TEXTURE0_ARB + i);
qglBindTexture(GL_TEXTURE_2D, 0);
glDsaState.textures[i] = 0;
}
qglActiveTextureARB(GL_TEXTURE0_ARB);
glDsaState.texunit = GL_TEXTURE0_ARB;
}
}
/**
* @brief GL_SelectTexture
* @param[in] unit
*/
void GL_SelectTexture(int unit)
{
if (glState.currenttmu == unit)
{
return;
}
if (unit == 0)
{
qglActiveTextureARB(GL_TEXTURE0_ARB);
Ren_LogComment("glActiveTextureARB( GL_TEXTURE0_ARB )\n");
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
Ren_LogComment("glClientActiveTextureARB( GL_TEXTURE0_ARB )\n");
}
else if (unit == 1)
{
qglActiveTextureARB(GL_TEXTURE1_ARB);
Ren_LogComment("glActiveTextureARB( GL_TEXTURE1_ARB )\n");
qglClientActiveTextureARB(GL_TEXTURE1_ARB);
Ren_LogComment("glClientActiveTextureARB( GL_TEXTURE1_ARB )\n");
}
else
{
Ren_Drop("GL_SelectTexture: unit = %i", unit);
}
glState.currenttmu = unit;
}
GLvoid APIENTRY GLDSA_BindMultiTexture(GLenum texunit, GLenum target, GLuint texture)
{
if (glDsaState.texunit != texunit)
{
qglActiveTextureARB(texunit);
glDsaState.texunit = texunit;
}
qglBindTexture(target, texture);
}
/*
* RB_SelectTextureUnit
*/
void RB_SelectTextureUnit( int tmu )
{
if( tmu == rb.gl.currentTMU )
return;
rb.gl.currentTMU = tmu;
qglActiveTextureARB( tmu + GL_TEXTURE0_ARB );
qglClientActiveTextureARB( tmu + GL_TEXTURE0_ARB );
}
/*
** GL_SelectTexture
*/
void GL_SelectTexture( int unit )
{
if ( glState.currenttmu == unit )
{
return;
}
if ( unit == 0 )
{
#ifdef VCMODS_OPENGLES
qglActiveTextureARB( GL_TEXTURE0);
#else
qglActiveTextureARB( GL_TEXTURE0_ARB );
#endif
GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE0_ARB )\n" );
#ifdef VCMODS_OPENGLES
qglClientActiveTextureARB( GL_TEXTURE0 );
#else
qglClientActiveTextureARB( GL_TEXTURE0_ARB );
#endif
GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE0_ARB )\n" );
}
else if ( unit == 1 )
{
#ifdef VCMODS_OPENGLES
qglActiveTextureARB( GL_TEXTURE1);
#else
qglActiveTextureARB( GL_TEXTURE1_ARB );
#endif
GLimp_LogComment( "glActiveTextureARB( GL_TEXTURE1_ARB )\n" );
#ifdef VCMODS_OPENGLES
qglClientActiveTextureARB( GL_TEXTURE1);
#else
qglClientActiveTextureARB( GL_TEXTURE1_ARB );
#endif
GLimp_LogComment( "glClientActiveTextureARB( GL_TEXTURE1_ARB )\n" );
} else {
ri.Error( ERR_DROP, "GL_SelectTexture: unit = %i", unit );
}
glState.currenttmu = unit;
}
/*
* RB_SelectTextureUnit
*/
static void RB_SelectTextureUnit( int tmu )
{
if( tmu == rb.gl.currentTMU )
return;
rb.gl.currentTMU = tmu;
qglActiveTextureARB( tmu + GL_TEXTURE0_ARB );
#ifndef GL_ES_VERSION_2_0
qglClientActiveTextureARB( tmu + GL_TEXTURE0_ARB );
#endif
}
/*
** GL_SelectTexture
*/
void
GL_SelectTexture(int unit)
{
if(glState.currenttmu == unit){
return;
}
if(!(unit >= 0 && unit <= 31))
ri.Error(ERR_DROP, "GL_SelectTexture: unit = %i", unit);
qglActiveTextureARB(GL_TEXTURE0_ARB + unit);
glState.currenttmu = unit;
}
/*
====================
GL_SelectTexture
====================
*/
void GL_SelectTexture( int unit ) {
if ( backEnd.glState.currenttmu == unit ) {
return;
}
if ( unit < 0 || (unit >= glConfig.maxTextureUnits && unit >= glConfig.maxTextureImageUnits) ) {
common->Warning( "GL_SelectTexture: unit = %i", unit );
return;
}
qglActiveTextureARB( GL_TEXTURE0_ARB + unit );
qglClientActiveTextureARB( GL_TEXTURE0_ARB + unit );
RB_LogComment( "glActiveTextureARB( %i );\nglClientActiveTextureARB( %i );\n", unit, unit );
backEnd.glState.currenttmu = unit;
}
void GL_SelectTexture( GLenum texture )
{
int tmu;
if ( !qglSelectTextureSGIS && !qglActiveTextureARB )
return;
if ( texture == GL_TEXTURE0 )
{
tmu = 0;
}
//ep::multitexturing
else if ( texture == GL_TEXTURE2 )
{
tmu = 2;
}
else if ( texture == GL_TEXTURE3 )
{
tmu = 3;
}
//ep::multitexturing
else
{
tmu = 1;
}
if ( tmu == gl_state.currenttmu )
{
return;
}
gl_state.currenttmu = tmu;
if ( qglSelectTextureSGIS )
{
qglSelectTextureSGIS( texture );
}
else if ( qglActiveTextureARB )
{
qglActiveTextureARB( texture );
qglClientActiveTextureARB( texture );
}
}
void R_ScreenGamma(void)
{
if (gammaProgram.program)
{
glUseProgramObjectARB(gammaProgram.program);
qglActiveTextureARB(GL_TEXTURE0_ARB);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
GL_Bind(screenImage);
// We will copy the current buffer into the screenImage
qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 0, 0, glConfig.vidWidth, glConfig.vidHeight, 0);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glUniform1f(gammaProgram.gammaUniform, r_gamma->value);
// Draw a simple quad, We could have done this in the GLSL code directly but that is version 130 upwards
// and we want to be sure that R1 runs even with a toaster.
glBegin(GL_QUADS);
{
glTexCoord2f(0.0, 0.0);
glVertex3f(-1.0f, -1.0f, 0.0f);
glTexCoord2f(1.0, 0.0);
glVertex3f(1.0f, -1.0f, 0.0f);
glTexCoord2f(1.0, 1.0);
glVertex3f(1.0f, 1.0f, 0.0f);
glTexCoord2f(0.0, 1.0);
glVertex3f(-1.0f, 1.0f, 0.0f);
}
glEnd();
glUseProgramObjectARB(0);
}
}
/*
====================
GL_SelectTextureNoClient
====================
*/
static void GL_SelectTextureNoClient( int unit ) {
backEnd.glState.currenttmu = unit;
qglActiveTextureARB( GL_TEXTURE0_ARB + unit );
RB_LogComment( "glActiveTextureARB( %i )\n", unit );
}
static inline void RB_BlurGlowTexture()
{
qglDisable (GL_CLIP_PLANE0);
GL_Cull( CT_TWO_SIDED );
// Go into orthographic 2d mode.
qglMatrixMode(GL_PROJECTION);
qglPushMatrix();
qglLoadIdentity();
qglOrtho(0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight, 0, -1, 1);
qglMatrixMode(GL_MODELVIEW);
qglPushMatrix();
qglLoadIdentity();
GL_State(GLS_DEPTHTEST_DISABLE);
/////////////////////////////////////////////////////////
// Setup vertex and pixel programs.
/////////////////////////////////////////////////////////
// NOTE: The 0.25 is because we're blending 4 textures (so = 1.0) and we want a relatively normalized pixel
// intensity distribution, but this won't happen anyways if intensity is higher than 1.0.
float fBlurDistribution = r_DynamicGlowIntensity->value * 0.25f;
float fBlurWeight[4] = { fBlurDistribution, fBlurDistribution, fBlurDistribution, 1.0f };
// Enable and set the Vertex Program.
qglEnable( GL_VERTEX_PROGRAM_ARB );
qglBindProgramARB( GL_VERTEX_PROGRAM_ARB, tr.glowVShader );
// Apply Pixel Shaders.
if ( qglCombinerParameterfvNV )
{
BeginPixelShader( GL_REGISTER_COMBINERS_NV, tr.glowPShader );
// Pass the blur weight to the regcom.
qglCombinerParameterfvNV( GL_CONSTANT_COLOR0_NV, (float*)&fBlurWeight );
}
else if ( qglProgramEnvParameter4fARB )
{
BeginPixelShader( GL_FRAGMENT_PROGRAM_ARB, tr.glowPShader );
// Pass the blur weight to the Fragment Program.
qglProgramEnvParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 0, fBlurWeight[0], fBlurWeight[1], fBlurWeight[2], fBlurWeight[3] );
}
/////////////////////////////////////////////////////////
// Set the blur texture to the 4 texture stages.
/////////////////////////////////////////////////////////
// How much to offset each texel by.
float fTexelWidthOffset = 0.1f, fTexelHeightOffset = 0.1f;
GLuint uiTex = tr.screenGlow;
qglActiveTextureARB( GL_TEXTURE3_ARB );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB( GL_TEXTURE2_ARB );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB( GL_TEXTURE1_ARB );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB(GL_TEXTURE0_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
/////////////////////////////////////////////////////////
// Draw the blur passes (each pass blurs it more, increasing the blur radius ).
/////////////////////////////////////////////////////////
//int iTexWidth = backEnd.viewParms.viewportWidth, iTexHeight = backEnd.viewParms.viewportHeight;
int iTexWidth = glConfig.vidWidth, iTexHeight = glConfig.vidHeight;
for ( int iNumBlurPasses = 0; iNumBlurPasses < r_DynamicGlowPasses->integer; iNumBlurPasses++ )
{
// Load the Texel Offsets into the Vertex Program.
qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 0, -fTexelWidthOffset, -fTexelWidthOffset, 0.0f, 0.0f );
qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 1, -fTexelWidthOffset, fTexelWidthOffset, 0.0f, 0.0f );
qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 2, fTexelWidthOffset, -fTexelWidthOffset, 0.0f, 0.0f );
qglProgramEnvParameter4fARB( GL_VERTEX_PROGRAM_ARB, 3, fTexelWidthOffset, fTexelWidthOffset, 0.0f, 0.0f );
// After first pass put the tex coords to the viewport size.
if ( iNumBlurPasses == 1 )
{
if ( !g_bTextureRectangleHack )
{
iTexWidth = backEnd.viewParms.viewportWidth;
iTexHeight = backEnd.viewParms.viewportHeight;
}
uiTex = tr.blurImage;
qglActiveTextureARB( GL_TEXTURE3_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB( GL_TEXTURE2_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB( GL_TEXTURE1_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglActiveTextureARB(GL_TEXTURE0_ARB );
qglDisable( GL_TEXTURE_2D );
qglEnable( GL_TEXTURE_RECTANGLE_EXT );
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
// Copy the current image over.
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, uiTex );
qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
}
// Draw the fullscreen quad.
qglBegin( GL_QUADS );
qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, iTexHeight );
qglVertex2f( 0, 0 );
qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, 0, 0 );
qglVertex2f( 0, backEnd.viewParms.viewportHeight );
qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, iTexWidth, 0 );
qglVertex2f( backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
qglMultiTexCoord2fARB( GL_TEXTURE0_ARB, iTexWidth, iTexHeight );
qglVertex2f( backEnd.viewParms.viewportWidth, 0 );
qglEnd();
qglBindTexture( GL_TEXTURE_RECTANGLE_EXT, tr.blurImage );
qglCopyTexSubImage2D( GL_TEXTURE_RECTANGLE_EXT, 0, 0, 0, 0, 0, backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
// Increase the texel offsets.
// NOTE: This is possibly the most important input to the effect. Even by using an exponential function I've been able to
// make it look better (at a much higher cost of course). This is cheap though and still looks pretty great. In the future
// I might want to use an actual gaussian equation to correctly calculate the pixel coefficients and attenuates, texel
// offsets, gaussian amplitude and radius...
fTexelWidthOffset += r_DynamicGlowDelta->value;
fTexelHeightOffset += r_DynamicGlowDelta->value;
}
// Disable multi-texturing.
qglActiveTextureARB( GL_TEXTURE3_ARB );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglActiveTextureARB( GL_TEXTURE2_ARB );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglActiveTextureARB( GL_TEXTURE1_ARB );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglActiveTextureARB(GL_TEXTURE0_ARB );
qglDisable( GL_TEXTURE_RECTANGLE_EXT );
qglEnable( GL_TEXTURE_2D );
qglDisable( GL_VERTEX_PROGRAM_ARB );
EndPixelShader();
qglMatrixMode(GL_PROJECTION);
qglPopMatrix();
qglMatrixMode(GL_MODELVIEW);
qglPopMatrix();
qglDisable( GL_BLEND );
glState.currenttmu = 0; //this matches the last one we activated
}
/*********
SP_DrawTexture
*********/
void SP_DrawTexture(void* pixels, float width, float height, float vShift)
{
if (!pixels)
{
// Ug. We were not even able to load the error message texture.
return;
}
// Create a texture from the buffered file
GLuint texid;
qglGenTextures(1, &texid);
qglBindTexture(GL_TEXTURE_2D, texid);
qglTexImage2D(GL_TEXTURE_2D, 0, GL_DDS1_EXT, width, height, 0, GL_DDS1_EXT, GL_UNSIGNED_BYTE, pixels);
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
// Reset every GL state we've got. Who knows what state
// the renderer could be in when this function gets called.
qglColor3f(1.f, 1.f, 1.f);
qglViewport(0, 0, 640, 480);
GLboolean alpha = qglIsEnabled(GL_ALPHA_TEST);
qglDisable(GL_ALPHA_TEST);
GLboolean blend = qglIsEnabled(GL_BLEND);
qglDisable(GL_BLEND);
GLboolean cull = qglIsEnabled(GL_CULL_FACE);
qglDisable(GL_CULL_FACE);
GLboolean depth = qglIsEnabled(GL_DEPTH_TEST);
qglDisable(GL_DEPTH_TEST);
GLboolean fog = qglIsEnabled(GL_FOG);
qglDisable(GL_FOG);
GLboolean lighting = qglIsEnabled(GL_LIGHTING);
qglDisable(GL_LIGHTING);
GLboolean offset = qglIsEnabled(GL_POLYGON_OFFSET_FILL);
qglDisable(GL_POLYGON_OFFSET_FILL);
GLboolean scissor = qglIsEnabled(GL_SCISSOR_TEST);
qglDisable(GL_SCISSOR_TEST);
GLboolean stencil = qglIsEnabled(GL_STENCIL_TEST);
qglDisable(GL_STENCIL_TEST);
GLboolean texture = qglIsEnabled(GL_TEXTURE_2D);
qglEnable(GL_TEXTURE_2D);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglOrtho(0, 640, 0, 480, 0, 1);
qglMatrixMode(GL_TEXTURE0);
qglLoadIdentity();
qglMatrixMode(GL_TEXTURE1);
qglLoadIdentity();
qglActiveTextureARB(GL_TEXTURE0_ARB);
qglClientActiveTextureARB(GL_TEXTURE0_ARB);
memset(&tess, 0, sizeof(tess));
// Draw the error message
qglBeginFrame();
if (!SP_LicenseDone)
{
// clear the screen if we haven't done the
// license yet...
qglClearColor(0, 0, 0, 1);
qglClear(GL_COLOR_BUFFER_BIT);
}
float x1 = 320 - width / 2;
float x2 = 320 + width / 2;
float y1 = 240 - height / 2;
float y2 = 240 + height / 2;
y1 += vShift;
y2 += vShift;
qglBeginEXT (GL_TRIANGLE_STRIP, 4, 0, 0, 4, 0);
qglTexCoord2f( 0, 0 );
qglVertex2f(x1, y1);
qglTexCoord2f( 1 , 0 );
qglVertex2f(x2, y1);
qglTexCoord2f( 0, 1 );
qglVertex2f(x1, y2);
qglTexCoord2f( 1, 1 );
qglVertex2f(x2, y2);
qglEnd();
qglEndFrame();
qglFlush();
// Restore (most) of the render states we reset
if (alpha) qglEnable(GL_ALPHA_TEST);
else qglDisable(GL_ALPHA_TEST);
if (blend) qglEnable(GL_BLEND);
else qglDisable(GL_BLEND);
if (cull) qglEnable(GL_CULL_FACE);
else qglDisable(GL_CULL_FACE);
if (depth) qglEnable(GL_DEPTH_TEST);
else qglDisable(GL_DEPTH_TEST);
if (fog) qglEnable(GL_FOG);
else qglDisable(GL_FOG);
if (lighting) qglEnable(GL_LIGHTING);
else qglDisable(GL_LIGHTING);
if (offset) qglEnable(GL_POLYGON_OFFSET_FILL);
else qglDisable(GL_POLYGON_OFFSET_FILL);
if (scissor) qglEnable(GL_SCISSOR_TEST);
else qglDisable(GL_SCISSOR_TEST);
if (stencil) qglEnable(GL_STENCIL_TEST);
else qglDisable(GL_STENCIL_TEST);
if (texture) qglEnable(GL_TEXTURE_2D);
else qglDisable(GL_TEXTURE_2D);
// Kill the texture
qglDeleteTextures(1, &texid);
}