hermitworks/st
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
st/code/cgame/cg_draw.c
archive 1c7954095a as released 2008-04-04
2008-04-04 00:00:00 +00:00

1155 lines
26 KiB
C
Raw Blame History

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
Copyright (C) 2007 HermitWorks Entertainment Corporation
This file is part of the Space Trader source code.
The Space Trader 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.
The Space Trader 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 the Space Trader source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
#include "cg_local.h"
// cg_draw.c -- draw all of the graphical elements during
// active (after loading) gameplay
/*
================
CG_Draw3DModel
================
*/
void CG_Draw3DModel( float x, float y, float w, float h, qhandle_t model, qhandle_t skin, vec3_t origin, vec3_t angles ) {
refdef_t refdef;
refEntity_t ent;
if ( !cg_draw3dIcons.integer || !cg_drawIcons.integer ) {
return;
}
CG_AdjustFrom640( &x, &y, &w, &h );
memset( &refdef, 0, sizeof( refdef ) );
memset( &ent, 0, sizeof( ent ) );
AnglesToAxis( angles, ent.axis );
VectorCopy( origin, ent.origin );
ent.hModel = model;
ent.customSkin = skin;
ent.renderfx = RF_NOSHADOW; // no stencil shadows
refdef.rdflags = RDF_NOWORLDMODEL;
AxisClear( refdef.viewaxis );
refdef.fov_x = 30;
refdef.fov_y = 30;
refdef.x = x;
refdef.y = y;
refdef.width = w;
refdef.height = h;
refdef.time = cg.time;
trap_R_ClearScene();
trap_R_AddRefEntityToScene( &ent );
trap_R_RenderScene( &refdef );
}
/*
================
CG_DrawHead
Used for both the status bar and the scoreboard
================
*/
void CG_DrawHead( float x, float y, float w, float h, int clientNum, vec3_t headAngles )
{
// clipHandle_t cm;
clientInfo_t *ci;
// float len;
// vec3_t origin;
// vec3_t mins, maxs;
REF_PARAM( headAngles );
ci = &cgs.clientinfo[ clientNum ];
//Disabled to just draw the icon for the players heads
/* if ( cg_draw3dIcons.integer ) {
cm = ci->headModel;
if ( !cm ) {
return;
}
// offset the origin y and z to center the head
trap_R_ModelBounds( cm, mins, maxs );
origin[2] = -0.5 * ( mins[2] + maxs[2] );
origin[1] = 0.5 * ( mins[1] + maxs[1] );
// calculate distance so the head nearly fills the box
// assume heads are taller than wide
len = 0.7 * ( maxs[2] - mins[2] );
origin[0] = len / 0.268; // len / tan( fov/2 )
// allow per-model tweaking
VectorAdd( origin, ci->headOffset, origin );
CG_Draw3DModel( x, y, w, h, ci->headModel, ci->headSkin, origin, headAngles );
} else if ( cg_drawIcons.integer ) {*/
CG_DrawPic( x, y, w, h, ci->modelIcon );
//}
// if they are deferred, draw a cross out
if ( ci->deferred ) {
CG_DrawPic( x, y, w, h, cgs.media.deferShader );
}
}
/*
===========================================================================================
UPPER RIGHT CORNER
===========================================================================================
*/
/*
================
CG_DrawAttacker
================
*/
static float CG_DrawAttacker( float y ) {
int t;
float size;
vec3_t angles;
const char *info;
const char *name;
int clientNum;
if ( cg.predictedPlayerState.stats[STAT_HEALTH] <= 0 ) {
return y;
}
if ( !cg.attackerTime ) {
return y;
}
clientNum = cg.predictedPlayerState.persistant[PERS_ATTACKER];
if ( clientNum < 0 || clientNum >= MAX_CLIENTS || clientNum == cg.snap->ps.clientNum ) {
return y;
}
t = cg.time - cg.attackerTime;
if ( t > ATTACKER_HEAD_TIME ) {
cg.attackerTime = 0;
return y;
}
size = ICON_SIZE * 1.25;
angles[PITCH] = 0;
angles[YAW] = 180;
angles[ROLL] = 0;
CG_DrawHead( 640 - size, y, size, size, clientNum, angles );
info = CG_ConfigString( CS_PLAYERS + clientNum );
name = Info_ValueForKey( info, "n" );
y += size;
// CG_DrawBigString( 640 - ( Q_PrintStrlen( name ) * BIGCHAR_WIDTH), y, name, 0.5 );
return y + BIGCHAR_HEIGHT + 2;
}
/*
===============
CG_DamageView
===============
*/
static void CG_DrawDamageView( void ) {
float color[4] = {1.0f, 1.0f, 1.0f, 1.0f};
float left, right, top, bottom, w, h;
int health = cg.predictedPlayerState.stats[STAT_HEALTH];
if ( health > 40 || health <= 0)
return;
color[3] = 1.0f - (float)health/100;
trap_R_SetColor( color );
left = 0.0f;
right = 640.0f * cgDC.glconfig.xscale + 2.0f*cgDC.glconfig.xbias;
top = 0.0f;
bottom = 480.0f * cgDC.glconfig.yscale;
w = 40.0f * cgDC.glconfig.xscale;
h = 40.0f * cgDC.glconfig.yscale;
// left
trap_R_DrawStretchPic( left, top, w, bottom-top, 0.0f, 0.0f, 1.0f, 1.0f, cgs.media.viewDamagedShader );
// right
trap_R_DrawStretchPic( right-w, top, w, bottom-top, 1.0f, 0.0f, 0.0f, 1.0f, cgs.media.viewDamagedShader );
// top
trap_R_DrawStretchPic( left, top, right-left, h, 0.0f, 0.0f, 1.0f, 1.0f, cgs.media.viewDamagedShader_vert );
// bottom
trap_R_DrawStretchPic( left, bottom-h, right-left, h, 1.0f, 1.0f, 0.0f, 0.0f, cgs.media.viewDamagedShader_vert );
}
/*
==================
CG_DrawSnapshot
==================
*/
static float CG_DrawSnapshot( float y ) {
char *s;
rectDef_t r;
s = va( "time:%i snap:%i cmd:%i", cg.snap->serverTime, cg.latestSnapshotNum, cgs.serverCommandSequence );
r.x = 0.0f;
r.y = y + 2.0f;
r.w = 630.0f;
r.h = 24.0f;
trap_R_RenderText( &r, 0.3f, colorWhite, s, -1, TEXT_ALIGN_RIGHT, TEXT_ALIGN_CENTER, TEXT_STYLE_ITALIC, cgs.media.font, -1, 0 );
return y + 24.0f;
}
/*
==================
CG_DrawFPS
==================
*/
#define FPS_FRAMES 16
static float CG_DrawFPS( float y ) {
char *s;
static int previousTimes[FPS_FRAMES];
static int index;
int i, total;
int fps;
static int previous;
int t, frameTime;
// don't use serverTime, because that will be drifting to
// correct for internet lag changes, timescales, timedemos, etc
t = trap_Milliseconds();
frameTime = t - previous;
previous = t;
previousTimes[index % FPS_FRAMES] = frameTime;
index++;
if ( index > FPS_FRAMES ) {
// average multiple frames together to smooth changes out a bit
total = 0;
for ( i = 0 ; i < FPS_FRAMES ; i++ ) {
total += previousTimes[i];
}
if ( !total ) {
total = 1;
}
fps = 1000 * FPS_FRAMES / total;
s = va( "%i fps", fps );
{
rectDef_t r;
r.x = 540.0f;
r.y = y + 2.0f;
r.w = 80.0f;
r.h = 16.0f;
trap_R_RenderText( &r, 0.3f, colorWhite, s, -1, TEXT_ALIGN_RIGHT, TEXT_ALIGN_CENTER, 3, cgs.media.font, -1, 0 );
}
}
return y + BIGCHAR_HEIGHT + 4;
}
static void CG_DrawWaiting( ) {
int i, t;
static int waiting_clients;
for (i=0,t=0; i < MAX_PLAYERS; i++ )
{
if ( cgs.clientinfo[i].infoValid == qtrue && cg_entities[i].currentState.eFlags & EF_CONNECTION )
{
t |= (1 << i );
}
}
if ( t != waiting_clients ) {
trap_Cmd_ExecuteText( EXEC_NOW, va("st_lagging %d", t ) );
waiting_clients = t;
}
}
/*
=================
CG_DrawTimer
=================
*/
static float CG_DrawTimer( float y ) {
char *s;
rectDef_t r;
int mins, seconds, tens;
int msec;
msec = cg.time - cgs.levelStartTime;
seconds = msec / 1000;
mins = seconds / 60;
seconds -= mins * 60;
tens = seconds / 10;
seconds -= tens * 10;
s = va( "%i:%i%i", mins, tens, seconds );
r.x = 0.0f;
r.y = y + 2.0f;
r.w = 630.0f;
r.h = 24.0f;
trap_R_RenderText( &r, 0.3f, colorWhite, s, -1, TEXT_ALIGN_RIGHT, TEXT_ALIGN_CENTER, TEXT_STYLE_ITALIC, cgs.media.font, -1, 0 );
return y + 24.0f;
}
/*
=====================
CG_DrawUpperRight
=====================
*/
static void CG_DrawUpperRight( void ) {
float y;
y = 96.0f;
if ( cg_drawSnapshot.integer ) {
y = CG_DrawSnapshot( y );
}
if ( cg_drawFPS.integer ) {
y = CG_DrawFPS( y );
}
if ( cg_drawTimer.integer ) {
y = CG_DrawTimer( y );
}
if ( cg_drawAttacker.integer ) {
y = CG_DrawAttacker( y );
}
}
/*
===============================================================================
LAGOMETER
===============================================================================
*/
#define LAG_SAMPLES 128
typedef struct {
int frameSamples[LAG_SAMPLES];
int frameCount;
int snapshotFlags[LAG_SAMPLES];
int snapshotSamples[LAG_SAMPLES];
int snapshotCount;
} lagometer_t;
lagometer_t lagometer;
/*
==============
CG_AddLagometerFrameInfo
Adds the current interpolate / extrapolate bar for this frame
==============
*/
void CG_AddLagometerFrameInfo( void ) {
int offset;
offset = cg.time - cg.latestSnapshotTime;
lagometer.frameSamples[ lagometer.frameCount & ( LAG_SAMPLES - 1) ] = offset;
lagometer.frameCount++;
}
/*
==============
CG_AddLagometerSnapshotInfo
Each time a snapshot is received, log its ping time and
the number of snapshots that were dropped before it.
Pass NULL for a dropped packet.
==============
*/
void CG_AddLagometerSnapshotInfo( snapshot_t *snap ) {
// dropped packet
if ( !snap ) {
lagometer.snapshotSamples[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = -1;
lagometer.snapshotCount++;
return;
}
// add this snapshot's info
lagometer.snapshotSamples[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = snap->ping;
lagometer.snapshotFlags[ lagometer.snapshotCount & ( LAG_SAMPLES - 1) ] = snap->snapFlags;
lagometer.snapshotCount++;
}
/*
==============
CG_DrawDisconnect
Should we draw something differnet for long lag vs no packets?
==============
*/
static void CG_DrawDisconnect( void ) {
float x, y;
int cmdNum;
usercmd_t cmd;
int seconds;
static qboolean show_lag=qfalse;
//int w; // bk010215 - FIXME char message[1024];
// draw the phone jack if we are completely past our buffers
cmdNum = trap_GetCurrentCmdNumber() - CMD_BACKUP + 1;
trap_GetUserCmd( cmdNum, &cmd );
if ( cmd.serverTime <= cg.snap->ps.commandTime
|| cmd.serverTime > cg.time ) { // special check for map_restart // bk 0102165 - FIXME
if (show_lag == qtrue ) {
show_lag = qfalse;
trap_Cmd_ExecuteText(EXEC_NOW, "st_lag 0");
}
return;
}
seconds = ( cmd.serverTime - cg.snap->ps.commandTime )/1000;
if (seconds >= 60 ) {
trap_Cmd_ExecuteText( EXEC_APPEND, "disconnect\n" );
}
if ( show_lag == qfalse && seconds > 5 ) {
show_lag = qtrue;
trap_Cmd_ExecuteText(EXEC_NOW, "st_lag 1");
}
// blink the icon
if ( ( cg.time >> 9 ) & 1 ) {
return;
}
x = 640 - 48;
y = 480 - 48;
CG_DrawPic( x, y, 48, 48, trap_R_RegisterShader("gfx/2d/net.tga" ) );
}
#define MAX_LAGOMETER_PING 900
#define MAX_LAGOMETER_RANGE 300
/*
==============
CG_DrawLagometer
==============
*/
static void CG_DrawLagometer( void ) {
int a, x, y, i;
float v;
float ax, ay, aw, ah, mid, range;
int color;
float vscale;
if ( !cg_lagometer.integer || cgs.localServer ) {
CG_DrawDisconnect();
return;
}
//
// draw the graph
//
x = 640 - 48;
y = 480 - 144;
trap_R_SetColor( NULL );
CG_DrawPic( x, y, 48, 48, cgs.media.lagometerShader );
ax = x;
ay = y;
aw = 48;
ah = 48;
CG_AdjustFrom640( &ax, &ay, &aw, &ah );
color = -1;
range = ah / 3;
mid = ay + range;
vscale = range / MAX_LAGOMETER_RANGE;
// draw the frame interpoalte / extrapolate graph
for ( a = 0 ; a < aw ; a++ ) {
i = ( lagometer.frameCount - 1 - a ) & (LAG_SAMPLES - 1);
v = lagometer.frameSamples[i];
v *= vscale;
if ( v > 0 ) {
if ( color != 1 ) {
color = 1;
trap_R_SetColor( g_color_table[ColorIndex(COLOR_YELLOW)] );
}
if ( v > range ) {
v = range;
}
trap_R_DrawStretchPic ( ax + aw - a, mid - v, 1, v, 0, 0, 0, 0, cgs.media.whiteShader );
} else if ( v < 0 ) {
if ( color != 2 ) {
color = 2;
trap_R_SetColor( g_color_table[ColorIndex(COLOR_BLUE)] );
}
v = -v;
if ( v > range ) {
v = range;
}
trap_R_DrawStretchPic( ax + aw - a, mid, 1, v, 0, 0, 0, 0, cgs.media.whiteShader );
}
}
// draw the snapshot latency / drop graph
range = ah / 2;
vscale = range / MAX_LAGOMETER_PING;
for ( a = 0 ; a < aw ; a++ ) {
i = ( lagometer.snapshotCount - 1 - a ) & (LAG_SAMPLES - 1);
v = lagometer.snapshotSamples[i];
if ( v > 0 ) {
if ( lagometer.snapshotFlags[i] & SNAPFLAG_RATE_DELAYED ) {
if ( color != 5 ) {
color = 5; // YELLOW for rate delay
trap_R_SetColor( g_color_table[ColorIndex(COLOR_YELLOW)] );
}
} else {
if ( color != 3 ) {
color = 3;
trap_R_SetColor( g_color_table[ColorIndex(COLOR_GREEN)] );
}
}
v = v * vscale;
if ( v > range ) {
v = range;
}
trap_R_DrawStretchPic( ax + aw - a, ay + ah - v, 1, v, 0, 0, 0, 0, cgs.media.whiteShader );
} else if ( v < 0 ) {
if ( color != 4 ) {
color = 4; // RED for dropped snapshots
trap_R_SetColor( g_color_table[ColorIndex(COLOR_RED)] );
}
trap_R_DrawStretchPic( ax + aw - a, ay + ah - range, 1, range, 0, 0, 0, 0, cgs.media.whiteShader );
}
}
trap_R_SetColor( NULL );
if ( cg_nopredict.integer || cg_synchronousClients.integer ) {
//CG_DrawBigString( ax, ay, "snc", 1.0 );
}
CG_DrawDisconnect();
}
/*
================================================================================
CROSSHAIR
================================================================================
*/
/*
=================
CG_DrawCrosshair
=================
*/
static void CG_DrawCrosshair(void) {
float w, h;
qhandle_t hShader;
float f;
float x, y;
float scale;
int ca;
vec4_t hcolor;
if ( !cg_drawCrosshair.integer ) {
return;
}
if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR) {
return;
}
if ( cg.renderingThirdPerson ) {
return;
}
// set color based on health
if ( cg_crosshairHealth.integer ) {
CG_ColorForHealth( hcolor );
trap_R_SetColor( hcolor );
} else {
hcolor[0] = cg_crosshairColorR.value;
hcolor[1] = cg_crosshairColorG.value;
hcolor[2] = cg_crosshairColorB.value;
hcolor[3] = cg_crosshairColorA.value;
trap_R_SetColor( hcolor);
}
w = h = cg_crosshairSize.value;
scale = cg.xyspeed / 100;
//never go below 1 for the scale so we don't make the crosshair disapear
if (scale < 2) scale = 2;
if (cg.predictedPlayerState.groundEntityNum != ENTITYNUM_NONE && cg.predictedPlayerState.pm_flags & PMF_DUCKED) scale = 1;
if ( cg.predictedPlayerState.weapon != WP_SHOTGUN ) {
w *= scale;
h *= scale;
} else {
w *= 2;
h *= 2;
}
// pulse the size of the crosshair when picking up items
f = cg.time - cg.itemPickupBlendTime;
if ( f > 0 && f < ITEM_BLOB_TIME ) {
f /= ITEM_BLOB_TIME;
w *= ( 1 + f );
h *= ( 1 + f );
}
x = cg_crosshairX.integer + 320.0f - (w)*0.5f;
y = cg_crosshairY.integer + 240.0f - (h)*0.5f;
CG_AdjustFrom640( &x, &y, &w, &h );
ca = cg_drawCrosshair.integer;
if (ca < 0)
{
ca = 0;
}
hShader = cgs.media.crosshairShader[ ca % NUM_CROSSHAIRS ];
//If (in hub) the last time we had a client under our cursor was less then 250 ms ago, change the crosshair, if in hostage, and the player is on the same team.
if( (cgs.gametype == GT_HUB || ( cgs.gametype == GT_HOSTAGE && cgs.clientinfo[cg.crosshairClientNum].team == cgs.clientinfo[cg.clientNum].team ) ) && cg.time - cg.crosshairClientTime < 250 && cgs.clientinfo[cg.crosshairClientNum].botSkill > 0 )
{
if( cg.crosshairClientDist < CHAT_DISTANCE )
{
// if npc is close enough show the talk icon...
hShader = cgs.media.crosshairTalk;
//if ( cg.time == cg.crosshairClientTime && cg.predictedPlayerState.weapon != WP_NONE )
// trap_SendClientCommand( "holster" );
} else {
return;
}
} else if (cgs.gametype == GT_HUB) {
return;
}
//if ( cg.time - cg.crosshairClientTime >=250 && cg.predictedPlayerState.weaponstate == WEAPON_HOLSTERED)
// trap_SendClientCommand( "unholster" );
trap_R_DrawStretchPic( x,y,w,h, 0, 0, 1, 1, hShader );
}
/*
=================
CG_ScanForCrosshairEntity
=================
*/
static void CG_ScanForCrosshairEntity( void ) {
trace_t trace;
vec3_t start, end;
int content;
VectorCopy( cg.refdef.vieworg, start );
VectorMA( start, 1e5f, cg.refdef.viewaxis[0], end );
CG_Trace( &trace, start, vec3_origin, vec3_origin, end, cg.snap->ps.clientNum, CONTENTS_SOLID|CONTENTS_BODY );
if ( trace.entityNum < MAX_CLIENTS ) {
// if the player is in fog, don't show it
content = trap_CM_PointContents( trace.endpos, 0 );
if ( !(content & CONTENTS_FOG) ) {
// notify ui for effects
if ( cg.crosshairClientNum != trace.entityNum ) {
trap_Cmd_ExecuteText( EXEC_NOW, va( "st_crosshair %d", trace.entityNum ) );
}
// update the fade timer
cg.crosshairClientNum = trace.entityNum;
cg.crosshairClientTime = cg.time;
cg.crosshairClientDist = 1e5f * trace.fraction;
return;
}
}
// notify ui that there is no client under the crosshair
if ( cg.crosshairClientTime > 0 && (cg.time - cg.crosshairClientTime) > 250 ) {
trap_Cmd_ExecuteText( EXEC_NOW, "st_crosshair -1" );
cg.crosshairClientTime = 0;
cg.crosshairClientNum = -1;
}
}
/*
=====================
CG_DrawCrosshairNames
=====================
*/
static void CG_DrawCrosshairNames( void ) {
//float *color;
//char *name;
if ( !cg_drawCrosshair.integer ) {
return;
}
if ( !cg_drawCrosshairNames.integer ) {
return;
}
if ( cg.renderingThirdPerson ) {
return;
}
// scan the known entities to see if the crosshair is sighted on one
CG_ScanForCrosshairEntity();
// draw the name of the player being looked at
#if 0
color = CG_FadeColor( cg.crosshairClientTime, 1000 );
if ( color )
{
rectDef_t r;
int botType;
r.x = 0.0f;
r.y = 190.0f;
r.w = 640.0f;
r.h = 24.0f;
botType = cgs.clientinfo[ cg.crosshairClientNum ].botType;
/*if ( botType == BOT_GUARD_EASY || botType == BOT_GUARD_MEDIUM || botType == BOT_GUARD_HARD )
name = "Guard";
else*/
name = cgs.clientinfo[ cg.crosshairClientNum ].name;
color[3] *= 0.5f;
trap_R_RenderText( &r,
0.3f,
color,
name,
-1,
TEXT_ALIGN_CENTER,
TEXT_ALIGN_CENTER,
TEXT_STYLE_SHADOWED,
cgs.media.font,
-1,
0 );
}
#endif
}
extern char* fn( int number, int flags );
static void CG_DrawHint( void ) {
rectDef_t r;
char s[ MAX_INFO_STRING ];
s[ 0 ] = '\0';
switch ( cgs.gametype )
{
case GT_ASSASSINATE:
{
r.x = 0.0f;
r.y = 140.0f;
r.w = 640.0f;
r.h = 24.0f;
if ( gsi.ASSASSINATE.dead_countdown > 0 ) {
fn_buffer( s, gsi.ASSASSINATE.dead_countdown, FN_TIME );
}
if ( gsi.ASSASSINATE.boss_escaping ) {
trap_SQL_Run( s, sizeof(s), cgs.media.CG_FUGITIVE_ESCAPE, 0,0,0 );
}
} break;
case GT_MOA:
{
r.x = 0.0f;
r.y = 140.0f;
r.w = 640.0f;
r.h = 24.0f;
if ( gsi.ASSASSINATE.dead_countdown > 0 ) {
fn_buffer( s, gsi.ASSASSINATE.dead_countdown, FN_TIME );
}
} break;
case GT_HUB:
{
r.x = 32.0f;
r.y = 20.0f;
r.w = 632.0f;
r.h = 30.0f;
if ( cg.crosshairClientNum >= MAX_PLAYERS && cg.crosshairClientNum < MAX_CLIENTS && cg.crosshairClientDist < 90.0f && cg.crosshairClientTime + 200 > cg.time )
trap_SQL_Run( s, sizeof(s), cgs.media.CG_INTERACT_HINT, 0,0,0 );
else
trap_SQL_Run( s, sizeof(s), cgs.media.CG_EXPLORE_HINT, 0,0,0 );
} break;
}
if ( s[0] )
{
vec4_t color = { 1.0f, 1.0f, 1.0f, 1.0f };
color[ 3 ] = 0.75f+0.25f*sinf( ((float)cgDC.realTime) / 140.0f );
trap_R_RenderText( &r,
0.35f,
color,
s,
-1,
TEXT_ALIGN_CENTER,
TEXT_ALIGN_CENTER,
TEXT_STYLE_SHADOWED | TEXT_STYLE_ITALIC,
cgs.media.font,
-1,
0 );
}
}
//==============================================================================
/*
=================
CG_DrawSpectator
=================
*/
static void CG_DrawSpectator(void) {
char s[ 255 ];
rectDef_t r;
trap_SQL_Run( s, sizeof(s), cgs.media.CG_NOMORECHANCES, 0,0,0 );
r.x = 0.0f;
r.y = 448.0f;
r.w = 640.0f;
r.h = 24.0f;
if ( s[0] )
{
vec4_t color = { 1.0f, 1.0f, 1.0f, 1.0f };
color[ 3 ] = 0.75f+0.25f*sinf( ((float)cgDC.realTime) / 140.0f );
trap_R_RenderText( &r,
0.35f,
color,
s,
-1,
TEXT_ALIGN_CENTER,
TEXT_ALIGN_CENTER,
TEXT_STYLE_SHADOWED | TEXT_STYLE_ITALIC,
cgs.media.font,
-1,
0 );
}
}
static qboolean CG_DrawScoreboard() {
static qboolean firstTime = qtrue;
float fade, *fadeColor;
if (cg_paused.integer) {
cg.deferredPlayerLoading = 0;
firstTime = qtrue;
return qfalse;
}
// should never happen in Team Arena
if (cgs.gametype == GT_SINGLE_PLAYER && cg.predictedPlayerState.pm_type == PM_INTERMISSION ) {
cg.deferredPlayerLoading = 0;
firstTime = qtrue;
return qfalse;
}
// don't draw scoreboard during death while warmup up
if ( cg.warmup && !cg.showScores ) {
return qfalse;
}
//no scoreboard if we are in the hub gametype
if (cgs.gametype == GT_HUB) return qfalse;
if ( cg.showScores ||
cg.predictedPlayerState.pm_type == PM_DEAD ||
cg.predictedPlayerState.pm_type == PM_INTERMISSION ) {
fade = 1.0;
fadeColor = colorWhite;
} else {
fadeColor = CG_FadeColor( cg.scoreFadeTime, FADE_TIME );
if ( !fadeColor ) {
// next time scoreboard comes up, don't print killer
cg.deferredPlayerLoading = 0;
cg.killerName[0] = 0;
firstTime = qtrue;
return qfalse;
}
fade = *fadeColor;
}
// load any models that have been deferred
if ( ++cg.deferredPlayerLoading > 10 ) {
CG_LoadDeferredPlayers();
}
return qtrue;
}
/*
=================
CG_DrawIntermission
=================
*/
static void CG_DrawIntermission( void ) {
cg.scoreFadeTime = cg.time;
cg.scoreBoardShowing = CG_DrawScoreboard();
}
/*
=================
CG_DrawWarmup
=================
*/
static void CG_DrawWarmup( void ) {
}
//==================================================================================
/*
=================
CG_Draw2D
=================
*/
static void CG_Draw2D( void )
{
int ui_active = trap_Key_GetCatcher() & KEYCATCH_UI;
if( !cg.snap )
return;
// if we are taking a levelshot for the menu, don't draw anything
if ( cg.levelShot ) {
return;
}
if ( cg_draw2D.integer == 0 ) {
return;
}
if ( cg_cubemap.integer != 0 ) { //no 2d when drawing cubemaps
return;
}
if ( cg.snap->ps.pm_type == PM_INTERMISSION ) {
CG_DrawIntermission();
return;
}
if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR ) {
if ( !ui_active )
{
CG_DrawSpectator();
CG_DrawCrosshairNames();
CG_DrawCrosshair();
}
} else {
// don't draw any status if dead or the scoreboard is being explicitly shown
if ( !cg.showScores && cg.snap->ps.stats[STAT_HEALTH] > 0 ) {
if ( cg_drawStatus.integer )
{
//if ( !ui_active )
// Menu_PaintAll();
}
//Never draw the out of ammo warnings any more
//CG_DrawAmmoWarning();
if ( !ui_active )
{
CG_DrawCrosshairNames();
CG_DrawCrosshair();
CG_DrawWeaponSelect();
CG_DrawHint();
if ( cg.snap->ps.pm_flags & PMF_FOLLOW ) {
CG_DrawSpectator();
}
}
}
}
CG_DrawLagometer();
if (!cg_paused.integer) {
CG_DrawUpperRight();
CG_DrawWaiting();
}
if ( cg.snap->ps.pm_flags & PMF_FOLLOW )
{
CG_DrawWarmup();
}
CG_DrawDamageView();
// don't draw center string if scoreboard is up
cg.scoreBoardShowing = CG_DrawScoreboard();
}
/*
=====================
CG_DrawActive
Perform all drawing needed to completely fill the screen
=====================
*/
void CG_DrawActive( stereoFrame_t stereoView ) {
float separation;
vec3_t baseOrg;
// optionally draw the info screen instead
if ( !cg.snap ) {
//CG_DrawInformation();
return;
}
switch( stereoView )
{
case STEREO_CENTER:
separation = 0;
break;
case STEREO_LEFT:
separation = -cg_stereoSeparation.value / 2;
break;
case STEREO_RIGHT:
separation = cg_stereoSeparation.value / 2;
break;
default:
separation = 0;
CG_Error( "CG_DrawActive: Undefined stereoView" );
}
// clear around the rendered view if sized down
//CG_TileClear();
// offset vieworg appropriately if we're doing stereo separation
VectorCopy( cg.refdef.vieworg, baseOrg );
if ( separation != 0 ) {
VectorMA( cg.refdef.vieworg, -separation, cg.refdef.viewaxis[1], cg.refdef.vieworg );
}
switch ( cg_cubemap.integer )
{
case 1: //up
cg.refdefViewAngles[PITCH]-=90;
break;
case 2: //down
cg.refdefViewAngles[PITCH]+=90;
break;
case 3: //left
cg.refdefViewAngles[YAW]+=90;
break;
case 4: //right
cg.refdefViewAngles[YAW]-=90;
break;
case 5: //forward
break;
case 6: //back
cg.refdefViewAngles[YAW]-=180;
break;
}
if ( cg_cubemap.integer != 0 )
{
AnglesToAxis(cg.refdefViewAngles, cg.refdef.viewaxis);
}
// draw 3D view
trap_R_RenderScene( &cg.refdef );
// restore original viewpoint if running stereo
if ( separation != 0 ) {
VectorCopy( baseOrg, cg.refdef.vieworg );
}
}
void CG_DrawOverlays( int serverTime, stereoFrame_t stereoView, qboolean demoPlayback )
{
REF_PARAM( serverTime );
REF_PARAM( stereoView );
REF_PARAM( demoPlayback );
// draw status bar and other floating elements
CG_Draw2D();
// fade in screen
if ( 0 )
{
int t = cg.time - cgs.levelStartTime;
if ( t < 3000 )
{
float c[4];
float f;
c[ 0 ] = c[ 1 ] = c[ 2] = 0.0f;
f = (float)t / 3000.0f;
c[ 3 ] = 1.0f - (f*f);
trap_R_SetColor( c );
trap_R_DrawStretchPic( 0.0f, 0.0f, 640.0f * cgDC.glconfig.xscale, 480.0f * cgDC.glconfig.yscale, 0.0f, 0.0f, 1.0f, 1.0f, cgs.media.whiteShader );
}
}
}
Reference in a new issue View git blame Copy permalink