mirror of
https://github.com/UberGames/lilium-voyager.git
synced 2024-11-15 08:51:55 +00:00
8531162bd9
Reserve space for end of list and swap buffer commands. These are absolutely required and cannot be dropped. Dropping swap buffer command causes screen to not update and possible crash from drawsurf buffer overflow if not enough cmd buffer space for many continous frames.
585 lines
14 KiB
C
585 lines
14 KiB
C
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
Quake III Arena source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Quake III Arena source code; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
#include "tr_local.h"
|
|
|
|
/*
|
|
=====================
|
|
R_PerformanceCounters
|
|
=====================
|
|
*/
|
|
void R_PerformanceCounters( void ) {
|
|
if ( !r_speeds->integer ) {
|
|
// clear the counters even if we aren't printing
|
|
Com_Memset( &tr.pc, 0, sizeof( tr.pc ) );
|
|
Com_Memset( &backEnd.pc, 0, sizeof( backEnd.pc ) );
|
|
return;
|
|
}
|
|
|
|
if (r_speeds->integer == 1) {
|
|
ri.Printf (PRINT_ALL, "%i/%i/%i shaders/batches/surfs %i leafs %i verts %i/%i tris %.2f mtex %.2f dc\n",
|
|
backEnd.pc.c_shaders, backEnd.pc.c_surfBatches, backEnd.pc.c_surfaces, tr.pc.c_leafs, backEnd.pc.c_vertexes,
|
|
backEnd.pc.c_indexes/3, backEnd.pc.c_totalIndexes/3,
|
|
R_SumOfUsedImages()/(1000000.0f), backEnd.pc.c_overDraw / (float)(glConfig.vidWidth * glConfig.vidHeight) );
|
|
} else if (r_speeds->integer == 2) {
|
|
ri.Printf (PRINT_ALL, "(patch) %i sin %i sclip %i sout %i bin %i bclip %i bout\n",
|
|
tr.pc.c_sphere_cull_patch_in, tr.pc.c_sphere_cull_patch_clip, tr.pc.c_sphere_cull_patch_out,
|
|
tr.pc.c_box_cull_patch_in, tr.pc.c_box_cull_patch_clip, tr.pc.c_box_cull_patch_out );
|
|
ri.Printf (PRINT_ALL, "(md3) %i sin %i sclip %i sout %i bin %i bclip %i bout\n",
|
|
tr.pc.c_sphere_cull_md3_in, tr.pc.c_sphere_cull_md3_clip, tr.pc.c_sphere_cull_md3_out,
|
|
tr.pc.c_box_cull_md3_in, tr.pc.c_box_cull_md3_clip, tr.pc.c_box_cull_md3_out );
|
|
} else if (r_speeds->integer == 3) {
|
|
ri.Printf (PRINT_ALL, "viewcluster: %i\n", tr.viewCluster );
|
|
} else if (r_speeds->integer == 4) {
|
|
if ( backEnd.pc.c_dlightVertexes ) {
|
|
ri.Printf (PRINT_ALL, "dlight srf:%i culled:%i verts:%i tris:%i\n",
|
|
tr.pc.c_dlightSurfaces, tr.pc.c_dlightSurfacesCulled,
|
|
backEnd.pc.c_dlightVertexes, backEnd.pc.c_dlightIndexes / 3 );
|
|
}
|
|
}
|
|
else if (r_speeds->integer == 5 )
|
|
{
|
|
ri.Printf( PRINT_ALL, "zFar: %.0f\n", tr.viewParms.zFar );
|
|
}
|
|
else if (r_speeds->integer == 6 )
|
|
{
|
|
ri.Printf( PRINT_ALL, "flare adds:%i tests:%i renders:%i\n",
|
|
backEnd.pc.c_flareAdds, backEnd.pc.c_flareTests, backEnd.pc.c_flareRenders );
|
|
}
|
|
else if (r_speeds->integer == 7 )
|
|
{
|
|
ri.Printf( PRINT_ALL, "VAO draws: static %i dynamic %i\nMultidraws: %i merged %i\n",
|
|
backEnd.pc.c_staticVaoDraws, backEnd.pc.c_dynamicVaoDraws, backEnd.pc.c_multidraws, backEnd.pc.c_multidrawsMerged );
|
|
ri.Printf( PRINT_ALL, "GLSL binds: %i draws: gen %i light %i fog %i dlight %i\n",
|
|
backEnd.pc.c_glslShaderBinds, backEnd.pc.c_genericDraws, backEnd.pc.c_lightallDraws, backEnd.pc.c_fogDraws, backEnd.pc.c_dlightDraws);
|
|
}
|
|
|
|
Com_Memset( &tr.pc, 0, sizeof( tr.pc ) );
|
|
Com_Memset( &backEnd.pc, 0, sizeof( backEnd.pc ) );
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
R_IssueRenderCommands
|
|
====================
|
|
*/
|
|
void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
|
|
renderCommandList_t *cmdList;
|
|
|
|
cmdList = &backEndData->commands;
|
|
assert(cmdList);
|
|
// add an end-of-list command
|
|
*(int *)(cmdList->cmds + cmdList->used) = RC_END_OF_LIST;
|
|
|
|
// clear it out, in case this is a sync and not a buffer flip
|
|
cmdList->used = 0;
|
|
|
|
if ( runPerformanceCounters ) {
|
|
R_PerformanceCounters();
|
|
}
|
|
|
|
// actually start the commands going
|
|
if ( !r_skipBackEnd->integer ) {
|
|
// let it start on the new batch
|
|
RB_ExecuteRenderCommands( cmdList->cmds );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
R_IssuePendingRenderCommands
|
|
|
|
Issue any pending commands and wait for them to complete.
|
|
====================
|
|
*/
|
|
void R_IssuePendingRenderCommands( void ) {
|
|
if ( !tr.registered ) {
|
|
return;
|
|
}
|
|
R_IssueRenderCommands( qfalse );
|
|
}
|
|
|
|
/*
|
|
============
|
|
R_GetCommandBufferReserved
|
|
|
|
make sure there is enough command space
|
|
============
|
|
*/
|
|
void *R_GetCommandBufferReserved( int bytes, int reservedBytes ) {
|
|
renderCommandList_t *cmdList;
|
|
|
|
cmdList = &backEndData->commands;
|
|
bytes = PAD(bytes, sizeof(void *));
|
|
|
|
// always leave room for the end of list command
|
|
if ( cmdList->used + bytes + 4 + reservedBytes > MAX_RENDER_COMMANDS ) {
|
|
if ( bytes > MAX_RENDER_COMMANDS - 4 ) {
|
|
ri.Error( ERR_FATAL, "R_GetCommandBuffer: bad size %i", bytes );
|
|
}
|
|
// if we run out of room, just start dropping commands
|
|
return NULL;
|
|
}
|
|
|
|
cmdList->used += bytes;
|
|
|
|
return cmdList->cmds + cmdList->used - bytes;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
R_GetCommandBuffer
|
|
|
|
returns NULL if there is not enough space for important commands
|
|
=============
|
|
*/
|
|
void *R_GetCommandBuffer( int bytes ) {
|
|
return R_GetCommandBufferReserved( bytes, sizeof ( swapBuffersCommand_t ) );
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
R_AddDrawSurfCmd
|
|
|
|
=============
|
|
*/
|
|
void R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs ) {
|
|
drawSurfsCommand_t *cmd;
|
|
|
|
cmd = R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_DRAW_SURFS;
|
|
|
|
cmd->drawSurfs = drawSurfs;
|
|
cmd->numDrawSurfs = numDrawSurfs;
|
|
|
|
cmd->refdef = tr.refdef;
|
|
cmd->viewParms = tr.viewParms;
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
R_AddCapShadowmapCmd
|
|
|
|
=============
|
|
*/
|
|
void R_AddCapShadowmapCmd( int map, int cubeSide ) {
|
|
capShadowmapCommand_t *cmd;
|
|
|
|
cmd = R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_CAPSHADOWMAP;
|
|
|
|
cmd->map = map;
|
|
cmd->cubeSide = cubeSide;
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
R_PostProcessingCmd
|
|
|
|
=============
|
|
*/
|
|
void R_AddPostProcessCmd( ) {
|
|
postProcessCommand_t *cmd;
|
|
|
|
cmd = R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_POSTPROCESS;
|
|
|
|
cmd->refdef = tr.refdef;
|
|
cmd->viewParms = tr.viewParms;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
RE_SetColor
|
|
|
|
Passing NULL will set the color to white
|
|
=============
|
|
*/
|
|
void RE_SetColor( const float *rgba ) {
|
|
setColorCommand_t *cmd;
|
|
|
|
if ( !tr.registered ) {
|
|
return;
|
|
}
|
|
cmd = R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_SET_COLOR;
|
|
if ( !rgba ) {
|
|
static float colorWhite[4] = { 1, 1, 1, 1 };
|
|
|
|
rgba = colorWhite;
|
|
}
|
|
|
|
cmd->color[0] = rgba[0];
|
|
cmd->color[1] = rgba[1];
|
|
cmd->color[2] = rgba[2];
|
|
cmd->color[3] = rgba[3];
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
RE_StretchPic
|
|
=============
|
|
*/
|
|
void RE_StretchPic ( float x, float y, float w, float h,
|
|
float s1, float t1, float s2, float t2, qhandle_t hShader ) {
|
|
stretchPicCommand_t *cmd;
|
|
|
|
if (!tr.registered) {
|
|
return;
|
|
}
|
|
cmd = R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_STRETCH_PIC;
|
|
cmd->shader = R_GetShaderByHandle( hShader );
|
|
cmd->x = x;
|
|
cmd->y = y;
|
|
cmd->w = w;
|
|
cmd->h = h;
|
|
cmd->s1 = s1;
|
|
cmd->t1 = t1;
|
|
cmd->s2 = s2;
|
|
cmd->t2 = t2;
|
|
}
|
|
|
|
#define MODE_RED_CYAN 1
|
|
#define MODE_RED_BLUE 2
|
|
#define MODE_RED_GREEN 3
|
|
#define MODE_GREEN_MAGENTA 4
|
|
#define MODE_MAX MODE_GREEN_MAGENTA
|
|
|
|
void R_SetColorMode(GLboolean *rgba, stereoFrame_t stereoFrame, int colormode)
|
|
{
|
|
rgba[0] = rgba[1] = rgba[2] = rgba[3] = GL_TRUE;
|
|
|
|
if(colormode > MODE_MAX)
|
|
{
|
|
if(stereoFrame == STEREO_LEFT)
|
|
stereoFrame = STEREO_RIGHT;
|
|
else if(stereoFrame == STEREO_RIGHT)
|
|
stereoFrame = STEREO_LEFT;
|
|
|
|
colormode -= MODE_MAX;
|
|
}
|
|
|
|
if(colormode == MODE_GREEN_MAGENTA)
|
|
{
|
|
if(stereoFrame == STEREO_LEFT)
|
|
rgba[0] = rgba[2] = GL_FALSE;
|
|
else if(stereoFrame == STEREO_RIGHT)
|
|
rgba[1] = GL_FALSE;
|
|
}
|
|
else
|
|
{
|
|
if(stereoFrame == STEREO_LEFT)
|
|
rgba[1] = rgba[2] = GL_FALSE;
|
|
else if(stereoFrame == STEREO_RIGHT)
|
|
{
|
|
rgba[0] = GL_FALSE;
|
|
|
|
if(colormode == MODE_RED_BLUE)
|
|
rgba[1] = GL_FALSE;
|
|
else if(colormode == MODE_RED_GREEN)
|
|
rgba[2] = GL_FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
====================
|
|
RE_BeginFrame
|
|
|
|
If running in stereo, RE_BeginFrame will be called twice
|
|
for each RE_EndFrame
|
|
====================
|
|
*/
|
|
void RE_BeginFrame( stereoFrame_t stereoFrame ) {
|
|
drawBufferCommand_t *cmd = NULL;
|
|
colorMaskCommand_t *colcmd = NULL;
|
|
|
|
if ( !tr.registered ) {
|
|
return;
|
|
}
|
|
glState.finishCalled = qfalse;
|
|
|
|
tr.frameCount++;
|
|
tr.frameSceneNum = 0;
|
|
|
|
//
|
|
// do overdraw measurement
|
|
//
|
|
if ( r_measureOverdraw->integer )
|
|
{
|
|
if ( glConfig.stencilBits < 4 )
|
|
{
|
|
ri.Printf( PRINT_ALL, "Warning: not enough stencil bits to measure overdraw: %d\n", glConfig.stencilBits );
|
|
ri.Cvar_Set( "r_measureOverdraw", "0" );
|
|
r_measureOverdraw->modified = qfalse;
|
|
}
|
|
else if ( r_shadows->integer == 2 )
|
|
{
|
|
ri.Printf( PRINT_ALL, "Warning: stencil shadows and overdraw measurement are mutually exclusive\n" );
|
|
ri.Cvar_Set( "r_measureOverdraw", "0" );
|
|
r_measureOverdraw->modified = qfalse;
|
|
}
|
|
else
|
|
{
|
|
R_IssuePendingRenderCommands();
|
|
qglEnable( GL_STENCIL_TEST );
|
|
qglStencilMask( ~0U );
|
|
qglClearStencil( 0U );
|
|
qglStencilFunc( GL_ALWAYS, 0U, ~0U );
|
|
qglStencilOp( GL_KEEP, GL_INCR, GL_INCR );
|
|
}
|
|
r_measureOverdraw->modified = qfalse;
|
|
}
|
|
else
|
|
{
|
|
// this is only reached if it was on and is now off
|
|
if ( r_measureOverdraw->modified ) {
|
|
R_IssuePendingRenderCommands();
|
|
qglDisable( GL_STENCIL_TEST );
|
|
}
|
|
r_measureOverdraw->modified = qfalse;
|
|
}
|
|
|
|
//
|
|
// texturemode stuff
|
|
//
|
|
if ( r_textureMode->modified ) {
|
|
R_IssuePendingRenderCommands();
|
|
GL_TextureMode( r_textureMode->string );
|
|
r_textureMode->modified = qfalse;
|
|
}
|
|
|
|
//
|
|
// gamma stuff
|
|
//
|
|
if ( r_gamma->modified ) {
|
|
r_gamma->modified = qfalse;
|
|
|
|
R_IssuePendingRenderCommands();
|
|
R_SetColorMappings();
|
|
}
|
|
|
|
// check for errors
|
|
if ( !r_ignoreGLErrors->integer )
|
|
{
|
|
int err;
|
|
|
|
R_IssuePendingRenderCommands();
|
|
if ((err = qglGetError()) != GL_NO_ERROR)
|
|
ri.Error(ERR_FATAL, "RE_BeginFrame() - glGetError() failed (0x%x)!", err);
|
|
}
|
|
|
|
if (glConfig.stereoEnabled) {
|
|
if( !(cmd = R_GetCommandBuffer(sizeof(*cmd))) )
|
|
return;
|
|
|
|
cmd->commandId = RC_DRAW_BUFFER;
|
|
|
|
if ( stereoFrame == STEREO_LEFT ) {
|
|
cmd->buffer = (int)GL_BACK_LEFT;
|
|
} else if ( stereoFrame == STEREO_RIGHT ) {
|
|
cmd->buffer = (int)GL_BACK_RIGHT;
|
|
} else {
|
|
ri.Error( ERR_FATAL, "RE_BeginFrame: Stereo is enabled, but stereoFrame was %i", stereoFrame );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(r_anaglyphMode->integer)
|
|
{
|
|
if(r_anaglyphMode->modified)
|
|
{
|
|
// clear both, front and backbuffer.
|
|
qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
backEnd.colorMask[0] = GL_FALSE;
|
|
backEnd.colorMask[1] = GL_FALSE;
|
|
backEnd.colorMask[2] = GL_FALSE;
|
|
backEnd.colorMask[3] = GL_FALSE;
|
|
|
|
if (glRefConfig.framebufferObject)
|
|
{
|
|
// clear all framebuffers
|
|
if (tr.msaaResolveFbo)
|
|
{
|
|
FBO_Bind(tr.msaaResolveFbo);
|
|
qglClear(GL_COLOR_BUFFER_BIT);
|
|
}
|
|
|
|
if (tr.renderFbo)
|
|
{
|
|
FBO_Bind(tr.renderFbo);
|
|
qglClear(GL_COLOR_BUFFER_BIT);
|
|
}
|
|
|
|
FBO_Bind(NULL);
|
|
}
|
|
|
|
qglDrawBuffer(GL_FRONT);
|
|
qglClear(GL_COLOR_BUFFER_BIT);
|
|
qglDrawBuffer(GL_BACK);
|
|
qglClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
r_anaglyphMode->modified = qfalse;
|
|
}
|
|
|
|
if(stereoFrame == STEREO_LEFT)
|
|
{
|
|
if( !(cmd = R_GetCommandBuffer(sizeof(*cmd))) )
|
|
return;
|
|
|
|
if( !(colcmd = R_GetCommandBuffer(sizeof(*colcmd))) )
|
|
return;
|
|
}
|
|
else if(stereoFrame == STEREO_RIGHT)
|
|
{
|
|
clearDepthCommand_t *cldcmd;
|
|
|
|
if( !(cldcmd = R_GetCommandBuffer(sizeof(*cldcmd))) )
|
|
return;
|
|
|
|
cldcmd->commandId = RC_CLEARDEPTH;
|
|
|
|
if( !(colcmd = R_GetCommandBuffer(sizeof(*colcmd))) )
|
|
return;
|
|
}
|
|
else
|
|
ri.Error( ERR_FATAL, "RE_BeginFrame: Stereo is enabled, but stereoFrame was %i", stereoFrame );
|
|
|
|
R_SetColorMode(colcmd->rgba, stereoFrame, r_anaglyphMode->integer);
|
|
colcmd->commandId = RC_COLORMASK;
|
|
}
|
|
else
|
|
{
|
|
if(stereoFrame != STEREO_CENTER)
|
|
ri.Error( ERR_FATAL, "RE_BeginFrame: Stereo is disabled, but stereoFrame was %i", stereoFrame );
|
|
|
|
if( !(cmd = R_GetCommandBuffer(sizeof(*cmd))) )
|
|
return;
|
|
}
|
|
|
|
if(cmd)
|
|
{
|
|
cmd->commandId = RC_DRAW_BUFFER;
|
|
|
|
if(r_anaglyphMode->modified)
|
|
{
|
|
qglColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
|
|
backEnd.colorMask[0] = 0;
|
|
backEnd.colorMask[1] = 0;
|
|
backEnd.colorMask[2] = 0;
|
|
backEnd.colorMask[3] = 0;
|
|
r_anaglyphMode->modified = qfalse;
|
|
}
|
|
|
|
if (!Q_stricmp(r_drawBuffer->string, "GL_FRONT"))
|
|
cmd->buffer = (int)GL_FRONT;
|
|
else
|
|
cmd->buffer = (int)GL_BACK;
|
|
}
|
|
}
|
|
|
|
tr.refdef.stereoFrame = stereoFrame;
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
RE_EndFrame
|
|
|
|
Returns the number of msec spent in the back end
|
|
=============
|
|
*/
|
|
void RE_EndFrame( int *frontEndMsec, int *backEndMsec ) {
|
|
swapBuffersCommand_t *cmd;
|
|
|
|
if ( !tr.registered ) {
|
|
return;
|
|
}
|
|
cmd = R_GetCommandBufferReserved( sizeof( *cmd ), 0 );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_SWAP_BUFFERS;
|
|
|
|
R_IssueRenderCommands( qtrue );
|
|
|
|
R_InitNextFrame();
|
|
|
|
if ( frontEndMsec ) {
|
|
*frontEndMsec = tr.frontEndMsec;
|
|
}
|
|
tr.frontEndMsec = 0;
|
|
if ( backEndMsec ) {
|
|
*backEndMsec = backEnd.pc.msec;
|
|
}
|
|
backEnd.pc.msec = 0;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
RE_TakeVideoFrame
|
|
=============
|
|
*/
|
|
void RE_TakeVideoFrame( int width, int height,
|
|
byte *captureBuffer, byte *encodeBuffer, qboolean motionJpeg )
|
|
{
|
|
videoFrameCommand_t *cmd;
|
|
|
|
if( !tr.registered ) {
|
|
return;
|
|
}
|
|
|
|
cmd = R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if( !cmd ) {
|
|
return;
|
|
}
|
|
|
|
cmd->commandId = RC_VIDEOFRAME;
|
|
|
|
cmd->width = width;
|
|
cmd->height = height;
|
|
cmd->captureBuffer = captureBuffer;
|
|
cmd->encodeBuffer = encodeBuffer;
|
|
cmd->motionJpeg = motionJpeg;
|
|
}
|