//update tr.screenImage
void RB_CaptureScreenImage(void)
{
int radX = 2048;
int radY = 2048;
int x = glConfig.vidWidth/2;
int y = glConfig.vidHeight/2;
int cX, cY;
GL_Bind( tr.screenImage );
//using this method, we could pixel-filter the texture and all sorts of crazy stuff.
//but, it is slow as hell.
/*
static byte *tmp = NULL;
if (!tmp)
{
tmp = (byte *)Z_Malloc((sizeof(byte)*4)*(glConfig.vidWidth*glConfig.vidHeight), TAG_ICARUS, qtrue);
}
qglReadPixels(0, 0, glConfig.vidWidth, glConfig.vidHeight, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
qglTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, tmp);
*/
if (radX > glConfig.maxTextureSize)
{
radX = glConfig.maxTextureSize;
}
if (radY > glConfig.maxTextureSize)
{
radY = glConfig.maxTextureSize;
}
while (glConfig.vidWidth < radX)
{
radX /= 2;
}
while (glConfig.vidHeight < radY)
{
radY /= 2;
}
cX = x-(radX/2);
cY = y-(radY/2);
if (cX+radX > glConfig.vidWidth)
{ //would it go off screen?
cX = glConfig.vidWidth-radX;
}
else if (cX < 0)
{ //cap it off at 0
cX = 0;
}
if (cY+radY > glConfig.vidHeight)
{ //would it go off screen?
cY = glConfig.vidHeight-radY;
}
else if (cY < 0)
{ //cap it off at 0
cY = 0;
}
#ifndef _XBOX
qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, cX, cY, radX, radY, 0);
#else
qglCopyBackBufferToTexEXT(radX, radY, cX, (480 - cY), (cX + radX), (480 - (cY + radY)));
#endif // _XBOX
}
void RB_RenderDrawSurfList( drawSurf_t *drawSurfs, int numDrawSurfs ) {
shader_t *shader, *oldShader;
int fogNum, oldFogNum;
int entityNum, oldEntityNum;
int dlighted, oldDlighted;
int depthRange, oldDepthRange;
int i;
drawSurf_t *drawSurf;
unsigned int oldSort;
float originalTime;
trRefEntity_t *curEnt;
postRender_t *pRender;
bool didShadowPass = false;
#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 = Sys_Milliseconds() + MAC_EVENT_PUMP_MSEC;
#endif
if (g_bRenderGlowingObjects)
{ //only shadow on initial passes
didShadowPass = true;
}
// 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 = (unsigned int) -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;
}
R_DecomposeSort( drawSurf->sort, &entityNum, &shader, &fogNum, &dlighted );
#ifndef _XBOX // GLOWXXX
// If we're rendering glowing objects, but this shader has no stages with glow, skip it!
if ( g_bRenderGlowingObjects && !shader->hasGlow )
{
shader = oldShader;
entityNum = oldEntityNum;
fogNum = oldFogNum;
dlighted = oldDlighted;
continue;
}
#endif
oldSort = drawSurf->sort;
//
// 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 (entityNum != TR_WORLDENT &&
g_numPostRenders < MAX_POST_RENDERS)
{
if ( (backEnd.refdef.entities[entityNum].e.renderfx & RF_DISTORTION)/* ||
(backEnd.refdef.entities[entityNum].e.renderfx & RF_FORCE_ENT_ALPHA)*/)
//not sure if we need this alpha fix for sp or not, leaving it out for now -rww
{ //must render last
curEnt = &backEnd.refdef.entities[entityNum];
pRender = &g_postRenders[g_numPostRenders];
g_numPostRenders++;
depthRange = 0;
//figure this stuff out now and store it
if ( curEnt->e.renderfx & RF_NODEPTH )
{
depthRange = 2;
}
else if ( curEnt->e.renderfx & RF_DEPTHHACK )
{
depthRange = 1;
}
pRender->depthRange = depthRange;
//It is not necessary to update the old* values because
//we are not updating now with the current values.
depthRange = oldDepthRange;
//store off the ent num
pRender->entNum = entityNum;
//remember the other values necessary for rendering this surf
pRender->drawSurf = drawSurf;
pRender->dlighted = dlighted;
pRender->fogNum = fogNum;
pRender->shader = shader;
//assure the info is back to the last set state
shader = oldShader;
entityNum = oldEntityNum;
fogNum = oldFogNum;
dlighted = oldDlighted;
oldSort = (unsigned int)-1; //invalidate this thing, cause we may want to postrender more surfs of the same sort
//continue without bothering to begin a draw surf
continue;
}
}
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 = Sys_Milliseconds();
if ( t > macEventTime ) {
macEventTime = t + MAC_EVENT_PUMP_MSEC;
Sys_PumpEvents();
}
#endif
RB_EndSurface();
if (!didShadowPass && shader && shader->sort > SS_BANNER)
{
RB_ShadowFinish();
didShadowPass = true;
}
}
RB_BeginSurface( shader, fogNum );
oldShader = shader;
oldFogNum = fogNum;
oldDlighted = dlighted;
}
//
// change the modelview matrix if needed
//
if ( entityNum != oldEntityNum ) {
depthRange = qfalse;
if ( entityNum != TR_WORLDENT ) {
backEnd.currentEntity = &backEnd.refdef.entities[entityNum];
backEnd.refdef.floatTime = originalTime - backEnd.currentEntity->e.shaderTime;
// set up the transformation matrix
R_RotateForEntity( backEnd.currentEntity, &backEnd.viewParms, &backEnd.ori );
// set up the dynamic lighting if needed
if ( backEnd.currentEntity->needDlights ) {
#ifdef VV_LIGHTING
VVLightMan.R_TransformDlights( &backEnd.ori );
#else
R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
#endif
}
if ( backEnd.currentEntity->e.renderfx & RF_NODEPTH ) {
// No depth at all, very rare but some things for seeing through walls
depthRange = 2;
}
else 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.ori = backEnd.viewParms.world;
#ifdef VV_LIGHTING
VVLightMan.R_TransformDlights( &backEnd.ori );
#else
R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
#endif
}
qglLoadMatrixf( backEnd.ori.modelMatrix );
//
// change depthrange if needed
//
if ( oldDepthRange != depthRange ) {
switch ( depthRange ) {
default:
case 0:
qglDepthRange (0, 1);
break;
case 1:
qglDepthRange (0, .3);
break;
case 2:
qglDepthRange (0, 0);
break;
}
oldDepthRange = depthRange;
}
oldEntityNum = entityNum;
}
// add the triangles for this surface
rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface );
}
// draw the contents of the last shader batch
if (oldShader != NULL) {
RB_EndSurface();
}
if (tr_stencilled && tr_distortionPrePost)
{ //ok, cap it now
RB_CaptureScreenImage();
RB_DistortionFill();
}
//render distortion surfs (or anything else that needs to be post-rendered)
if (g_numPostRenders > 0)
{
int lastPostEnt = -1;
while (g_numPostRenders > 0)
{
g_numPostRenders--;
pRender = &g_postRenders[g_numPostRenders];
RB_BeginSurface( pRender->shader, pRender->fogNum );
backEnd.currentEntity = &backEnd.refdef.entities[pRender->entNum];
backEnd.refdef.floatTime = originalTime - backEnd.currentEntity->e.shaderTime;
// set up the transformation matrix
R_RotateForEntity( backEnd.currentEntity, &backEnd.viewParms, &backEnd.ori );
// set up the dynamic lighting if needed
if ( backEnd.currentEntity->needDlights )
{
#ifdef VV_LIGHTING
VVLightMan.R_TransformDlights( &backEnd.ori );
#else
R_TransformDlights( backEnd.refdef.num_dlights, backEnd.refdef.dlights, &backEnd.ori );
#endif
}
qglLoadMatrixf( backEnd.ori.modelMatrix );
depthRange = pRender->depthRange;
switch ( depthRange )
{
default:
case 0:
qglDepthRange (0, 1);
break;
case 1:
qglDepthRange (0, .3);
break;
case 2:
qglDepthRange (0, 0);
break;
}
if ((backEnd.currentEntity->e.renderfx & RF_DISTORTION) &&
lastPostEnt != pRender->entNum)
{ //do the capture now, we only need to do it once per ent
int x, y;
int rad = backEnd.currentEntity->e.radius;
//We are going to just bind this, and then the CopyTexImage is going to
//stomp over this texture num in texture memory.
GL_Bind( tr.screenImage );
if (R_WorldCoordToScreenCoord( backEnd.currentEntity->e.origin, &x, &y ))
{
int cX, cY;
cX = glConfig.vidWidth-x-(rad/2);
cY = glConfig.vidHeight-y-(rad/2);
if (cX+rad > glConfig.vidWidth)
{ //would it go off screen?
cX = glConfig.vidWidth-rad;
}
else if (cX < 0)
{ //cap it off at 0
cX = 0;
}
if (cY+rad > glConfig.vidHeight)
{ //would it go off screen?
cY = glConfig.vidHeight-rad;
}
else if (cY < 0)
{ //cap it off at 0
cY = 0;
}
//now copy a portion of the screen to this texture
#ifdef _XBOX
qglCopyBackBufferToTexEXT(rad, rad, cX, (480 - cY), (cX + rad), (480 - (cY + rad)));
#else
qglCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, cX, cY, rad, rad, 0);
#endif
lastPostEnt = pRender->entNum;
}
}
rb_surfaceTable[ *pRender->drawSurf->surface ]( pRender->drawSurf->surface );
RB_EndSurface();
}
}
// go back to the world modelview matrix
qglLoadMatrixf( backEnd.viewParms.world.modelMatrix );
if ( depthRange ) {
qglDepthRange (0, 1);
}
#if 0
RB_DrawSun();
#endif
if (tr_stencilled && !tr_distortionPrePost)
{ //draw in the stencil buffer's cutout
RB_DistortionFill();
}
if (!didShadowPass)
{
// darken down any stencil shadows
RB_ShadowFinish();
didShadowPass = true;
}
#ifdef _XBOX
if (r_hdreffect->integer)
HDREffect.Render();
#endif
// 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
}
