mirror of
https://github.com/DrBeef/JKXR.git
synced 2024-12-11 13:11:58 +00:00
62556d9b6b
and head tacking seems to work
531 lines
12 KiB
C++
531 lines
12 KiB
C++
/*
|
|
===========================================================================
|
|
Copyright (C) 1999 - 2005, Id Software, Inc.
|
|
Copyright (C) 2000 - 2013, Raven Software, Inc.
|
|
Copyright (C) 2001 - 2013, Activision, Inc.
|
|
Copyright (C) 2005 - 2015, ioquake3 contributors
|
|
Copyright (C) 2013 - 2015, OpenJK contributors
|
|
|
|
This file is part of the OpenJK source code.
|
|
|
|
OpenJK is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU General Public License version 2 as
|
|
published by the Free Software Foundation.
|
|
|
|
This program 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 this program; if not, see <http://www.gnu.org/licenses/>.
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../server/exe_headers.h"
|
|
|
|
#include "tr_local.h"
|
|
|
|
|
|
/*
|
|
=====================
|
|
R_PerformanceCounters
|
|
=====================
|
|
*/
|
|
void R_PerformanceCounters( void ) {
|
|
if ( !r_speeds->integer ) {
|
|
// clear the counters even if we aren't printing
|
|
memset( &tr.pc, 0, sizeof( tr.pc ) );
|
|
memset( &backEnd.pc, 0, sizeof( backEnd.pc ) );
|
|
return;
|
|
}
|
|
|
|
if (r_speeds->integer == 1) {
|
|
const float texSize = R_SumOfUsedImages( qfalse )/(8*1048576.0f)*(r_texturebits->integer?r_texturebits->integer:glConfig.colorBits);
|
|
ri.Printf (PRINT_ALL, "%i/%i shdrs/srfs %i leafs %i vrts %i/%i tris %.2fMB tex %.2f dc\n",
|
|
backEnd.pc.c_shaders, backEnd.pc.c_surfaces, tr.pc.c_leafs, backEnd.pc.c_vertexes,
|
|
backEnd.pc.c_indexes/3, backEnd.pc.c_totalIndexes/3,
|
|
texSize, 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) {
|
|
const float texSize = R_SumOfUsedImages(qtrue) / (1048576.0f);
|
|
const float backBuff= glConfig.vidWidth * glConfig.vidHeight * glConfig.colorBits / (8.0f * 1024*1024);
|
|
const float depthBuff= glConfig.vidWidth * glConfig.vidHeight * glConfig.depthBits / (8.0f * 1024*1024);
|
|
const float stencilBuff= glConfig.vidWidth * glConfig.vidHeight * glConfig.stencilBits / (8.0f * 1024*1024);
|
|
ri.Printf (PRINT_ALL, "Tex MB %.2f + buffers %.2f MB = Total %.2fMB\n",
|
|
texSize, backBuff*2+depthBuff+stencilBuff, texSize+backBuff*2+depthBuff+stencilBuff);
|
|
}
|
|
|
|
memset( &tr.pc, 0, sizeof( tr.pc ) );
|
|
memset( &backEnd.pc, 0, sizeof( backEnd.pc ) );
|
|
}
|
|
|
|
/*
|
|
====================
|
|
R_IssueRenderCommands
|
|
====================
|
|
*/
|
|
void R_IssueRenderCommands( qboolean runPerformanceCounters ) {
|
|
renderCommandList_t *cmdList;
|
|
|
|
cmdList = &backEndData->commands;
|
|
|
|
// add an end-of-list command
|
|
byteAlias_t *ba = (byteAlias_t *)&cmdList->cmds[cmdList->used];
|
|
ba->ui = RC_END_OF_LIST;
|
|
|
|
// clear it out, in case this is a sync and not a buffer flip
|
|
cmdList->used = 0;
|
|
|
|
// at this point, the back end thread is idle, so it is ok
|
|
// to look at it's performance counters
|
|
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
|
|
============
|
|
*/
|
|
static 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 + sizeof( int ) + reservedBytes > MAX_RENDER_COMMANDS ) {
|
|
if ( bytes > MAX_RENDER_COMMANDS - (int)sizeof( int ) ) {
|
|
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
|
|
|
|
make sure there is enough command space
|
|
============
|
|
*/
|
|
static void *R_GetCommandBuffer( int bytes ) {
|
|
return R_GetCommandBufferReserved( bytes, PAD( sizeof( swapBuffersCommand_t ), sizeof(void *) ) );
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
R_AddDrawSurfCmd
|
|
|
|
=============
|
|
*/
|
|
void R_AddDrawSurfCmd( drawSurf_t *drawSurfs, int numDrawSurfs ) {
|
|
drawSurfsCommand_t *cmd;
|
|
|
|
cmd = (drawSurfsCommand_t *) 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;
|
|
}
|
|
|
|
|
|
/*
|
|
=============
|
|
RE_SetColor
|
|
|
|
Passing NULL will set the color to white
|
|
=============
|
|
*/
|
|
void RE_SetColor( const float *rgba ) {
|
|
setColorCommand_t *cmd;
|
|
|
|
if ( !tr.registered ) {
|
|
return;
|
|
}
|
|
cmd = (setColorCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_SET_COLOR;
|
|
if ( !rgba ) {
|
|
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 = (stretchPicCommand_t *) 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;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
RE_RotatePic
|
|
=============
|
|
*/
|
|
void RE_RotatePic ( float x, float y, float w, float h,
|
|
float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) {
|
|
rotatePicCommand_t *cmd;
|
|
|
|
if (!tr.registered) {
|
|
return;
|
|
}
|
|
cmd = (rotatePicCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_ROTATE_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;
|
|
cmd->a = a;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
RE_RotatePic2
|
|
=============
|
|
*/
|
|
void RE_RotatePic2 ( float x, float y, float w, float h,
|
|
float s1, float t1, float s2, float t2,float a, qhandle_t hShader ) {
|
|
rotatePicCommand_t *cmd;
|
|
|
|
if (!tr.registered) {
|
|
return;
|
|
}
|
|
|
|
cmd = (rotatePicCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_ROTATE_PIC2;
|
|
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;
|
|
cmd->a = a;
|
|
}
|
|
|
|
void RE_LAGoggles( void )
|
|
{
|
|
tr.refdef.rdflags |= (RDF_doLAGoggles|RDF_doFullbright);
|
|
tr.refdef.doLAGoggles = qtrue;
|
|
|
|
jk_fog_t *fog = &tr.world->fogs[tr.world->numfogs];
|
|
|
|
fog->parms.color[0] = 0.75f;
|
|
fog->parms.color[1] = 0.42f + Q_flrand(0.0f, 1.0f) * 0.025f;
|
|
fog->parms.color[2] = 0.07f;
|
|
fog->parms.depthForOpaque = 10000;
|
|
fog->colorInt = ColorBytes4(fog->parms.color[0], fog->parms.color[1], fog->parms.color[2], 1.0f);
|
|
fog->tcScale = 2.0f / ( fog->parms.depthForOpaque * (1.0f + cos( tr.refdef.floatTime) * 0.1f));
|
|
}
|
|
|
|
void RE_RenderWorldEffects(void)
|
|
{
|
|
setModeCommand_t *cmd;
|
|
|
|
if (!tr.registered) {
|
|
return;
|
|
}
|
|
|
|
cmd = (setModeCommand_t *)R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_WORLD_EFFECTS;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
RE_Scissor
|
|
=============
|
|
*/
|
|
void RE_Scissor ( float x, float y, float w, float h)
|
|
{
|
|
scissorCommand_t *cmd;
|
|
|
|
if (!tr.registered) {
|
|
return;
|
|
}
|
|
|
|
cmd = (scissorCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_SCISSOR;
|
|
cmd->x = x;
|
|
cmd->y = y;
|
|
cmd->w = w;
|
|
cmd->h = h;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
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;
|
|
|
|
if ( !tr.registered ) {
|
|
return;
|
|
}
|
|
glState.finishCalled = qfalse;
|
|
|
|
tr.frameCount++;
|
|
tr.frameSceneNum = 0;
|
|
|
|
//
|
|
// do overdraw measurement
|
|
//
|
|
#ifndef HAVE_GLES
|
|
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;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// texturemode stuff
|
|
//
|
|
if ( r_textureMode->modified || r_ext_texture_filter_anisotropic->modified) {
|
|
R_IssuePendingRenderCommands();
|
|
GL_TextureMode( r_textureMode->string );
|
|
r_textureMode->modified = qfalse;
|
|
r_ext_texture_filter_anisotropic->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 ) {
|
|
Com_Error( ERR_FATAL, "RE_BeginFrame() - glGetError() failed (0x%x)!\n", err );
|
|
}
|
|
}
|
|
|
|
//
|
|
// draw buffer stuff
|
|
//
|
|
cmd = (drawBufferCommand_t *) R_GetCommandBuffer( sizeof( *cmd ) );
|
|
if ( !cmd ) {
|
|
return;
|
|
}
|
|
cmd->commandId = RC_DRAW_BUFFER;
|
|
|
|
{
|
|
if ( stereoFrame == STEREO_LEFT ) {
|
|
cmd->buffer = (int)0;
|
|
} else if ( stereoFrame == STEREO_RIGHT ) {
|
|
cmd->buffer = (int)1;
|
|
} else {
|
|
ri.Error( ERR_FATAL, "RE_BeginFrame: Stereo is enabled, but stereoFrame was %i", 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 = (swapBuffersCommand_t*)R_GetCommandBuffer(sizeof(*cmd));
|
|
if (!cmd) {
|
|
return;
|
|
}
|
|
|
|
cmd->commandId = RC_FLUSH;
|
|
|
|
R_IssueRenderCommands( qfalse );
|
|
|
|
// use the other buffers next frame, because another CPU
|
|
// may still be rendering into the current ones
|
|
R_InitNextFrame();
|
|
|
|
if (frontEndMsec) {
|
|
*frontEndMsec = tr.frontEndMsec;
|
|
}
|
|
tr.frontEndMsec = 0;
|
|
if (backEndMsec) {
|
|
*backEndMsec = backEnd.pc.msec;
|
|
}
|
|
backEnd.pc.msec = 0;
|
|
|
|
for(int i=0;i<MAX_LIGHT_STYLES;i++)
|
|
{
|
|
styleUpdated[i] = false;
|
|
}
|
|
}
|
|
|
|
void RE_SubmitStereoFrame( ) {
|
|
swapBuffersCommand_t *cmd;
|
|
|
|
if ( !tr.registered ) {
|
|
return;
|
|
}
|
|
|
|
cmd = (swapBuffersCommand_t*)R_GetCommandBuffer(sizeof(*cmd));
|
|
if (!cmd) {
|
|
return;
|
|
}
|
|
|
|
cmd->commandId = RC_SWAP_BUFFERS;
|
|
|
|
R_IssueRenderCommands( qtrue );
|
|
}
|