tr_backend.c File Reference

#include "tr_local.h"

Include dependency graph for tr_backend.c:

Go to the source code of this file.

Defines
#define	MAC_EVENT_PUMP_MSEC   5
Functions
void	GL_Bind (image_t *image)
void	GL_BindMultitexture (image_t *image0, GLuint env0, image_t *image1, GLuint env1)
void	GL_Cull (int cullType)
void	GL_SelectTexture (int unit)
void	GL_State (unsigned long stateBits)
void	GL_TexEnv (int env)
void	RB_BeginDrawingView (void)
const void *	RB_DrawBuffer (const void *data)
const void *	RB_DrawSurfs (const void *data)
void	RB_ExecuteRenderCommands (const void *data)
void	RB_Hyperspace (void)
void	RB_RenderDrawSurfList (drawSurf_t *drawSurfs, int numDrawSurfs)
void	RB_RenderThread (void)
const void *	RB_SetColor (const void *data)
void	RB_SetGL2D (void)
void	RB_ShowImages (void)
const void *	RB_StretchPic (const void *data)
const void *	RB_SwapBuffers (const void *data)
void	RE_StretchRaw (int x, int y, int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty)
void	RE_UploadCinematic (int w, int h, int cols, int rows, const byte *data, int client, qboolean dirty)
void	SetViewportAndScissor (void)
Variables
backEndState_t	backEnd
backEndData_t *	backEndData [SMP_FRAMES]
float	s_flipMatrix [16]

---

Define Documentation

#define MAC_EVENT_PUMP_MSEC   5

Definition at line 512 of file tr_backend.c.

---

Function Documentation

void GL_Bind (  image_t *  image  )

Definition at line 41 of file tr_backend.c. References glstate_t::currenttextures, glstate_t::currenttmu, trGlobals_t::defaultImage, trGlobals_t::dlightImage, trGlobals_t::frameCount, image_s::frameUsed, glState, image_t, cvar_s::integer, PRINT_WARNING, qglBindTexture, r_nobind, ri, image_s::texnum, and tr. Referenced by DrawNormals(), DrawSkySide(), DrawTris(), GL_TextureMode(), ProjectDlightTexture(), R_BindAnimatedImage(), R_CreateImage(), R_DebugGraphics(), RB_FogPass(), RB_IterateStagesGeneric(), RB_ShadowFinish(), RB_ShadowTessEnd(), RB_ShowImages(), RB_SurfaceAxis(), RB_SurfaceBeam(), RE_StretchRaw(), and RE_UploadCinematic(). { int texnum; if ( !image ) { ri.Printf( PRINT_WARNING, "GL_Bind: NULL image\n" ); texnum = tr.defaultImage->texnum; } else { texnum = image->texnum; } if ( r_nobind->integer && tr.dlightImage ) { // performance evaluation option texnum = tr.dlightImage->texnum; } if ( glState.currenttextures[glState.currenttmu] != texnum ) { image->frameUsed = tr.frameCount; glState.currenttextures[glState.currenttmu] = texnum; qglBindTexture (GL_TEXTURE_2D, texnum); } }

void GL_BindMultitexture (  image_t *  image0, GLuint  env0, image_t *  image1, GLuint  env1 )

Definition at line 96 of file tr_backend.c. References glstate_t::currenttextures, trGlobals_t::dlightImage, trGlobals_t::frameCount, image_s::frameUsed, GL_SelectTexture(), glState, image_t, cvar_s::integer, qglBindTexture, r_nobind, image_s::texnum, and tr. { int texnum0, texnum1; texnum0 = image0->texnum; texnum1 = image1->texnum; if ( r_nobind->integer && tr.dlightImage ) { // performance evaluation option texnum0 = texnum1 = tr.dlightImage->texnum; } if ( glState.currenttextures[1] != texnum1 ) { GL_SelectTexture( 1 ); image1->frameUsed = tr.frameCount; glState.currenttextures[1] = texnum1; qglBindTexture( GL_TEXTURE_2D, texnum1 ); } if ( glState.currenttextures[0] != texnum0 ) { GL_SelectTexture( 0 ); image0->frameUsed = tr.frameCount; glState.currenttextures[0] = texnum0; qglBindTexture( GL_TEXTURE_2D, texnum0 ); } }

Here is the call graph for this function:

void GL_Cull (  int  cullType  )

Definition at line 124 of file tr_backend.c. References backEnd, glstate_t::faceCulling, glState, viewParms_t::isMirror, qglCullFace, qglDisable, qglEnable, and backEndState_t::viewParms. Referenced by R_DebugGraphics(), RB_StageIteratorGeneric(), RB_StageIteratorLightmappedMultitexture(), and RB_StageIteratorVertexLitTexture(). { if ( glState.faceCulling == cullType ) { return; } glState.faceCulling = cullType; if ( cullType == CT_TWO_SIDED ) { qglDisable( GL_CULL_FACE ); } else { qglEnable( GL_CULL_FACE ); if ( cullType == CT_BACK_SIDED ) { if ( backEnd.viewParms.isMirror ) { qglCullFace( GL_FRONT ); } else { qglCullFace( GL_BACK ); } } else { if ( backEnd.viewParms.isMirror ) { qglCullFace( GL_BACK ); } else { qglCullFace( GL_FRONT ); } } } }

void GL_SelectTexture (  int  unit  )

Definition at line 65 of file tr_backend.c. References glstate_t::currenttmu, ERR_DROP, GL_TEXTURE0_ARB, GL_TEXTURE1_ARB, GLimp_LogComment(), glState, qglActiveTextureARB, qglClientActiveTextureARB, and ri. Referenced by DrawMultitextured(), GL_BindMultitexture(), GL_SetDefaultState(), R_CreateImage(), R_DeleteTextures(), and RB_StageIteratorLightmappedMultitexture(). { 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; }

Here is the call graph for this function:

void GL_State (  unsigned long  stateBits  )

Definition at line 203 of file tr_backend.c. References assert, ERR_DROP, f, GLenum(), GLS_ATEST_GE_80, GLS_ATEST_GT_0, GLS_ATEST_LT_80, GLS_DSTBLEND_DST_ALPHA, GLS_DSTBLEND_ONE, GLS_DSTBLEND_ONE_MINUS_DST_ALPHA, GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA, GLS_DSTBLEND_ONE_MINUS_SRC_COLOR, GLS_DSTBLEND_SRC_ALPHA, GLS_DSTBLEND_SRC_COLOR, GLS_DSTBLEND_ZERO, GLS_SRCBLEND_ALPHA_SATURATE, GLS_SRCBLEND_BITS, GLS_SRCBLEND_DST_ALPHA, GLS_SRCBLEND_DST_COLOR, GLS_SRCBLEND_ONE, GLS_SRCBLEND_ONE_MINUS_DST_ALPHA, GLS_SRCBLEND_ONE_MINUS_DST_COLOR, GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA, GLS_SRCBLEND_SRC_ALPHA, GLS_SRCBLEND_ZERO, glState, glstate_t::glStateBits, qglAlphaFunc, qglBlendFunc, qglDepthFunc, qglDepthMask, qglDisable, qglEnable, qglPolygonMode, and ri. Referenced by DrawMultitextured(), DrawNormals(), DrawTris(), ProjectDlightTexture(), R_DebugPolygon(), RB_BeginDrawingView(), RB_FogPass(), RB_IterateStagesGeneric(), RB_SetGL2D(), RB_ShadowFinish(), RB_ShadowTessEnd(), RB_StageIteratorLightmappedMultitexture(), RB_StageIteratorSky(), RB_StageIteratorVertexLitTexture(), and RB_SurfaceBeam(). { unsigned long diff = stateBits ^ glState.glStateBits; if ( !diff ) { return; } // // check depthFunc bits // if ( diff & GLS_DEPTHFUNC_EQUAL ) { if ( stateBits & GLS_DEPTHFUNC_EQUAL ) { qglDepthFunc( GL_EQUAL ); } else { qglDepthFunc( GL_LEQUAL ); } } // // check blend bits // if ( diff & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) ) { GLenum srcFactor, dstFactor; if ( stateBits & ( GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS ) ) { switch ( stateBits & GLS_SRCBLEND_BITS ) { case GLS_SRCBLEND_ZERO: srcFactor = GL_ZERO; break; case GLS_SRCBLEND_ONE: srcFactor = GL_ONE; break; case GLS_SRCBLEND_DST_COLOR: srcFactor = GL_DST_COLOR; break; case GLS_SRCBLEND_ONE_MINUS_DST_COLOR: srcFactor = GL_ONE_MINUS_DST_COLOR; break; case GLS_SRCBLEND_SRC_ALPHA: srcFactor = GL_SRC_ALPHA; break; case GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA: srcFactor = GL_ONE_MINUS_SRC_ALPHA; break; case GLS_SRCBLEND_DST_ALPHA: srcFactor = GL_DST_ALPHA; break; case GLS_SRCBLEND_ONE_MINUS_DST_ALPHA: srcFactor = GL_ONE_MINUS_DST_ALPHA; break; case GLS_SRCBLEND_ALPHA_SATURATE: srcFactor = GL_SRC_ALPHA_SATURATE; break; default: srcFactor = GL_ONE; // to get warning to shut up ri.Error( ERR_DROP, "GL_State: invalid src blend state bits\n" ); break; } switch ( stateBits & GLS_DSTBLEND_BITS ) { case GLS_DSTBLEND_ZERO: dstFactor = GL_ZERO; break; case GLS_DSTBLEND_ONE: dstFactor = GL_ONE; break; case GLS_DSTBLEND_SRC_COLOR: dstFactor = GL_SRC_COLOR; break; case GLS_DSTBLEND_ONE_MINUS_SRC_COLOR: dstFactor = GL_ONE_MINUS_SRC_COLOR; break; case GLS_DSTBLEND_SRC_ALPHA: dstFactor = GL_SRC_ALPHA; break; case GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA: dstFactor = GL_ONE_MINUS_SRC_ALPHA; break; case GLS_DSTBLEND_DST_ALPHA: dstFactor = GL_DST_ALPHA; break; case GLS_DSTBLEND_ONE_MINUS_DST_ALPHA: dstFactor = GL_ONE_MINUS_DST_ALPHA; break; default: dstFactor = GL_ONE; // to get warning to shut up ri.Error( ERR_DROP, "GL_State: invalid dst blend state bits\n" ); break; } qglEnable( GL_BLEND ); qglBlendFunc( srcFactor, dstFactor ); } else { qglDisable( GL_BLEND ); } } // // check depthmask // if ( diff & GLS_DEPTHMASK_TRUE ) { if ( stateBits & GLS_DEPTHMASK_TRUE ) { qglDepthMask( GL_TRUE ); } else { qglDepthMask( GL_FALSE ); } } // // fill/line mode // if ( diff & GLS_POLYMODE_LINE ) { if ( stateBits & GLS_POLYMODE_LINE ) { qglPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); } else { qglPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); } } // // depthtest // if ( diff & GLS_DEPTHTEST_DISABLE ) { if ( stateBits & GLS_DEPTHTEST_DISABLE ) { qglDisable( GL_DEPTH_TEST ); } else { qglEnable( GL_DEPTH_TEST ); } } // // alpha test // if ( diff & GLS_ATEST_BITS ) { switch ( stateBits & GLS_ATEST_BITS ) { case 0: qglDisable( GL_ALPHA_TEST ); break; case GLS_ATEST_GT_0: qglEnable( GL_ALPHA_TEST ); qglAlphaFunc( GL_GREATER, 0.0f ); break; case GLS_ATEST_LT_80: qglEnable( GL_ALPHA_TEST ); qglAlphaFunc( GL_LESS, 0.5f ); break; case GLS_ATEST_GE_80: qglEnable( GL_ALPHA_TEST ); qglAlphaFunc( GL_GEQUAL, 0.5f ); break; default: assert( 0 ); break; } } glState.glStateBits = stateBits; }

Here is the call graph for this function:

void GL_TexEnv (  int  env  )

Definition at line 167 of file tr_backend.c. References glstate_t::currenttmu, ERR_DROP, glState, qglTexEnvf, ri, and glstate_t::texEnv. Referenced by DrawMultitextured(), GL_SetDefaultState(), and RB_StageIteratorLightmappedMultitexture(). { if ( env == glState.texEnv[glState.currenttmu] ) { return; } glState.texEnv[glState.currenttmu] = env; switch ( env ) { case GL_MODULATE: qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE ); break; case GL_REPLACE: qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE ); break; case GL_DECAL: qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL ); break; case GL_ADD: qglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD ); break; default: ri.Error( ERR_DROP, "GL_TexEnv: invalid env '%d' passed\n", env ); break; } }

void RB_BeginDrawingView (  void   )

Definition at line 432 of file tr_backend.c. References orientationr_t::axis, backEnd, cplane_s::dist, DotProduct, f, glstate_t::faceCulling, glstate_t::finishCalled, GL_State(), GLS_DEFAULT, glState, cvar_s::integer, backEndState_t::isHyperspace, viewParms_t::isPortal, cplane_s::normal, viewParms_t::or, orientationr_t::origin, viewParms_t::portalPlane, backEndState_t::projection2D, qglClear, qglClearColor, qglClipPlane, qglDisable, qglEnable, qglFinish, qglLoadMatrixf, r_fastsky, r_finish, r_measureOverdraw, r_shadows, RB_Hyperspace(), trRefdef_t::rdflags, backEndState_t::refdef, s_flipMatrix, SetViewportAndScissor(), backEndState_t::skyRenderedThisView, and backEndState_t::viewParms. Referenced by RB_RenderDrawSurfList(). { int clearBits = 0; // sync with gl if needed if ( r_finish->integer == 1 && !glState.finishCalled ) { qglFinish (); glState.finishCalled = qtrue; } if ( r_finish->integer == 0 ) { glState.finishCalled = qtrue; } // we will need to change the projection matrix before drawing // 2D images again backEnd.projection2D = qfalse; // // set the modelview matrix for the viewer // SetViewportAndScissor(); // ensures that depth writes are enabled for the depth clear GL_State( GLS_DEFAULT ); // clear relevant buffers clearBits = GL_DEPTH_BUFFER_BIT; if ( r_measureOverdraw->integer || r_shadows->integer == 2 ) { clearBits |= GL_STENCIL_BUFFER_BIT; } if ( r_fastsky->integer && !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) ) { clearBits |= GL_COLOR_BUFFER_BIT; // FIXME: only if sky shaders have been used #ifdef _DEBUG qglClearColor( 0.8f, 0.7f, 0.4f, 1.0f ); // FIXME: get color of sky #else qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); // FIXME: get color of sky #endif } qglClear( clearBits ); if ( ( backEnd.refdef.rdflags & RDF_HYPERSPACE ) ) { RB_Hyperspace(); return; } else { backEnd.isHyperspace = qfalse; } glState.faceCulling = -1; // force face culling to set next time // we will only draw a sun if there was sky rendered in this view backEnd.skyRenderedThisView = qfalse; // clip to the plane of the portal if ( backEnd.viewParms.isPortal ) { float plane[4]; double plane2[4]; plane[0] = backEnd.viewParms.portalPlane.normal[0]; plane[1] = backEnd.viewParms.portalPlane.normal[1]; plane[2] = backEnd.viewParms.portalPlane.normal[2]; plane[3] = backEnd.viewParms.portalPlane.dist; plane2[0] = DotProduct (backEnd.viewParms.or.axis[0], plane); plane2[1] = DotProduct (backEnd.viewParms.or.axis[1], plane); plane2[2] = DotProduct (backEnd.viewParms.or.axis[2], plane); plane2[3] = DotProduct (plane, backEnd.viewParms.or.origin) - plane[3]; qglLoadMatrixf( s_flipMatrix ); qglClipPlane (GL_CLIP_PLANE0, plane2); qglEnable (GL_CLIP_PLANE0); } else { qglDisable (GL_CLIP_PLANE0); } }

Here is the call graph for this function:

const void* RB_DrawBuffer (  const void *  data  )

Definition at line 937 of file tr_backend.c. References drawBufferCommand_t::buffer, cvar_s::integer, qglClear, qglClearColor, qglDrawBuffer, and r_clear. Referenced by RB_ExecuteRenderCommands(). { const drawBufferCommand_t *cmd; cmd = (const drawBufferCommand_t *)data; qglDrawBuffer( cmd->buffer ); // clear screen for debugging if ( r_clear->integer ) { qglClearColor( 1, 0, 0.5, 1 ); qglClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); } return (const void *)(cmd + 1); }

const void* RB_DrawSurfs (  const void *  data  )

Definition at line 912 of file tr_backend.c. References backEnd, drawSurfsCommand_t::drawSurfs, drawSurfsCommand_t::numDrawSurfs, shaderCommands_s::numIndexes, RB_EndSurface(), RB_RenderDrawSurfList(), drawSurfsCommand_t::refdef, backEndState_t::refdef, tess, drawSurfsCommand_t::viewParms, and backEndState_t::viewParms. Referenced by RB_ExecuteRenderCommands(). { const drawSurfsCommand_t *cmd; // finish any 2D drawing if needed if ( tess.numIndexes ) { RB_EndSurface(); } cmd = (const drawSurfsCommand_t *)data; backEnd.refdef = cmd->refdef; backEnd.viewParms = cmd->viewParms; RB_RenderDrawSurfList( cmd->drawSurfs, cmd->numDrawSurfs ); return (const void *)(cmd + 1); }

Here is the call graph for this function:

void RB_ExecuteRenderCommands (  const void *  data  )

Definition at line 1075 of file tr_backend.c. References backEnd, backEndData, renderCommandList_t::cmds, backEndData_t::commands, data, cvar_s::integer, refimport_t::Milliseconds, backEndCounters_t::msec, backEndState_t::pc, r_smp, RB_DrawBuffer(), RB_DrawSurfs(), RB_SetColor(), RB_StretchPic(), RB_SwapBuffers(), RB_TakeScreenshotCmd(), RC_DRAW_BUFFER, RC_DRAW_SURFS, RC_END_OF_LIST, RC_SCREENSHOT, RC_SET_COLOR, RC_STRETCH_PIC, RC_SWAP_BUFFERS, ri, and backEndState_t::smpFrame. Referenced by R_IssueRenderCommands(), and RB_RenderThread(). { int t1, t2; t1 = ri.Milliseconds (); if ( !r_smp->integer || data == backEndData[0]->commands.cmds ) { backEnd.smpFrame = 0; } else { backEnd.smpFrame = 1; } while ( 1 ) { switch ( *(const int *)data ) { case RC_SET_COLOR: data = RB_SetColor( data ); break; case RC_STRETCH_PIC: data = RB_StretchPic( data ); break; case RC_DRAW_SURFS: data = RB_DrawSurfs( data ); break; case RC_DRAW_BUFFER: data = RB_DrawBuffer( data ); break; case RC_SWAP_BUFFERS: data = RB_SwapBuffers( data ); break; case RC_SCREENSHOT: data = RB_TakeScreenshotCmd( data ); break; case RC_END_OF_LIST: default: // stop rendering on this thread t2 = ri.Milliseconds (); backEnd.pc.msec = t2 - t1; return; } } }

Here is the call graph for this function:

void RB_Hyperspace (  void   )  [static]

Definition at line 397 of file tr_backend.c. References backEnd, c, backEndState_t::isHyperspace, qglClear, qglClearColor, backEndState_t::refdef, and trRefdef_t::time. Referenced by RB_BeginDrawingView(). { float c; if ( !backEnd.isHyperspace ) { // do initialization shit } c = ( backEnd.refdef.time & 255 ) / 255.0f; qglClearColor( c, c, c, 1 ); qglClear( GL_COLOR_BUFFER_BIT ); backEnd.isHyperspace = qtrue; }

void RB_RenderDrawSurfList (  drawSurf_t *  drawSurfs, int  numDrawSurfs )

Definition at line 519 of file tr_backend.c. References backEnd, backEndCounters_t::c_surfaces, backEndState_t::currentEntity, trRefdef_t::dlights, drawSurf_t, trRefEntity_t::e, trRefdef_t::entities, shader_s::entityMergable, trRefdef_t::floatTime, i, refimport_t::Milliseconds, orientationr_t::modelMatrix, trRefEntity_t::needDlights, trRefdef_t::num_dlights, backEndState_t::or, backEndState_t::pc, qboolean, qglDepthRange, qglLoadMatrixf, R_DecomposeSort(), R_RotateForEntity(), R_TransformDlights(), RB_BeginDrawingView(), RB_BeginSurface(), RB_DrawSun(), RB_EndSurface(), RB_RenderFlares(), RB_ShadowFinish(), rb_surfaceTable, backEndState_t::refdef, refEntity_t::renderfx, ri, shaderCommands_s::shader, shader_t, shaderCommands_s::shaderTime, refEntity_t::shaderTime, drawSurf_s::sort, drawSurf_s::surface, t, tess, shader_s::timeOffset, tr, backEndState_t::viewParms, viewParms_t::world, and trGlobals_t::worldEntity. Referenced by RB_DrawSurfs(). { shader_t *shader, *oldShader; int fogNum, oldFogNum; int entityNum, oldEntityNum; int dlighted, oldDlighted; qboolean depthRange, oldDepthRange; int i; drawSurf_t *drawSurf; int oldSort; float originalTime; #ifdef __MACOS__ int macEventTime; Sys_PumpEvents(); // crutch up the mac's limited buffer queue size // we don't want to pump the event loop too often and waste time, so // we are going to check every shader change macEventTime = ri.Milliseconds() + MAC_EVENT_PUMP_MSEC; #endif // save original time for entity shader offsets originalTime = backEnd.refdef.floatTime; // clear the z buffer, set the modelview, etc RB_BeginDrawingView (); // draw everything oldEntityNum = -1; backEnd.currentEntity = &tr.worldEntity; oldShader = NULL; oldFogNum = -1; oldDepthRange = qfalse; oldDlighted = qfalse; oldSort = -1; depthRange = qfalse; backEnd.pc.c_surfaces += numDrawSurfs; for (i = 0, drawSurf = drawSurfs ; i < numDrawSurfs ; i++, drawSurf++) { if ( drawSurf->sort == oldSort ) { // fast path, same as previous sort rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface ); continue; } oldSort = drawSurf->sort; R_DecomposeSort( drawSurf->sort, &entityNum, &shader, &fogNum, &dlighted ); // // change the tess parameters if needed // a "entityMergable" shader is a shader that can have surfaces from seperate // entities merged into a single batch, like smoke and blood puff sprites if (shader != oldShader || fogNum != oldFogNum || dlighted != oldDlighted || ( entityNum != oldEntityNum && !shader->entityMergable ) ) { if (oldShader != NULL) { #ifdef __MACOS__ // crutch up the mac's limited buffer queue size int t; t = ri.Milliseconds(); if ( t > macEventTime ) { macEventTime = t + MAC_EVENT_PUMP_MSEC; Sys_PumpEvents(); } #endif RB_EndSurface(); } RB_BeginSurface( shader, fogNum ); oldShader = shader; oldFogNum = fogNum; oldDlighted = dlighted; } // // change the modelview matrix if needed // if ( entityNum != oldEntityNum ) { depthRange = qfalse; if ( entityNum != ENTITYNUM_WORLD ) { backEnd.currentEntity = &backEnd.refdef.entities[entityNum]; backEnd.refdef.floatTime = originalTime - backEnd.currentEntity->e.shaderTime; // we have to reset the shaderTime as well otherwise image animations start // from the wrong frame tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset; // set up the transformation matrix R_RotateForEntity( backEnd.currentEntity, &backEnd.viewParms, &backEnd.or ); // set up the dynamic lighting if needed if ( backEnd.currentEntity->needDlights ) { R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.or ); } if ( backEnd.currentEntity->e.renderfx & RF_DEPTHHACK ) { // hack the depth range to prevent view model from poking into walls depthRange = qtrue; } } else { backEnd.currentEntity = &tr.worldEntity; backEnd.refdef.floatTime = originalTime; backEnd.or = backEnd.viewParms.world; // we have to reset the shaderTime as well otherwise image animations on // the world (like water) continue with the wrong frame tess.shaderTime = backEnd.refdef.floatTime - tess.shader->timeOffset; R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.or ); } qglLoadMatrixf( backEnd.or.modelMatrix ); // // change depthrange if needed // if ( oldDepthRange != depthRange ) { if ( depthRange ) { qglDepthRange (0, 0.3); } else { qglDepthRange (0, 1); } oldDepthRange = depthRange; } oldEntityNum = entityNum; } // add the triangles for this surface rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface ); } backEnd.refdef.floatTime = originalTime; // draw the contents of the last shader batch if (oldShader != NULL) { RB_EndSurface(); } // go back to the world modelview matrix qglLoadMatrixf( backEnd.viewParms.world.modelMatrix ); if ( depthRange ) { qglDepthRange (0, 1); } #if 0 RB_DrawSun(); #endif // darken down any stencil shadows RB_ShadowFinish(); // add light flares on lights that aren't obscured RB_RenderFlares(); #ifdef __MACOS__ Sys_PumpEvents(); // crutch up the mac's limited buffer queue size #endif }

Here is the call graph for this function:

void RB_RenderThread (  void   )

Definition at line 1124 of file tr_backend.c. References data, GLimp_RendererSleep(), RB_ExecuteRenderCommands(), and renderThreadActive. Referenced by R_InitCommandBuffers(). { const void *data; // wait for either a rendering command or a quit command while ( 1 ) { // sleep until we have work to do data = GLimp_RendererSleep(); if ( !data ) { return; // all done, renderer is shutting down } renderThreadActive = qtrue; RB_ExecuteRenderCommands( data ); renderThreadActive = qfalse; } }

Here is the call graph for this function:

const void* RB_SetColor (  const void *  data  )

Definition at line 817 of file tr_backend.c. References backEnd, setColorCommand_t::color, and backEndState_t::color2D. Referenced by RB_ExecuteRenderCommands(). { const setColorCommand_t *cmd; cmd = (const setColorCommand_t *)data; backEnd.color2D[0] = cmd->color[0] * 255; backEnd.color2D[1] = cmd->color[1] * 255; backEnd.color2D[2] = cmd->color[2] * 255; backEnd.color2D[3] = cmd->color[3] * 255; return (const void *)(cmd + 1); }

void RB_SetGL2D (  void   )

Definition at line 688 of file tr_backend.c. References backEnd, trRefdef_t::floatTime, GL_State(), glConfig, GLS_DEPTHTEST_DISABLE, GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA, GLS_SRCBLEND_SRC_ALPHA, refimport_t::Milliseconds, backEndState_t::projection2D, qglDisable, qglLoadIdentity, qglMatrixMode, qglOrtho, qglScissor, qglViewport, backEndState_t::refdef, ri, trRefdef_t::time, glconfig_t::vidHeight, and glconfig_t::vidWidth. Referenced by RB_ShowImages(), RB_StretchPic(), and RE_StretchRaw(). { 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_CULL_FACE ); qglDisable( GL_CLIP_PLANE0 ); // set time for 2D shaders backEnd.refdef.time = ri.Milliseconds(); backEnd.refdef.floatTime = backEnd.refdef.time * 0.001f; }

Here is the call graph for this function:

void RB_ShowImages (  void   )

Definition at line 963 of file tr_backend.c. References backEnd, GL_Bind(), glConfig, h(), i, image_t, trGlobals_t::images, cvar_s::integer, refimport_t::Milliseconds, trGlobals_t::numImages, PRINT_ALL, backEndState_t::projection2D, qglBegin, qglClear, qglEnd, qglFinish, qglTexCoord2f, qglVertex2f, r_showImages, RB_SetGL2D(), ri, tr, image_s::uploadHeight, image_s::uploadWidth, glconfig_t::vidHeight, glconfig_t::vidWidth, w, x, and y. Referenced by RB_SwapBuffers(), and RE_EndRegistration(). { int i; image_t *image; float x, y, w, h; int start, end; if ( !backEnd.projection2D ) { RB_SetGL2D(); } qglClear( GL_COLOR_BUFFER_BIT ); qglFinish(); start = ri.Milliseconds(); for ( i=0 ; i<tr.numImages ; i++ ) { image = tr.images[i]; w = glConfig.vidWidth / 20; h = glConfig.vidHeight / 15; x = i % 20 * w; y = i / 20 * h; // show in proportional size in mode 2 if ( r_showImages->integer == 2 ) { w *= image->uploadWidth / 512.0f; h *= image->uploadHeight / 512.0f; } GL_Bind( image ); qglBegin (GL_QUADS); qglTexCoord2f( 0, 0 ); qglVertex2f( x, y ); qglTexCoord2f( 1, 0 ); qglVertex2f( x + w, y ); qglTexCoord2f( 1, 1 ); qglVertex2f( x + w, y + h ); qglTexCoord2f( 0, 1 ); qglVertex2f( x, y + h ); qglEnd(); } qglFinish(); end = ri.Milliseconds(); ri.Printf( PRINT_ALL, "%i msec to draw all images\n", end - start ); }

Here is the call graph for this function:

const void* RB_StretchPic (  const void *  data  )

Definition at line 835 of file tr_backend.c. References backEnd, backEndState_t::color2D, backEndState_t::currentEntity, backEndState_t::entity2D, stretchPicCommand_t::h, shaderCommands_s::indexes, shaderCommands_s::numIndexes, shaderCommands_s::numVertexes, backEndState_t::projection2D, RB_BeginSurface(), RB_CHECKOVERFLOW, RB_EndSurface(), RB_SetGL2D(), stretchPicCommand_t::s1, stretchPicCommand_t::s2, shaderCommands_s::shader, stretchPicCommand_t::shader, shader_t, stretchPicCommand_t::t1, stretchPicCommand_t::t2, tess, shaderCommands_s::texCoords, shaderCommands_s::vertexColors, stretchPicCommand_t::w, stretchPicCommand_t::x, shaderCommands_s::xyz, and stretchPicCommand_t::y. Referenced by RB_ExecuteRenderCommands(). { const stretchPicCommand_t *cmd; shader_t *shader; int numVerts, numIndexes; cmd = (const stretchPicCommand_t *)data; if ( !backEnd.projection2D ) { RB_SetGL2D(); } shader = cmd->shader; if ( shader != tess.shader ) { if ( tess.numIndexes ) { RB_EndSurface(); } backEnd.currentEntity = &backEnd.entity2D; RB_BeginSurface( shader, 0 ); } RB_CHECKOVERFLOW( 4, 6 ); numVerts = tess.numVertexes; numIndexes = tess.numIndexes; tess.numVertexes += 4; tess.numIndexes += 6; tess.indexes[ numIndexes ] = numVerts + 3; tess.indexes[ numIndexes + 1 ] = numVerts + 0; tess.indexes[ numIndexes + 2 ] = numVerts + 2; tess.indexes[ numIndexes + 3 ] = numVerts + 2; tess.indexes[ numIndexes + 4 ] = numVerts + 0; tess.indexes[ numIndexes + 5 ] = numVerts + 1; *(int *)tess.