/*
======================
RB_BindStageTexture
======================
*/
void RB_BindStageTexture( const float *shaderRegisters, const textureStage_t *texture, const drawSurf_t *surf ) {
// image
RB_BindVariableStageImage( texture, shaderRegisters );
// texgens
if ( texture->texgen == TG_DIFFUSE_CUBE ) {
qglTexCoordPointer( 3, GL_FLOAT, sizeof( idDrawVert ), ((idDrawVert *)vertexCache.Position( surf->geo->ambientCache ))->normal.ToFloatPtr() );
}
if ( texture->texgen == TG_SKYBOX_CUBE || texture->texgen == TG_WOBBLESKY_CUBE ) {
qglTexCoordPointer( 3, GL_FLOAT, 0, vertexCache.Position( surf->dynamicTexCoords ) );
}
if ( texture->texgen == TG_REFLECT_CUBE ) {
qglEnable( GL_TEXTURE_GEN_S );
qglEnable( GL_TEXTURE_GEN_T );
qglEnable( GL_TEXTURE_GEN_R );
qglTexGenf( GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_EXT );
qglTexGenf( GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_EXT );
qglTexGenf( GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_EXT );
qglEnableClientState( GL_NORMAL_ARRAY );
qglNormalPointer( GL_FLOAT, sizeof( idDrawVert ), ((idDrawVert *)vertexCache.Position( surf->geo->ambientCache ))->normal.ToFloatPtr() );
qglMatrixMode( GL_TEXTURE );
float mat[16];
R_TransposeGLMatrix( backEnd.viewDef->worldSpace.modelViewMatrix, mat );
qglLoadMatrixf( mat );
qglMatrixMode( GL_MODELVIEW );
}
// matrix
if ( texture->hasMatrix ) {
RB_LoadShaderTextureMatrix( shaderRegisters, texture );
}
}
/*
===============
RB_LeaveDepthHack
===============
*/
void RB_LeaveDepthHack() {
qglDepthRange( 0, 1 );
qglMatrixMode(GL_PROJECTION);
qglLoadMatrixf( backEnd.viewDef->projectionMatrix );
qglMatrixMode(GL_MODELVIEW);
}
/*
======================
RB_FinishStageTexture
======================
*/
void RB_FinishStageTexture( const textureStage_t *texture, const drawSurf_t *surf ) {
if ( texture->texgen == TG_DIFFUSE_CUBE || texture->texgen == TG_SKYBOX_CUBE
|| texture->texgen == TG_WOBBLESKY_CUBE ) {
qglTexCoordPointer( 2, GL_FLOAT, sizeof( idDrawVert ),
(void *)&(((idDrawVert *)vertexCache.Position( surf->geo->ambientCache ))->st) );
}
if ( texture->texgen == TG_REFLECT_CUBE ) {
qglDisable( GL_TEXTURE_GEN_S );
qglDisable( GL_TEXTURE_GEN_T );
qglDisable( GL_TEXTURE_GEN_R );
qglTexGenf( GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
qglTexGenf( GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
qglTexGenf( GL_R, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR );
qglDisableClientState( GL_NORMAL_ARRAY );
qglMatrixMode( GL_TEXTURE );
qglLoadIdentity();
qglMatrixMode( GL_MODELVIEW );
}
if ( texture->hasMatrix ) {
qglMatrixMode( GL_TEXTURE );
qglLoadIdentity();
qglMatrixMode( GL_MODELVIEW );
}
}
/*
================
RB_SetGL2D
================
*/
void RB_SetGL2D(void)
{
backEnd.projection2D = qtrue;
// set 2D virtual screen size
qglViewport(0, 0, glConfig.vidWidth, glConfig.vidHeight);
qglScissor(0, 0, glConfig.vidWidth, glConfig.vidHeight);
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglOrtho(0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
GL_State(GLS_DEPTHTEST_DISABLE |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA);
qglDisable(GL_FOG); //----(SA) added
qglDisable(GL_CULL_FACE);
qglDisable(GL_CLIP_PLANE0);
// set time for 2D shaders
backEnd.refdef.time = ri.Milliseconds();
backEnd.refdef.floatTime = backEnd.refdef.time * 0.001f;
}
/*
================
RB_SetGL2D
================
*/
void RB_SetGL2D (void) {
if ( tess.numIndexes | tess.numVertexes )
Com_Printf(" Going 2d with verts?" );
backEnd.projection2D = qtrue;
backEnd.currentModel = 0;
// set 2D virtual screen size
qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity ();
qglOrtho (0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity ();
GL_State( GLS_DEPTHTEST_DISABLE |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
GL_Cull( CT_TWO_SIDED );
qglDisable( GL_CLIP_PLANE0 );
// set time for 2D shaders
// tess.shaderTime = ri.Milliseconds();
}
/*
======================
RB_LoadShaderTextureMatrix
======================
*/
void RB_LoadShaderTextureMatrix( const float *shaderRegisters, const textureStage_t *texture ) {
float matrix[16];
RB_GetShaderTextureMatrix( shaderRegisters, texture, matrix );
qglMatrixMode( GL_TEXTURE );
qglLoadMatrixf( matrix );
qglMatrixMode( GL_MODELVIEW );
}
/*
==================
RB_STD_LightScale
Perform extra blending passes to multiply the entire buffer by
a floating point value
==================
*/
void RB_STD_LightScale( void ) {
float v, f;
if ( backEnd.overBright == 1.0f ) {
return;
}
if ( r_skipLightScale.GetBool() ) {
return;
}
// the scissor may be smaller than the viewport for subviews
if ( r_useScissor.GetBool() ) {
qglScissor( backEnd.viewDef->viewport.x1 + backEnd.viewDef->scissor.x1,
backEnd.viewDef->viewport.y1 + backEnd.viewDef->scissor.y1,
backEnd.viewDef->scissor.x2 - backEnd.viewDef->scissor.x1 + 1,
backEnd.viewDef->scissor.y2 - backEnd.viewDef->scissor.y1 + 1 );
backEnd.currentScissor = backEnd.viewDef->scissor;
}
// full screen blends
qglLoadIdentity();
qglMatrixMode( GL_PROJECTION );
qglPushMatrix();
qglLoadIdentity();
qglOrtho( 0, 1, 0, 1, -1, 1 );
GL_State( GLS_SRCBLEND_DST_COLOR | GLS_DSTBLEND_SRC_COLOR );
GL_Cull( CT_TWO_SIDED ); // so mirror views also get it
globalImages->BindNull();
qglDisable( GL_DEPTH_TEST );
qglDisable( GL_STENCIL_TEST );
v = 1;
while ( idMath::Fabs( v - backEnd.overBright ) > 0.01 ) { // a little extra slop
f = backEnd.overBright / v;
f /= 2;
if ( f > 1 ) {
f = 1;
}
qglColor3f( f, f, f );
v = v * f * 2;
qglBegin( GL_QUADS );
qglVertex2f( 0,0 );
qglVertex2f( 0,1 );
qglVertex2f( 1,1 );
qglVertex2f( 1,0 );
qglEnd();
}
qglPopMatrix();
qglEnable( GL_DEPTH_TEST );
qglMatrixMode( GL_MODELVIEW );
GL_Cull( CT_FRONT_SIDED );
}
/*
=================
R_BloomScreen
=================
*/
void R_BloomScreen( void )
{
if( !r_bloom->integer )
return;
if(r_bloom_sky_only->integer)
return;
if ( backEnd.doneBloom )
return;
if ( !backEnd.doneSurfaces )
return;
backEnd.doneBloom = qtrue;
if( !bloom.started ) {
R_Bloom_InitTextures();
if( !bloom.started )
return;
}
if ( !backEnd.projection2D )
RB_SetGL2D();
#if 0
// set up full screen workspace
GL_TexEnv( GL_MODULATE );
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity ();
qglOrtho( 0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1 );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity ();
GL_Cull( CT_TWO_SIDED );
#endif
qglColor4f( 1, 1, 1, 1 );
//Backup the old screen in a texture
R_Bloom_BackupScreen();
// create the bloom texture using one of a few methods
if(r_bloom_cascade->integer)
R_Bloom_Cascaded();
else
R_Bloom_WarsowEffect ();
// R_Bloom_CreateEffect();
// restore the screen-backup to the screen
R_Bloom_RestoreScreen();
// Do the final pass using the bloom texture for the final effect
R_Bloom_DrawEffect ();
// LEILEI - Lens Bloom Hack
// The concept of this is to inverse the coordinates on both X and Y,
// then scale outward using the offset value applied, as well as the modulated color
// applied to give a rainbow streak effect. Most effective with high bloom darkness
// values.
if(r_bloom_reflection->integer)
R_Bloom_LensEffect ();
}
void SetViewportAndScissor( void ) {
qglMatrixMode(GL_PROJECTION);
qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
qglMatrixMode(GL_MODELVIEW);
// set the window clipping
qglViewport( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
qglScissor( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
}
/*
===============
RB_EnterModelDepthHack
===============
*/
void RB_EnterModelDepthHack( float depth ) {
float matrix[16];
qglDepthRange( 0.0f, 1.0f );
memcpy( matrix, backEnd.viewDef->projectionMatrix, sizeof( matrix ) );
matrix[14] -= depth;
qglMatrixMode( GL_PROJECTION );
qglLoadMatrixf( matrix );
qglMatrixMode( GL_MODELVIEW );
}
/*
===============
RB_EnterWeaponDepthHack
===============
*/
void RB_EnterWeaponDepthHack() {
float matrix[16];
qglDepthRange( 0.0f, 0.5f );
memcpy( matrix, backEnd.viewDef->projectionMatrix, sizeof( matrix ) );
matrix[14] *= 0.25f;
qglMatrixMode( GL_PROJECTION );
qglLoadMatrixf( matrix );
qglMatrixMode( GL_MODELVIEW );
}
static void SetViewportAndScissor( void ) {
qglMatrixMode(GL_PROJECTION);
qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
qglMatrixMode(GL_MODELVIEW);
// set the window clipping
qglViewport( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
qglScissor( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
Matrix4Copy(backEnd.viewParms.projectionMatrix, glState.currentProjectionMatrix);
Matrix4Multiply(glState.currentProjectionMatrix, glState.currentModelViewMatrix, glState.currentModelViewProjectionMatrix);
}
void idGLDrawableView::draw(int x, int y, int w, int h)
{
int i;
renderView_t refdef;
const idMaterial *mat = material;
if (mat)
{
qglViewport(x, y, w, h);
qglScissor(x, y, w, h);
qglMatrixMode(GL_PROJECTION);
qglClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
qglClear(GL_COLOR_BUFFER_BIT);
UpdateLights();
// render it
renderSystem->BeginFrame(w, h);
memset( &refdef, 0, sizeof( refdef ) );
UpdateCamera( &refdef );
// Copy global shaderparms to view
for( i = 0; i < MAX_GLOBAL_SHADER_PARMS; i++ )
{
refdef.shaderParms[ i ] = globalParms[ i ];
}
refdef.width = SCREEN_WIDTH;
refdef.height = SCREEN_HEIGHT;
refdef.fov_x = 90;
refdef.fov_y = 2 * atan((float)h / w) * idMath::M_RAD2DEG;
refdef.time = eventLoop->Milliseconds();
world->RenderScene( &refdef );
if ( showLights )
{
drawLights( &refdef );
}
renderSystem->EndFrame( NULL, NULL );
world->DebugClearLines( refdef.time );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
}
}
void R_ScrollSkyMatrix (float speed)
{
float scroll = cl.time * speed;
glmatrix texmatrix;
scroll -= (int) scroll & ~127;
scroll /= 128.0f;
qglMatrixMode (GL_TEXTURE);
GL_IdentityMatrix (&texmatrix);
GL_TranslateMatrix (&texmatrix, scroll, scroll, 0);
qglLoadMatrixf (texmatrix.m16);
qglMatrixMode (GL_MODELVIEW);
}
void idGLWidget::OnPaint()
{
if (!initialized)
{
CDC *dc = GetDC();
QEW_SetupPixelFormat(dc->m_hDC);
ReleaseDC(dc);
initialized = true;
}
CPaintDC dc(this); // device context for painting
CRect rect;
GetClientRect(rect);
if (!qwglMakeCurrent(dc.m_hDC, win32.hGLRC))
{
}
qglViewport(0, 0, rect.Width(), rect.Height());
qglScissor(0, 0, rect.Width(), rect.Height());
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglClearColor (0.4f, 0.4f, 0.4f, 0.7f);
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
qglDisable(GL_DEPTH_TEST);
qglDisable(GL_BLEND);
qglOrtho(0, rect.Width(), 0, rect.Height(), -256, 256);
if (drawable)
{
drawable->draw(1, 1, rect.Width()-1, rect.Height()-1);
}
else
{
qglViewport(0, 0, rect.Width(), rect.Height());
qglScissor(0, 0, rect.Width(), rect.Height());
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglClearColor (0.4f, 0.4f, 0.4f, 0.7f);
qglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
qwglSwapBuffers(dc);
qglFlush();
qwglMakeCurrent(win32.hDC, win32.hGLRC);
}
void CMistyFog2::Render(CWorldEffectsSystem *system)
{
if (mFadeAlpha <= 0.0)
{
return;
}
qglMatrixMode(GL_PROJECTION);
qglPushMatrix();
qglLoadIdentity ();
MYgluPerspective (80.0, 1.0, 4, 2048.0);
qglMatrixMode(GL_MODELVIEW);
qglPushMatrix();
qglLoadIdentity ();
qglRotatef (-90, 1, 0, 0); // put Z going up
qglRotatef (90, 0, 0, 1); // put Z going up
qglRotatef (0, 1, 0, 0);
qglRotatef (-90, 0, 1, 0);
qglRotatef (-90, 0, 0, 1);
qglDisable(GL_TEXTURE_2D);
GL_State(GLS_SRCBLEND_SRC_ALPHA|GLS_DSTBLEND_ONE);
qglShadeModel (GL_SMOOTH);
qglColorPointer(4, GL_FLOAT, 0, mColors);
qglEnableClientState(GL_COLOR_ARRAY);
qglVertexPointer( 3, GL_FLOAT, 0, mVerts );
qglEnableClientState(GL_VERTEX_ARRAY);
if (qglLockArraysEXT)
{
qglLockArraysEXT(0, MISTYFOG_HEIGHT*MISTYFOG_WIDTH);
}
qglDrawElements(GL_QUADS, (MISTYFOG_HEIGHT-1)*(MISTYFOG_WIDTH-1)*4, GL_UNSIGNED_INT, mIndexes);
if ( qglUnlockArraysEXT )
{
qglUnlockArraysEXT();
}
qglDisableClientState(GL_COLOR_ARRAY);
// qglDisableClientState(GL_VERTEX_ARRAY); backend doesn't ever re=enable this properly
qglPopMatrix();
qglMatrixMode(GL_PROJECTION);
qglPopMatrix();
qglMatrixMode(GL_MODELVIEW); // bug somewhere in the backend which requires this
}
/*
===============
RB_EnterWeaponDepthHack
===============
*/
static void RB_EnterWeaponDepthHack() {
float matrix[16];
memcpy( matrix, backEnd.viewDef->projectionMatrix, sizeof( matrix ) );
const float modelDepthHack = 0.25f;
matrix[2] *= modelDepthHack;
matrix[6] *= modelDepthHack;
matrix[10] *= modelDepthHack;
matrix[14] *= modelDepthHack;
qglMatrixMode( GL_PROJECTION );
qglLoadMatrixf( matrix );
qglMatrixMode( GL_MODELVIEW );
}
/*
===================
RB_ShowIntensity
Debugging tool to see how much dynamic range a scene is using.
The greatest of the rgb values at each pixel will be used, with
the resulting color shading from red at 0 to green at 128 to blue at 255
===================
*/
static void RB_ShowIntensity() {
byte *colorReadback;
int i, j, c;
if ( !r_showIntensity.GetBool() ) {
return;
}
colorReadback = (byte *)R_StaticAlloc( renderSystem->GetWidth() * renderSystem->GetHeight() * 4, TAG_RENDER_TOOLS );
qglReadPixels( 0, 0, renderSystem->GetWidth(), renderSystem->GetHeight(), GL_RGBA, GL_UNSIGNED_BYTE, colorReadback );
c = renderSystem->GetWidth() * renderSystem->GetHeight() * 4;
for ( i = 0; i < c; i+=4 ) {
j = colorReadback[i];
if ( colorReadback[i+1] > j ) {
j = colorReadback[i+1];
}
if ( colorReadback[i+2] > j ) {
j = colorReadback[i+2];
}
if ( j < 128 ) {
colorReadback[i+0] = 2*(128-j);
colorReadback[i+1] = 2*j;
colorReadback[i+2] = 0;
} else {
colorReadback[i+0] = 0;
colorReadback[i+1] = 2*(255-j);
colorReadback[i+2] = 2*(j-128);
}
}
// draw it back to the screen
qglLoadIdentity();
qglMatrixMode( GL_PROJECTION );
GL_State( GLS_DEPTHFUNC_ALWAYS );
qglPushMatrix();
qglLoadIdentity();
qglOrtho( 0, 1, 0, 1, -1, 1 );
qglRasterPos2f( 0, 0 );
qglPopMatrix();
GL_Color( 1, 1, 1 );
globalImages->BindNull();
qglMatrixMode( GL_MODELVIEW );
qglDrawPixels( renderSystem->GetWidth(), renderSystem->GetHeight(), GL_RGBA , GL_UNSIGNED_BYTE, colorReadback );
R_StaticFree( colorReadback );
}
void RB_RenderWorldEffects(void)
{
float elapseTime = backEnd.refdef.frametime / 1000.0;
if (tr.refdef.rdflags & RDF_NOWORLDMODEL || !tr.world || CL_IsRunningInGameCinematic())
{ // no world rendering or no world
return;
}
SetViewportAndScissor();
qglMatrixMode(GL_MODELVIEW);
// qglPushMatrix();
qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
originContents = ri.CM_PointContents(backEnd.viewParms.or.origin, 0);
if (rainSystem)
{
rainSystem->Update(elapseTime);
rainSystem->Render();
}
if (snowSystem)
{
snowSystem->Update(elapseTime);
snowSystem->Render();
}
// qglMatrixMode(GL_MODELVIEW);
// qglPopMatrix();
}
/*
==================
GL_LoadIdentity
==================
*/
void GL_LoadIdentity (uint mode){
switch (mode){
case GL_PROJECTION:
if (glState.projectionMatrixIdentity)
return;
glState.projectionMatrixIdentity = true;
break;
case GL_MODELVIEW:
if (glState.modelviewMatrixIdentity)
return;
glState.modelviewMatrixIdentity = true;
break;
case GL_TEXTURE:
if (glState.textureMatrixIdentity[glState.texUnit])
return;
glState.textureMatrixIdentity[glState.texUnit] = true;
break;
}
qglMatrixMode(mode);
qglLoadIdentity();
}
static void SetViewportAndScissor( void ) {
qglMatrixMode( GL_PROJECTION );
qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
qglMatrixMode( GL_MODELVIEW );
// set the window clipping
qglViewport( backEnd.viewParms.viewportX,
backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth,
backEnd.viewParms.viewportHeight );
// TODO: insert handling for widescreen? (when looking through camera)
qglScissor( backEnd.viewParms.viewportX,
backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth,
backEnd.viewParms.viewportHeight );
}
/*
===============
RB_EnterModelDepthHack
===============
*/
static void RB_EnterModelDepthHack( float depth ) {
float matrix[16];
memcpy( matrix, backEnd.viewDef->projectionMatrix, sizeof( matrix ) );
matrix[14] -= depth;
qglMatrixMode( GL_PROJECTION );
qglLoadMatrixf( matrix );
qglMatr
/*
=============
RB_SetGL2D
This is not used by the normal game paths, just by some tools
=============
*/
void RB_SetGL2D( void ) {
// set 2D virtual screen size
qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
if ( r_useScissor.GetBool() ) {
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
}
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity();
qglOrtho( 0, 640, 480, 0, 0, 1 ); // always assume 640x480 virtual coordinates
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity();
GL_State( GLS_DEPTHFUNC_ALWAYS |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
GL_Cull( CT_TWO_SIDED );
qglDisable( GL_DEPTH_TEST );
qglDisable( GL_STENCIL_TEST );
}
static void SetViewportAndScissor( void ) {
qglMatrixMode(GL_PROJECTION);
qglLoadMatrixf( backEnd.viewParms.projectionMatrix );
qglMatrixMode(GL_MODELVIEW);
// set the window clipping
qglViewport( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
if(r_subviewScissor->integer)
{
qglScissor( backEnd.viewParms.scissorMinX, backEnd.viewParms.scissorMinY,
backEnd.viewParms.scissorMaxX - backEnd.viewParms.scissorMinX,
backEnd.viewParms.scissorMaxY - backEnd.viewParms.scissorMinY );
}
else
{
qglScissor( backEnd.viewParms.viewportX, backEnd.viewParms.viewportY,
backEnd.viewParms.viewportWidth, backEnd.viewParms.viewportHeight );
}
}
void Sky_RenderLayers (void)
{
glmatrix skymatrix;
// standard layers
GL_BindTexture (GL_TEXTURE0_ARB, solidskytexture);
R_ScrollSkyMatrix (8);
GL_TexEnv (GL_TEXTURE1_ARB, GL_TEXTURE_2D, GL_DECAL);
GL_BindTexture (GL_TEXTURE1_ARB, alphaskytexture);
R_ScrollSkyMatrix (16);
GL_IdentityMatrix (&skymatrix);
GL_TranslateMatrix (&skymatrix, -r_origin[0], -r_origin[1], -r_origin[2]);
GL_ScaleMatrix (&skymatrix, 65536, 65536, 65536);
qglMultMatrixf (skymatrix.m16);
GL_SetStreamSource (GLSTREAM_POSITION, 3, GL_FLOAT, sizeof (dpskyvert_t), r_dpskyverts->xyz);
GL_SetStreamSource (GLSTREAM_COLOR, 0, GL_NONE, 0, NULL);
GL_SetStreamSource (GLSTREAM_TEXCOORD0, 2, GL_FLOAT, sizeof (dpskyvert_t), r_dpskyverts->st);
GL_SetStreamSource (GLSTREAM_TEXCOORD1, 2, GL_FLOAT, sizeof (dpskyvert_t), r_dpskyverts->st);
GL_SetStreamSource (GLSTREAM_TEXCOORD2, 0, GL_NONE, 0, NULL);
GL_SetIndices (r_dpskyindexes);
GL_DrawIndexedPrimitive (GL_TRIANGLES, SKYSPHERE_NUMINDEXES, SKYSPHERE_NUMVERTS);
GL_TexEnv (GL_TEXTURE1_ARB, GL_TEXTURE_2D, GL_NONE);
qglMatrixMode (GL_TEXTURE);
qglLoadIdentity ();
qglMatrixMode (GL_MODELVIEW);
GL_ActiveTexture (GL_TEXTURE0_ARB);
qglMatrixMode (GL_TEXTURE);
qglLoadIdentity ();
qglMatrixMode (GL_MODELVIEW);
qglLoadMatrixf (r_world_matrix.m16);
}
/*
===================
RB_ShowDepthBuffer
Draw the depth buffer as colors
===================
*/
static void RB_ShowDepthBuffer() {
void *depthReadback;
if ( !r_showDepth.GetBool() ) {
return;
}
qglPushMatrix();
qglLoadIdentity();
qglMatrixMode( GL_PROJECTION );
qglPushMatrix();
qglLoadIdentity();
qglOrtho( 0, 1, 0, 1, -1, 1 );
qglRasterPos2f( 0, 0 );
qglPopMatrix();
qglMatrixMode( GL_MODELVIEW );
qglPopMatrix();
GL_State( GLS_DEPTHFUNC_ALWAYS );
GL_Color( 1, 1, 1 );
globalImages->BindNull();
depthReadback = R_StaticAlloc( renderSystem->GetWidth() * renderSystem->GetHeight()*4, TAG_RENDER_TOOLS );
memset( depthReadback, 0, renderSystem->GetWidth() * renderSystem->GetHeight()*4 );
qglReadPixels( 0, 0, renderSystem->GetWidth(), renderSystem->GetHeight(), GL_DEPTH_COMPONENT , GL_FLOAT, depthReadback );
#if 0
for ( i = 0; i < renderSystem->GetWidth() * renderSystem->GetHeight(); i++ ) {
((byte *)depthReadback)[i*4] =
((byte *)depthReadback)[i*4+1] =
((byte *)depthReadback)[i*4+2] = 255 * ((float *)depthReadback)[i];
((byte *)depthReadback)[i*4+3] = 1;
}
#endif
qglDrawPixels( renderSystem->GetWidth(), renderSystem->GetHeight(), GL_RGBA , GL_UNSIGNED_BYTE, depthReadback );
R_StaticFree( depthReadback );
}
/*
=================
RB_BeginDrawingView
Any mirrored or portaled views have already been drawn, so prepare
to actually render the visible surfaces for this view
=================
*/
void RB_BeginDrawingView (void) {
// set the modelview matrix for the viewer
qglMatrixMode(GL_PROJECTION);
qglLoadMatrixf( backEnd.viewDef->projectionMatrix );
qglMatrixMode(GL_MODELVIEW);
// set the window clipping
qglViewport( tr.viewportOffset[0] + backEnd.viewDef->viewport.x1,
tr.viewportOffset[1] + backEnd.viewDef->viewport.y1,
backEnd.viewDef->viewport.x2 + 1 - backEnd.viewDef->viewport.x1,
backEnd.viewDef->viewport.y2 + 1 - backEnd.viewDef->viewport.y1 );
// the scissor may be smaller than the viewport for subviews
qglScissor( tr.viewportOffset[0] + backEnd.viewDef->viewport.x1 + backEnd.viewDef->scissor.x1,
tr.viewportOffset[1] + backEnd.viewDef->viewport.y1 + backEnd.viewDef->scissor.y1,
backEnd.viewDef->scissor.x2 + 1 - backEnd.viewDef->scissor.x1,
backEnd.viewDef->scissor.y2 + 1 - backEnd.viewDef->scissor.y1 );
backEnd.currentScissor = backEnd.viewDef->scissor;
// ensures that depth writes are enabled for the depth clear
GL_State( GLS_DEFAULT );
// we don't have to clear the depth / stencil buffer for 2D rendering
if ( backEnd.viewDef->viewEntitys ) {
qglStencilMask( 0xff );
// some cards may have 7 bit stencil buffers, so don't assume this
// should be 128
qglClearStencil( 1<<(glConfig.stencilBits-1) );
qglClear( GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
qglEnable( GL_DEPTH_TEST );
} else {
qglDisable( GL_DEPTH_TEST );
qglDisable( GL_STENCIL_TEST );
}
backEnd.glState.faceCulling = -1; // force face culling to set next time
GL_Cull( CT_FRONT_SIDED );
}
/*
=================
R_PostprocessScreen
=================
*/
void R_PostprocessScreen( void )
{
if( !postprocess )
return;
if ( backEnd.donepostproc )
return;
if ( !backEnd.doneSurfaces )
return;
backEnd.donepostproc = qtrue;
if( !postproc.started ) {
R_Postprocess_InitTextures();
if( !postproc.started )
return;
}
if ( !backEnd.projection2D )
RB_SetGL2D();
#if 0
// set up full screen workspace
GL_TexEnv( GL_MODULATE );
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglViewport( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglMatrixMode( GL_PROJECTION );
qglLoadIdentity ();
qglOrtho( 0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1 );
qglMatrixMode( GL_MODELVIEW );
qglLoadIdentity ();
GL_Cull( CT_TWO_SIDED );
#endif
qglColor4f( 1, 1, 1, 1 );
//Backup the old screen in a texture
R_Postprocess_BackupScreen();
//Redraw texture using GLSL program
R_Bloom_RestoreScreen_Postprocessed();
}
static void RB_Bloom( void ) {
int i;
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity();
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity();
RB_SetGL2D();
GL_State(GLS_DEPTHTEST_DISABLE);
for (i = 0; i < r_BloomPasses->integer; i++) {
RB_BloomDownSample();
RB_BloomBrightness();
if (r_BloomDebug->integer < 2) {
RB_BloomBlurHorizontal();
RB_BloomBlurVertical();
}
if (r_BloomDebug->integer == 0 || r_BloomDebug->integer == 3) {
RB_BloomCombine();
}
}
}
/*
================
RB_SetGL2D
================
*/
void RB_SetGL2D (void) {
backEnd.projection2D = qtrue;
// set 2D virtual screen size
#ifdef IPHONE
if ( glConfig.vidRotation == 90.0 || glConfig.vidRotation == 270.0 )
{
qglViewport ( 0, 0, glConfig.vidHeight, glConfig.vidWidth );
qglScissor( 0, 0, glConfig.vidHeight, glConfig.vidWidth );
}
else
#endif // IPHONE
{
qglViewport ( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
qglScissor( 0, 0, glConfig.vidWidth, glConfig.vidHeight );
}
qglMatrixMode(GL_PROJECTION);
qglLoadIdentity ();
#ifdef IPHONE
qglRotatef (glConfig.vidRotation, 0, 0, 1);
qglTranslatef (0, 0, 0);
#endif // IPHONE
qglOrtho (0, glConfig.vidWidth, glConfig.vidHeight, 0, 0, 1);
qglMatrixMode(GL_MODELVIEW);
qglLoadIdentity ();
GL_State( GLS_DEPTHTEST_DISABLE |
GLS_SRCBLEND_SRC_ALPHA |
GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA );
qglDisable( GL_CULL_FACE );
qglDisable( GL_CLIP_PLANE0 );
// set time for 2D shaders
backEnd.refdef.time = ri.Milliseconds();
backEnd.refdef.floatTime = backEnd.refdef.time * 0.001f;
}
