cg_draw.c

Go to the documentation of this file.

/*
===========================================================================
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 Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/
//
// cg_draw.c -- draw all of the graphical elements during
// active (after loading) gameplay

#include "cg_local.h"

#ifdef MISSIONPACK
#include "../ui/ui_shared.h"

// used for scoreboard
extern displayContextDef_t cgDC;
menuDef_t *menuScoreboard = NULL;
#else
int drawTeamOverlayModificationCount = -1;
#endif

int sortedTeamPlayers[TEAM_MAXOVERLAY];
int numSortedTeamPlayers;

char systemChat[256];
char teamChat1[256];
char teamChat2[256];

#ifdef MISSIONPACK

int CG_Text_Width(const char *text, float scale, int limit) {
  int count,len;
    float out;
    glyphInfo_t *glyph;
    float useScale;
// FIXME: see ui_main.c, same problem
//  const unsigned char *s = text;
    const char *s = text;
    fontInfo_t *font = &cgDC.Assets.textFont;
    if (scale <= cg_smallFont.value) {
        font = &cgDC.Assets.smallFont;
    } else if (scale > cg_bigFont.value) {
        font = &cgDC.Assets.bigFont;
    }
    useScale = scale * font->glyphScale;
  out = 0;
  if (text) {
    len = strlen(text);
        if (limit > 0 && len > limit) {
            len = limit;
        }
        count = 0;
        while (s && *s && count < len) {
            if ( Q_IsColorString(s) ) {
                s += 2;
                continue;
            } else {
                glyph = &font->glyphs[(int)*s]; // TTimo: FIXME: getting nasty warnings without the cast, hopefully this doesn't break the VM build
                out += glyph->xSkip;
                s++;
                count++;
            }
    }
  }
  return out * useScale;
}

int CG_Text_Height(const char *text, float scale, int limit) {
  int len, count;
    float max;
    glyphInfo_t *glyph;
    float useScale;
// TTimo: FIXME
//  const unsigned char *s = text;
    const char *s = text;
    fontInfo_t *font = &cgDC.Assets.textFont;
    if (scale <= cg_smallFont.value) {
        font = &cgDC.Assets.smallFont;
    } else if (scale > cg_bigFont.value) {
        font = &cgDC.Assets.bigFont;
    }
    useScale = scale * font->glyphScale;
  max = 0;
  if (text) {
    len = strlen(text);
        if (limit > 0 && len > limit) {
            len = limit;
        }
        count = 0;
        while (s && *s && count < len) {
            if ( Q_IsColorString(s) ) {
                s += 2;
                continue;
            } else {
                glyph = &font->glyphs[(int)*s]; // TTimo: FIXME: getting nasty warnings without the cast, hopefully this doesn't break the VM build
          if (max < glyph->height) {
              max = glyph->height;
              }
                s++;
                count++;
            }
    }
  }
  return max * useScale;
}

void CG_Text_PaintChar(float x, float y, float width, float height, float scale, float s, float t, float s2, float t2, qhandle_t hShader) {
  float w, h;
  w = width * scale;
  h = height * scale;
  CG_AdjustFrom640( &x, &y, &w, &h );
  trap_R_DrawStretchPic( x, y, w, h, s, t, s2, t2, hShader );
}

void CG_Text_Paint(float x, float y, float scale, vec4_t color, const char *text, float adjust, int limit, int style) {
  int len, count;
    vec4_t newColor;
    glyphInfo_t *glyph;
    float useScale;
    fontInfo_t *font = &cgDC.Assets.textFont;
    if (scale <= cg_smallFont.value) {
        font = &cgDC.Assets.smallFont;
    } else if (scale > cg_bigFont.value) {
        font = &cgDC.Assets.bigFont;
    }
    useScale = scale * font->glyphScale;
  if (text) {
// TTimo: FIXME
//      const unsigned char *s = text;
        const char *s = text;
        trap_R_SetColor( color );
        memcpy(&newColor[0], &color[0], sizeof(vec4_t));
    len = strlen(text);
        if (limit > 0 && len > limit) {
            len = limit;
        }
        count = 0;
        while (s && *s && count < len) {
            glyph = &font->glyphs[(int)*s]; // TTimo: FIXME: getting nasty warnings without the cast, hopefully this doesn't break the VM build
      //int yadj = Assets.textFont.glyphs[text[i]].bottom + Assets.textFont.glyphs[text[i]].top;
      //float yadj = scale * (Assets.textFont.glyphs[text[i]].imageHeight - Assets.textFont.glyphs[text[i]].height);
            if ( Q_IsColorString( s ) ) {
                memcpy( newColor, g_color_table[ColorIndex(*(s+1))], sizeof( newColor ) );
                newColor[3] = color[3];
                trap_R_SetColor( newColor );
                s += 2;
                continue;
            } else {
                float yadj = useScale * glyph->top;
                if (style == ITEM_TEXTSTYLE_SHADOWED || style == ITEM_TEXTSTYLE_SHADOWEDMORE) {
                    int ofs = style == ITEM_TEXTSTYLE_SHADOWED ? 1 : 2;
                    colorBlack[3] = newColor[3];
                    trap_R_SetColor( colorBlack );
                    CG_Text_PaintChar(x + ofs, y - yadj + ofs, 
                                                        glyph->imageWidth,
                                                        glyph->imageHeight,
                                                        useScale, 
                                                        glyph->s,
                                                        glyph->t,
                                                        glyph->s2,
                                                        glyph->t2,
                                                        glyph->glyph);
                    colorBlack[3] = 1.0;
                    trap_R_SetColor( newColor );
                }
                CG_Text_PaintChar(x, y - yadj, 
                                                    glyph->imageWidth,
                                                    glyph->imageHeight,
                                                    useScale, 
                                                    glyph->s,
                                                    glyph->t,
                                                    glyph->s2,
                                                    glyph->t2,
                                                    glyph->glyph);
                // CG_DrawPic(x, y - yadj, scale * cgDC.Assets.textFont.glyphs[text[i]].imageWidth, scale * cgDC.Assets.textFont.glyphs[text[i]].imageHeight, cgDC.Assets.textFont.glyphs[text[i]].glyph);
                x += (glyph->xSkip * useScale) + adjust;
                s++;
                count++;
            }
    }
      trap_R_SetColor( NULL );
  }
}


#endif

/*
==============
CG_DrawField

Draws large numbers for status bar and powerups
==============
*/
#ifndef MISSIONPACK
static void CG_DrawField (int x, int y, int width, int value) {
    char    num[16], *ptr;
    int     l;
    int     frame;

    if ( width < 1 ) {
        return;
    }

    // draw number string
    if ( width > 5 ) {
        width = 5;
    }

    switch ( width ) {
    case 1:
        value = value > 9 ? 9 : value;
        value = value < 0 ? 0 : value;
        break;
    case 2:
        value = value > 99 ? 99 : value;
        value = value < -9 ? -9 : value;
        break;
    case 3:
        value = value > 999 ? 999 : value;
        value = value < -99 ? -99 : value;
        break;
    case 4:
        value = value > 9999 ? 9999 : value;
        value = value < -999 ? -999 : value;
        break;
    }

    Com_sprintf (num, sizeof(num), "%i", value);
    l = strlen(num);
    if (l > width)
        l = width;
    x += 2 + CHAR_WIDTH*(width - l);

    ptr = num;
    while (*ptr && l)
    {
        if (*ptr == '-')
            frame = STAT_MINUS;
        else
            frame = *ptr -'0';

        CG_DrawPic( x,y, CHAR_WIDTH, CHAR_HEIGHT, cgs.media.numberShaders[frame] );
        x += CHAR_WIDTH;
        ptr++;
        l--;
    }
}
#endif // MISSIONPACK

/*
================
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;

    ci = &cgs.clientinfo[ clientNum ];

    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 );
    }
}

/*
================
CG_DrawFlagModel

Used for both the status bar and the scoreboard
================
*/
void CG_DrawFlagModel( float x, float y, float w, float h, int team, qboolean force2D ) {
    qhandle_t       cm;
    float           len;
    vec3_t          origin, angles;
    vec3_t          mins, maxs;
    qhandle_t       handle;

    if ( !force2D && cg_draw3dIcons.integer ) {

        VectorClear( angles );

        cm = cgs.media.redFlagModel;

        // offset the origin y and z to center the flag
        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 flag nearly fills the box
        // assume heads are taller than wide
        len = 0.5 * ( maxs[2] - mins[2] );      
        origin[0] = len / 0.268;    // len / tan( fov/2 )

        angles[YAW] = 60 * sin( cg.time / 2000.0 );;

        if( team == TEAM_RED ) {
            handle = cgs.media.redFlagModel;
        } else if( team == TEAM_BLUE ) {
            handle = cgs.media.blueFlagModel;
        } else if( team == TEAM_FREE ) {
            handle = cgs.media.neutralFlagModel;
        } else {
            return;
        }
        CG_Draw3DModel( x, y, w, h, handle, 0, origin, angles );
    } else if ( cg_drawIcons.integer ) {
        gitem_t *item;

        if( team == TEAM_RED ) {
            item = BG_FindItemForPowerup( PW_REDFLAG );
        } else if( team == TEAM_BLUE ) {
            item = BG_FindItemForPowerup( PW_BLUEFLAG );
        } else if( team == TEAM_FREE ) {
            item = BG_FindItemForPowerup( PW_NEUTRALFLAG );
        } else {
            return;
        }
        if (item) {
          CG_DrawPic( x, y, w, h, cg_items[ ITEM_INDEX(item) ].icon );
        }
    }
}

/*
================
CG_DrawStatusBarHead

================
*/
#ifndef MISSIONPACK

static void CG_DrawStatusBarHead( float x ) {
    vec3_t      angles;
    float       size, stretch;
    float       frac;

    VectorClear( angles );

    if ( cg.damageTime && cg.time - cg.damageTime < DAMAGE_TIME ) {
        frac = (float)(cg.time - cg.damageTime ) / DAMAGE_TIME;
        size = ICON_SIZE * 1.25 * ( 1.5 - frac * 0.5 );

        stretch = size - ICON_SIZE * 1.25;
        // kick in the direction of damage
        x -= stretch * 0.5 + cg.damageX * stretch * 0.5;

        cg.headStartYaw = 180 + cg.damageX * 45;

        cg.headEndYaw = 180 + 20 * cos( crandom()*M_PI );
        cg.headEndPitch = 5 * cos( crandom()*M_PI );

        cg.headStartTime = cg.time;
        cg.headEndTime = cg.time + 100 + random() * 2000;
    } else {
        if ( cg.time >= cg.headEndTime ) {
            // select a new head angle
            cg.headStartYaw = cg.headEndYaw;
            cg.headStartPitch = cg.headEndPitch;
            cg.headStartTime = cg.headEndTime;
            cg.headEndTime = cg.time + 100 + random() * 2000;

            cg.headEndYaw = 180 + 20 * cos( crandom()*M_PI );
            cg.headEndPitch = 5 * cos( crandom()*M_PI );
        }

        size = ICON_SIZE * 1.25;
    }

    // if the server was frozen for a while we may have a bad head start time
    if ( cg.headStartTime > cg.time ) {
        cg.headStartTime = cg.time;
    }

    frac = ( cg.time - cg.headStartTime ) / (float)( cg.headEndTime - cg.headStartTime );
    frac = frac * frac * ( 3 - 2 * frac );
    angles[YAW] = cg.headStartYaw + ( cg.headEndYaw - cg.headStartYaw ) * frac;
    angles[PITCH] = cg.headStartPitch + ( cg.headEndPitch - cg.headStartPitch ) * frac;

    CG_DrawHead( x, 480 - size, size, size, 
                cg.snap->ps.clientNum, angles );
}
#endif // MISSIONPACK

/*
================
CG_DrawStatusBarFlag

================
*/
#ifndef MISSIONPACK
static void CG_DrawStatusBarFlag( float x, int team ) {
    CG_DrawFlagModel( x, 480 - ICON_SIZE, ICON_SIZE, ICON_SIZE, team, qfalse );
}
#endif // MISSIONPACK

/*
================
CG_DrawTeamBackground

================
*/
void CG_DrawTeamBackground( int x, int y, int w, int h, float alpha, int team )
{
    vec4_t      hcolor;

    hcolor[3] = alpha;
    if ( team == TEAM_RED ) {
        hcolor[0] = 1;
        hcolor[1] = 0;
        hcolor[2] = 0;
    } else if ( team == TEAM_BLUE ) {
        hcolor[0] = 0;
        hcolor[1] = 0;
        hcolor[2] = 1;
    } else {
        return;
    }
    trap_R_SetColor( hcolor );
    CG_DrawPic( x, y, w, h, cgs.media.teamStatusBar );
    trap_R_SetColor( NULL );
}

/*
================
CG_DrawStatusBar

================
*/
#ifndef MISSIONPACK
static void CG_DrawStatusBar( void ) {
    int         color;
    centity_t   *cent;
    playerState_t   *ps;
    int         value;
    vec4_t      hcolor;
    vec3_t      angles;
    vec3_t      origin;
#ifdef MISSIONPACK
    qhandle_t   handle;
#endif
    static float colors[4][4] = { 
//      { 0.2, 1.0, 0.2, 1.0 } , { 1.0, 0.2, 0.2, 1.0 }, {0.5, 0.5, 0.5, 1} };
        { 1.0f, 0.69f, 0.0f, 1.0f },    // normal
        { 1.0f, 0.2f, 0.2f, 1.0f },     // low health
        { 0.5f, 0.5f, 0.5f, 1.0f },     // weapon firing
        { 1.0f, 1.0f, 1.0f, 1.0f } };   // health > 100

    if ( cg_drawStatus.integer == 0 ) {
        return;
    }

    // draw the team background
    CG_DrawTeamBackground( 0, 420, 640, 60, 0.33f, cg.snap->ps.persistant[PERS_TEAM] );

    cent = &cg_entities[cg.snap->ps.clientNum];
    ps = &cg.snap->ps;

    VectorClear( angles );

    // draw any 3D icons first, so the changes back to 2D are minimized
    if ( cent->currentState.weapon && cg_weapons[ cent->currentState.weapon ].ammoModel ) {
        origin[0] = 70;
        origin[1] = 0;
        origin[2] = 0;
        angles[YAW] = 90 + 20 * sin( cg.time / 1000.0 );
        CG_Draw3DModel( CHAR_WIDTH*3 + TEXT_ICON_SPACE, 432, ICON_SIZE, ICON_SIZE,
                       cg_weapons[ cent->currentState.weapon ].ammoModel, 0, origin, angles );
    }

    CG_DrawStatusBarHead( 185 + CHAR_WIDTH*3 + TEXT_ICON_SPACE );

    if( cg.predictedPlayerState.powerups[PW_REDFLAG] ) {
        CG_DrawStatusBarFlag( 185 + CHAR_WIDTH*3 + TEXT_ICON_SPACE + ICON_SIZE, TEAM_RED );
    } else if( cg.predictedPlayerState.powerups[PW_BLUEFLAG] ) {
        CG_DrawStatusBarFlag( 185 + CHAR_WIDTH*3 + TEXT_ICON_SPACE + ICON_SIZE, TEAM_BLUE );
    } else if( cg.predictedPlayerState.powerups[PW_NEUTRALFLAG] ) {
        CG_DrawStatusBarFlag( 185 + CHAR_WIDTH*3 + TEXT_ICON_SPACE + ICON_SIZE, TEAM_FREE );
    }

    if ( ps->stats[ STAT_ARMOR ] ) {
        origin[0] = 90;
        origin[1] = 0;
        origin[2] = -10;
        angles[YAW] = ( cg.time & 2047 ) * 360 / 2048.0;
        CG_Draw3DModel( 370 + CHAR_WIDTH*3 + TEXT_ICON_SPACE, 432, ICON_SIZE, ICON_SIZE,
                       cgs.media.armorModel, 0, origin, angles );
    }
#ifdef MISSIONPACK
    if( cgs.gametype == GT_HARVESTER ) {
        origin[0] = 90;
        origin[1] = 0;
        origin[2] = -10;
        angles[YAW] = ( cg.time & 2047 ) * 360 / 2048.0;
        if( cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE ) {
            handle = cgs.media.redCubeModel;
        } else {
            handle = cgs.media.blueCubeModel;
        }
        CG_Draw3DModel( 640 - (TEXT_ICON_SPACE + ICON_SIZE), 416, ICON_SIZE, ICON_SIZE, handle, 0, origin, angles );
    }
#endif
    //
    // ammo
    //
    if ( cent->currentState.weapon ) {
        value = ps->ammo[cent->currentState.weapon];
        if ( value > -1 ) {
            if ( cg.predictedPlayerState.weaponstate == WEAPON_FIRING
                && cg.predictedPlayerState.weaponTime > 100 ) {
                // draw as dark grey when reloading
                color = 2;  // dark grey
            } else {
                if ( value >= 0 ) {
                    color = 0;  // green
                } else {
                    color = 1;  // red
                }
            }
            trap_R_SetColor( colors[color] );
            
            CG_DrawField (0, 432, 3, value);
            trap_R_SetColor( NULL );

            // if we didn't draw a 3D icon, draw a 2D icon for ammo
            if ( !cg_draw3dIcons.integer && cg_drawIcons.integer ) {
                qhandle_t   icon;

                icon = cg_weapons[ cg.predictedPlayerState.weapon ].ammoIcon;
                if ( icon ) {
                    CG_DrawPic( CHAR_WIDTH*3 + TEXT_ICON_SPACE, 432, ICON_SIZE, ICON_SIZE, icon );
                }
            }
        }
    }

    //
    // health
    //
    value = ps->stats[STAT_HEALTH];
    if ( value > 100 ) {
        trap_R_SetColor( colors[3] );       // white
    } else if (value > 25) {
        trap_R_SetColor( colors[0] );   // green
    } else if (value > 0) {
        color = (cg.time >> 8) & 1; // flash
        trap_R_SetColor( colors[color] );
    } else {
        trap_R_SetColor( colors[1] );   // red
    }

    // stretch the health up when taking damage
    CG_DrawField ( 185, 432, 3, value);
    CG_ColorForHealth( hcolor );
    trap_R_SetColor( hcolor );


    //
    // armor
    //
    value = ps->stats[STAT_ARMOR];
    if (value > 0 ) {
        trap_R_SetColor( colors[0] );
        CG_DrawField (370, 432, 3, value);
        trap_R_SetColor( NULL );
        // if we didn't draw a 3D icon, draw a 2D icon for armor
        if ( !cg_draw3dIcons.integer && cg_drawIcons.integer ) {
            CG_DrawPic( 370 + CHAR_WIDTH*3 + TEXT_ICON_SPACE, 432, ICON_SIZE, ICON_SIZE, cgs.media.armorIcon );
        }

    }
#ifdef MISSIONPACK
    //
    // cubes
    //
    if( cgs.gametype == GT_HARVESTER ) {
        value = ps->generic1;
        if( value > 99 ) {
            value = 99;
        }
        trap_R_SetColor( colors[0] );
        CG_DrawField (640 - (CHAR_WIDTH*2 + TEXT_ICON_SPACE + ICON_SIZE), 432, 2, value);
        trap_R_SetColor( NULL );
        // if we didn't draw a 3D icon, draw a 2D icon for armor
        if ( !cg_draw3dIcons.integer && cg_drawIcons.integer ) {
            if( cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE ) {
                handle = cgs.media.redCubeIcon;
            } else {
                handle = cgs.media.blueCubeIcon;
            }
            CG_DrawPic( 640 - (TEXT_ICON_SPACE + ICON_SIZE), 432, ICON_SIZE, ICON_SIZE, handle );
        }
    }
#endif
}
#endif

/*
===========================================================================================

  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_DrawSnapshot
==================
*/
static float CG_DrawSnapshot( float y ) {
    char        *s;
    int         w;

    s = va( "time:%i snap:%i cmd:%i", cg.snap->serverTime, 
        cg.latestSnapshotNum, cgs.serverCommandSequence );
    w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;

    CG_DrawBigString( 635 - w, y + 2, s, 1.0F);

    return y + BIGCHAR_HEIGHT + 4;
}

/*
==================
CG_DrawFPS
==================
*/
#define FPS_FRAMES  4
static float CG_DrawFPS( float y ) {
    char        *s;
    int         w;
    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( "%ifps", fps );
        w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;

        CG_DrawBigString( 635 - w, y + 2, s, 1.0F);
    }

    return y + BIGCHAR_HEIGHT + 4;
}

/*
=================
CG_DrawTimer
=================
*/
static float CG_DrawTimer( float y ) {
    char        *s;
    int         w;
    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 );
    w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH;

    CG_DrawBigString( 635 - w, y + 2, s, 1.0F);

    return y + BIGCHAR_HEIGHT + 4;
}


/*
=================
CG_DrawTeamOverlay
=================
*/

static float CG_DrawTeamOverlay( float y, qboolean right, qboolean upper ) {
    int x, w, h, xx;
    int i, j, len;
    const char *p;
    vec4_t      hcolor;
    int pwidth, lwidth;
    int plyrs;
    char st[16];
    clientInfo_t *ci;
    gitem_t *item;
    int ret_y, count;

    if ( !cg_drawTeamOverlay.integer ) {
        return y;
    }

    if ( cg.snap->ps.persistant[PERS_TEAM] != TEAM_RED && cg.snap->ps.persistant[PERS_TEAM] != TEAM_BLUE ) {
        return y; // Not on any team
    }

    plyrs = 0;

    // max player name width
    pwidth = 0;
    count = (numSortedTeamPlayers > 8) ? 8 : numSortedTeamPlayers;
    for (i = 0; i < count; i++) {
        ci = cgs.clientinfo + sortedTeamPlayers[i];
        if ( ci->infoValid && ci->team == cg.snap->ps.persistant[PERS_TEAM]) {
            plyrs++;
            len = CG_DrawStrlen(ci->name);
            if (len > pwidth)
                pwidth = len;
        }
    }

    if (!plyrs)
        return y;

    if (pwidth > TEAM_OVERLAY_MAXNAME_WIDTH)
        pwidth = TEAM_OVERLAY_MAXNAME_WIDTH;

    // max location name width
    lwidth = 0;
    for (i = 1; i < MAX_LOCATIONS; i++) {
        p = CG_ConfigString(CS_LOCATIONS + i);
        if (p && *p) {
            len = CG_DrawStrlen(p);
            if (len > lwidth)
                lwidth = len;
        }
    }

    if (lwidth > TEAM_OVERLAY_MAXLOCATION_WIDTH)
        lwidth = TEAM_OVERLAY_MAXLOCATION_WIDTH;

    w = (pwidth + lwidth + 4 + 7) * TINYCHAR_WIDTH;

    if ( right )
        x = 640 - w;
    else
        x = 0;

    h = plyrs * TINYCHAR_HEIGHT;

    if ( upper ) {
        ret_y = y + h;
    } else {
        y -= h;
        ret_y = y;
    }

    if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED ) {
        hcolor[0] = 1.0f;
        hcolor[1] = 0.0f;
        hcolor[2] = 0.0f;
        hcolor[3] = 0.33f;
    } else { // if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE )
        hcolor[0] = 0.0f;
        hcolor[1] = 0.0f;
        hcolor[2] = 1.0f;
        hcolor[3] = 0.33f;
    }
    trap_R_SetColor( hcolor );
    CG_DrawPic( x, y, w, h, cgs.media.teamStatusBar );
    trap_R_SetColor( NULL );

    for (i = 0; i < count; i++) {
        ci = cgs.clientinfo + sortedTeamPlayers[i];
        if ( ci->infoValid && ci->team == cg.snap->ps.persistant[PERS_TEAM]) {

            hcolor[0] = hcolor[1] = hcolor[2] = hcolor[3] = 1.0;

            xx = x + TINYCHAR_WIDTH;

            CG_DrawStringExt( xx, y,
                ci->name, hcolor, qfalse, qfalse,
                TINYCHAR_WIDTH, TINYCHAR_HEIGHT, TEAM_OVERLAY_MAXNAME_WIDTH);

            if (lwidth) {
                p = CG_ConfigString(CS_LOCATIONS + ci->location);
                if (!p || !*p)
                    p = "unknown";
                len = CG_DrawStrlen(p);
                if (len > lwidth)
                    len = lwidth;

//              xx = x + TINYCHAR_WIDTH * 2 + TINYCHAR_WIDTH * pwidth + 
//                  ((lwidth/2 - len/2) * TINYCHAR_WIDTH);
                xx = x + TINYCHAR_WIDTH * 2 + TINYCHAR_WIDTH * pwidth;
                CG_DrawStringExt( xx, y,
                    p, hcolor, qfalse, qfalse, TINYCHAR_WIDTH, TINYCHAR_HEIGHT,
                    TEAM_OVERLAY_MAXLOCATION_WIDTH);
            }

            CG_GetColorForHealth( ci->health, ci->armor, hcolor );

            Com_sprintf (st, sizeof(st), "%3i %3i", ci->health, ci->armor);

            xx = x + TINYCHAR_WIDTH * 3 + 
                TINYCHAR_WIDTH * pwidth + TINYCHAR_WIDTH * lwidth;

            CG_DrawStringExt( xx, y,
                st, hcolor, qfalse, qfalse,
                TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 0 );

            // draw weapon icon
            xx += TINYCHAR_WIDTH * 3;

            if ( cg_weapons[ci->curWeapon].weaponIcon ) {
                CG_DrawPic( xx, y, TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 
                    cg_weapons[ci->curWeapon].weaponIcon );
            } else {
                CG_DrawPic( xx, y, TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 
                    cgs.media.deferShader );
            }

            // Draw powerup icons
            if (right) {
                xx = x;
            } else {
                xx = x + w - TINYCHAR_WIDTH;
            }
            for (j = 0; j <= PW_NUM_POWERUPS; j++) {
                if (ci->powerups & (1 << j)) {

                    item = BG_FindItemForPowerup( j );

                    if (item) {
                        CG_DrawPic( xx, y, TINYCHAR_WIDTH, TINYCHAR_HEIGHT, 
                        trap_R_RegisterShader( item->icon ) );
                        if (right) {
                            xx -= TINYCHAR_WIDTH;
                        } else {
                            xx += TINYCHAR_WIDTH;
                        }
                    }
                }
            }

            y += TINYCHAR_HEIGHT;
        }
    }

    return ret_y;
//#endif
}


/*
=====================
CG_DrawUpperRight

=====================
*/
static void CG_DrawUpperRight( void ) {
    float   y;

    y = 0;

    if ( cgs.gametype >= GT_TEAM && cg_drawTeamOverlay.integer == 1 ) {
        y = CG_DrawTeamOverlay( y, qtrue, qtrue );
    } 
    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 );
    }

}

/*
===========================================================================================

  LOWER RIGHT CORNER

===========================================================================================
*/

/*
=================
CG_DrawScores

Draw the small two score display
=================
*/
#ifndef MISSIONPACK
static float CG_DrawScores( float y ) {
    const char  *s;
    int         s1, s2, score;
    int         x, w;
    int         v;
    vec4_t      color;
    float       y1;
    gitem_t     *item;

    s1 = cgs.scores1;
    s2 = cgs.scores2;

    y -=  BIGCHAR_HEIGHT + 8;

    y1 = y;

    // draw from the right side to left
    if ( cgs.gametype >= GT_TEAM ) {
        x = 640;
        color[0] = 0.0f;
        color[1] = 0.0f;
        color[2] = 1.0f;
        color[3] = 0.33f;
        s = va( "%2i", s2 );
        w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH + 8;
        x -= w;
        CG_FillRect( x, y-4,  w, BIGCHAR_HEIGHT+8, color );
        if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_BLUE ) {
            CG_DrawPic( x, y-4, w, BIGCHAR_HEIGHT+8, cgs.media.selectShader );
        }
        CG_DrawBigString( x + 4, y, s, 1.0F);

        if ( cgs.gametype == GT_CTF ) {
            // Display flag status
            item = BG_FindItemForPowerup( PW_BLUEFLAG );

            if (item) {
                y1 = y - BIGCHAR_HEIGHT - 8;
                if( cgs.blueflag >= 0 && cgs.blueflag <= 2 ) {
                    CG_DrawPic( x, y1-4, w, BIGCHAR_HEIGHT+8, cgs.media.blueFlagShader[cgs.blueflag] );
                }
            }
        }
        color[0] = 1.0f;
        color[1] = 0.0f;
        color[2] = 0.0f;
        color[3] = 0.33f;
        s = va( "%2i", s1 );
        w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH + 8;
        x -= w;
        CG_FillRect( x, y-4,  w, BIGCHAR_HEIGHT+8, color );
        if ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_RED ) {
            CG_DrawPic( x, y-4, w, BIGCHAR_HEIGHT+8, cgs.media.selectShader );
        }
        CG_DrawBigString( x + 4, y, s, 1.0F);

        if ( cgs.gametype == GT_CTF ) {
            // Display flag status
            item = BG_FindItemForPowerup( PW_REDFLAG );

            if (item) {
                y1 = y - BIGCHAR_HEIGHT - 8;
                if( cgs.redflag >= 0 && cgs.redflag <= 2 ) {
                    CG_DrawPic( x, y1-4, w, BIGCHAR_HEIGHT+8, cgs.media.redFlagShader[cgs.redflag] );
                }
            }
        }

#ifdef MISSIONPACK
        if ( cgs.gametype == GT_1FCTF ) {
            // Display flag status
            item = BG_FindItemForPowerup( PW_NEUTRALFLAG );

            if (item) {
                y1 = y - BIGCHAR_HEIGHT - 8;
                if( cgs.flagStatus >= 0 && cgs.flagStatus <= 3 ) {
                    CG_DrawPic( x, y1-4, w, BIGCHAR_HEIGHT+8, cgs.media.flagShader[cgs.flagStatus] );
                }
            }
        }
#endif
        if ( cgs.gametype >= GT_CTF ) {
            v = cgs.capturelimit;
        } else {
            v = cgs.fraglimit;
        }
        if ( v ) {
            s = va( "%2i", v );
            w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH + 8;
            x -= w;
            CG_DrawBigString( x + 4, y, s, 1.0F);
        }

    } else {
        qboolean    spectator;

        x = 640;
        score = cg.snap->ps.persistant[PERS_SCORE];
        spectator = ( cg.snap->ps.persistant[PERS_TEAM] == TEAM_SPECTATOR );

        // always show your score in the second box if not in first place
        if ( s1 != score ) {
            s2 = score;
        }
        if ( s2 != SCORE_NOT_PRESENT ) {
            s = va( "%2i", s2 );
            w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH + 8;
            x -= w;
            if ( !spectator && score == s2 && score != s1 ) {
                color[0] = 1.0f;
                color[1] = 0.0f;
                color[2] = 0.0f;
                color[3] = 0.33f;
                CG_FillRect( x, y-4,  w, BIGCHAR_HEIGHT+8, color );
                CG_DrawPic( x, y-4, w, BIGCHAR_HEIGHT+8, cgs.media.selectShader );
            } else {
                color[0] = 0.5f;
                color[1] = 0.5f;
                color[2] = 0.5f;
                color[3] = 0.33f;
                CG_FillRect( x, y-4,  w, BIGCHAR_HEIGHT+8, color );
            }   
            CG_DrawBigString( x + 4, y, s, 1.0F);
        }

        // first place
        if ( s1 != SCORE_NOT_PRESENT ) {
            s = va( "%2i", s1 );
            w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH + 8;
            x -= w;
            if ( !spectator && score == s1 ) {
                color[0] = 0.0f;
                color[1] = 0.0f;
                color[2] = 1.0f;
                color[3] = 0.33f;
                CG_FillRect( x, y-4,  w, BIGCHAR_HEIGHT+8, color );
                CG_DrawPic( x, y-4, w, BIGCHAR_HEIGHT+8, cgs.media.selectShader );
            } else {
                color[0] = 0.5f;
                color[1] = 0.5f;
                color[2] = 0.5f;
                color[3] = 0.33f;
                CG_FillRect( x, y-4,  w, BIGCHAR_HEIGHT+8, color );
            }   
            CG_DrawBigString( x + 4, y, s, 1.0F);
        }

        if ( cgs.fraglimit ) {
            s = va( "%2i", cgs.fraglimit );
            w = CG_DrawStrlen( s ) * BIGCHAR_WIDTH + 8;
            x -= w;
            CG_DrawBigString( x + 4, y, s, 1.0F);
        }

    }

    return y1 - 8;
}
#endif // MISSIONPACK

/*
================
CG_DrawPowerups
================
*/
#ifndef MISSIONPACK
static float CG_DrawPowerups( float y ) {
    int     sorted[MAX_POWERUPS];
    int     sortedTime[MAX_POWERUPS];
    int     i, j, k;
    int     active;
    playerState_t   *ps;
    int     t;
    gitem_t *item;
    int     x;
    int     color;
    float   size;
    float   f;
    static float colors[2][4] = { 
    { 0.2f, 1.0f, 0.2f, 1.0f } , 
    { 1.0f, 0.2f, 0.2f, 1.0f } 
  };

    ps = &cg.snap->ps;

    if ( ps->stats[STAT_HEALTH] <= 0 ) {
        return y;
    }

    // sort the list by time remaining
    active = 0;
    for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
        if ( !ps->powerups[ i ] ) {
            continue;
        }
        t = ps->powerups[ i ] - cg.time;
        // ZOID--don't draw if the power up has unlimited time (999 seconds)