cl_scrn.c File Reference

#include "client.h"
#include <inttypes.h>

Go to the source code of this file.

Classes
struct	dirty_t
struct	graphsamp_t

Macros
#define	STAT_MINUS   10
#define	ICON_WIDTH   24
#define	ICON_HEIGHT   24
#define	CHAR_WIDTH   16 * vid_hudscale->value
#define	ICON_SPACE   8
#define	STAT_LAYOUTS   13

Functions
void	SCR_TimeRefresh_f (void)
void	SCR_Loading_f (void)
void	CL_AddNetgraph (void)
void	SCR_DebugGraph (float value, int color)
void	SCR_DrawDebugGraph (void)
void	SCR_CenterPrint (char *str)
void	SCR_DrawCenterString (void)
void	SCR_CheckDrawCenterString (void)
static void	SCR_CalcVrect (void)
void	SCR_SizeUp_f (void)
void	SCR_SizeDown_f (void)
void	SCR_Sky_f (void)
void	SCR_Init (void)
void	SCR_DrawNet (void)
void	SCR_DrawPause (void)
void	SCR_DrawLoading (void)
void	SCR_RunConsole (void)
void	SCR_DrawConsole (void)
void	SCR_BeginLoadingPlaque (void)
void	SCR_EndLoadingPlaque (void)
int	entitycmpfnc (const entity_t *a, const entity_t *b)
void	SCR_AddDirtyPoint (int x, int y)
void	SCR_DirtyScreen (void)
void	SCR_TileClear (void)
void	SizeHUDString (char *string, int *w, int *h)
void	DrawHUDString (char *string, int x, int y, int centerwidth, int xor)
void	SCR_DrawField (int x, int y, int color, int width, int value)
void	SCR_TouchPics (void)
void	SCR_ExecuteLayoutString (char *s)
void	SCR_DrawStats (void)
void	SCR_DrawLayout (void)
void	SCR_UpdateScreen (void)

Variables
float	scr_con_current
float	scr_conlines
qboolean	scr_initialized
int	scr_draw_loading
vrect_t	scr_vrect
cvar_t *	scr_viewsize
cvar_t *	scr_conspeed
cvar_t *	scr_centertime
cvar_t *	scr_showturtle
cvar_t *	scr_showpause
cvar_t *	scr_printspeed
cvar_t *	scr_netgraph
cvar_t *	scr_timegraph
cvar_t *	scr_debuggraph
cvar_t *	scr_graphheight
cvar_t *	scr_graphscale
cvar_t *	scr_graphshift
cvar_t *	scr_drawall
cvar_t *	vid_hudscale
cvar_t *	vid_ref
dirty_t	scr_dirty
dirty_t	scr_old_dirty [2]
char	crosshair_pic [MAX_QPATH]
int	crosshair_width
int	crosshair_height
static int	current
static graphsamp_t	values [1024]
char	scr_centerstring [1024]
float	scr_centertime_start
float	scr_centertime_off
int	scr_center_lines
int	scr_erase_center
char *	sb_nums [2][11]

Macro Definition Documentation

CHAR_WIDTH

#define CHAR_WIDTH   16 * vid_hudscale->value

Definition at line 737 of file cl_scrn.c.

ICON_HEIGHT

#define ICON_HEIGHT   24

Definition at line 736 of file cl_scrn.c.

ICON_SPACE

#define ICON_SPACE   8

Definition at line 738 of file cl_scrn.c.

ICON_WIDTH

#define ICON_WIDTH   24

Definition at line 735 of file cl_scrn.c.

STAT_LAYOUTS

#define STAT_LAYOUTS   13

Definition at line 1196 of file cl_scrn.c.

STAT_MINUS

#define STAT_MINUS   10

Definition at line 726 of file cl_scrn.c.

Function Documentation

CL_AddNetgraph()

void CL_AddNetgraph

(

void

)

Definition at line 96 of file cl_scrn.c.

{
    int     i;
    int     in;
    int     ping;
 
    // if using the debuggraph for something else, don't
    // add the net lines
    if (scr_debuggraph->value || scr_timegraph->value)
        return;
 
    for (i=0 ; i<cls.netchan.dropped ; i++)
        SCR_DebugGraph (30, 0x40);
 
    for (i=0 ; i<cl.surpressCount ; i++)
        SCR_DebugGraph (30, 0xdf);
 
    // see what the latency was on this packet
    in = cls.netchan.incoming_acknowledged & (CMD_BACKUP-1);
    ping = cls.realtime - cl.cmd_time[in];
    ping /= 30;
    if (ping > 30)
        ping = 30;
    SCR_DebugGraph (ping, 0xd0);
}

Referenced by CL_ParseServerMessage().

DrawHUDString()

void DrawHUDString	(	char *	string,
		int	x,
		int	y,
		int	centerwidth,
		int	xor
	)

Definition at line 777 of file cl_scrn.c.

{
    int     margin;
    char    line[1024];
    int     width;
    int     i;
 
    margin = x;
 
    while (*string)
    {
        // scan out one line of text from the string
        width = 0;
        while (*string && *string != '\n')
            line[width++] = *string++;
        line[width] = 0;
 
        if (centerwidth)
            x = margin + ((centerwidth - width*8)*vid_hudscale->value)/2;
        else
            x = margin;
        for (i=0 ; i<width ; i++)
        {
            re.DrawChar (x, y, line[i]^xor);
            x += 8 * vid_hudscale->value;
        }
        if (*string)
        {
            string++;   // skip the \n
            x = margin;
            y += 8 * vid_hudscale->value;
        }
    }
}

Referenced by SCR_ExecuteLayoutString().

entitycmpfnc()

int entitycmpfnc	(	const entity_t *	a,
		const entity_t *	b
	)

Definition at line 611 of file cl_scrn.c.

{
    /*
    ** all other models are sorted by model then skin
    */
    if ( a->model == b->model )
    {
        return ( ( intptr_t ) a->skin - ( intptr_t ) b->skin );
    }
    else
    {
        return ( (intptr_t) a->model - (intptr_t) b->model );
    }
}

Referenced by V_RenderView().

SCR_AddDirtyPoint()

void SCR_AddDirtyPoint	(	int	x,
		int	y
	)

Definition at line 669 of file cl_scrn.c.

{
    if (x < scr_dirty.x1)
        scr_dirty.x1 = x;
    if (x > scr_dirty.x2)
        scr_dirty.x2 = x;
    if (y < scr_dirty.y1)
        scr_dirty.y1 = y;
    if (y > scr_dirty.y2)
        scr_dirty.y2 = y;
}

Referenced by CL_PrepRefresh(), Con_DrawConsole(), Con_DrawNotify(), SCR_DirtyScreen(), SCR_DrawCenterString(), SCR_DrawField(), SCR_ExecuteLayoutString(), and V_RenderView().

SCR_BeginLoadingPlaque()

void SCR_BeginLoadingPlaque

(

void

)

Definition at line 562 of file cl_scrn.c.

{
    S_StopAllSounds ();
    cl.sound_prepped = false;       // don't play ambients
    CDAudio_Stop ();
    Miniaudio_Stop ();
    if (cls.disable_screen)
        return;
    if (developer->value)
        return;
    if (cls.state == ca_disconnected)
        return; // if at console, don't bring up the plaque
    if (cls.key_dest == key_console)
        return;
    if (cl.cinematictime > 0)
        scr_draw_loading = 2;   // clear to balack first
    else
        scr_draw_loading = 1;
    SCR_UpdateScreen ();
    cls.disable_screen = Sys_Milliseconds ();
    cls.disable_servercount = cl.servercount;
}

Referenced by CL_Changing_f(), SCR_Loading_f(), SCR_RunCinematic(), SV_InitGame(), and SV_Map().

SCR_CalcVrect()

static void SCR_CalcVrect ( void  )

static

Definition at line 321 of file cl_scrn.c.

{
    int     size;
 
    // bound viewsize
    if (scr_viewsize->value < 40)
        Cvar_Set ("viewsize","40");
    if (scr_viewsize->value > 100)
        Cvar_Set ("viewsize","100");
 
    size = scr_viewsize->value;
 
    scr_vrect.width  = viddef.width*size/100;
    scr_vrect.height = viddef.height*size/100;
 
    scr_vrect.x = (viddef.width - scr_vrect.width)/2;
    scr_vrect.y = (viddef.height - scr_vrect.height)/2;
}

Referenced by SCR_UpdateScreen().

SCR_CenterPrint()

void SCR_CenterPrint

(

char *

str

)

Definition at line 201 of file cl_scrn.c.

{
    char    *s;
    char    line[64];
    int     i, j, l;
 
    strncpy (scr_centerstring, str, sizeof(scr_centerstring)-1);
    scr_centertime_off = scr_centertime->value;
    scr_centertime_start = cl.time;
 
    // count the number of lines for centering
    scr_center_lines = 1;
    s = str;
    while (*s)
    {
        if (*s == '\n')
            scr_center_lines++;
        s++;
    }
 
    // echo it to the console
    Com_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
 
    s = str;
    do  
    {
    // scan the width of the line
        for (l=0 ; l<40 ; l++)
            if (s[l] == '\n' || !s[l])
                break;
        for (i=0 ; i<(40-l)/2 ; i++)
            line[i] = ' ';
 
        for (j=0 ; j<l ; j++)
        {
            line[i++] = s[j];
        }
 
        line[i] = '\n';
        line[i+1] = 0;
 
        Com_Printf ("%s", line);
 
        while (*s && *s != '\n')
            s++;
 
        if (!*s)
            break;
        s++;        // skip the \n
    } while (1);
    Com_Printf("\n\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n");
    Con_ClearNotify ();
}

Referenced by CL_ParseServerMessage().

SCR_CheckDrawCenterString()

void SCR_CheckDrawCenterString

(

void

)

Definition at line 302 of file cl_scrn.c.

{
    scr_centertime_off -= cls.frametime;
    
    if (scr_centertime_off <= 0)
        return;
 
    SCR_DrawCenterString ();
}

Referenced by SCR_UpdateScreen().

SCR_DebugGraph()

void SCR_DebugGraph	(	float	value,
		int	color
	)

Definition at line 137 of file cl_scrn.c.

{
    values[current&1023].value = value;
    values[current&1023].color = color;
    current++;
}

Referenced by CL_AddNetgraph(), SCR_UpdateScreen(), and SV_InitGameProgs().

SCR_DirtyScreen()

void SCR_DirtyScreen

(

void

)

Definition at line 681 of file cl_scrn.c.

{
    SCR_AddDirtyPoint (0, 0);
    SCR_AddDirtyPoint (viddef.width-1, viddef.height-1);
}

Referenced by CL_DrawInventory(), M_Draw(), and MainWndProc().

SCR_DrawCenterString()

void SCR_DrawCenterString

(

void

)

Definition at line 256 of file cl_scrn.c.

{
    char    *start;
    int     l;
    int     j;
    int     x, y;
    int     remaining;
 
// the finale prints the characters one at a time
    remaining = 9999;
 
    scr_erase_center = 0;
    start = scr_centerstring;
 
    if (scr_center_lines <= 4)
        y = viddef.height*0.35;
    else
        y = 48;
 
    do  
    {
    // scan the width of the line
        for (l=0 ; l<40 ; l++)
            if (start[l] == '\n' || !start[l])
                break;
        x = (viddef.width - l*8*vid_hudscale->value)/2;
        SCR_AddDirtyPoint (x, y);
        for (j=0 ; j<l ; j++, x+=8*vid_hudscale->value)
        {
            re.DrawChar (x, y, start[j]);
            if (!remaining--)
                return;
        }
        SCR_AddDirtyPoint (x, y+8*vid_hudscale->value);
            
        y += 8*vid_hudscale->value;
 
        while (*start && *start != '\n')
            start++;
 
        if (!*start)
            break;
        start++;        // skip the \n
    } while (1);
}

Referenced by SCR_CheckDrawCenterString().

SCR_DrawConsole()

void SCR_DrawConsole

(

void

)

Definition at line 527 of file cl_scrn.c.

{
    Con_CheckResize ();
    
    if (cls.state == ca_disconnected || cls.state == ca_connecting)
    {   // forced full screen console
        Con_DrawConsole (1.0);
        return;
    }
 
    if (cls.state != ca_active || !cl.refresh_prepped)
    {   // connected, but can't render
        Con_DrawConsole (0.5);
        re.DrawFill (0, viddef.height/2, viddef.width, viddef.height/2, 0);
        return;
    }
 
    if (scr_con_current)
    {
        Con_DrawConsole (scr_con_current);
    }
    else
    {
        if (cls.key_dest == key_game || cls.key_dest == key_message)
            Con_DrawNotify ();  // only draw notify in game
    }
}

Referenced by SCR_UpdateScreen().

SCR_DrawDebugGraph()

void SCR_DrawDebugGraph

(

void

)

Definition at line 149 of file cl_scrn.c.

{
    int     a, x, y, w, i, h;
    float   v;
    int     color;
 
    //
    // draw the graph
    //
    w = scr_vrect.width;
 
    x = scr_vrect.x;
    y = scr_vrect.y+scr_vrect.height;
    re.DrawFill (x, y-scr_graphheight->value,
        w, scr_graphheight->value, 8);
 
    for (a=0 ; a<w ; a++)
    {
        i = (current-1-a+1024) & 1023;
        v = values[i].value;
        color = values[i].color;
        v = v*scr_graphscale->value + scr_graphshift->value;
        
        if (v < 0)
            v += scr_graphheight->value * (1+(int)(-v/scr_graphheight->value));
        h = (int)v % (int)scr_graphheight->value;
        re.DrawFill (x+w-1-a, y - h, 1, h, color);
    }
}

Referenced by SCR_UpdateScreen().

SCR_DrawField()

void SCR_DrawField	(	int	x,
		int	y,
		int	color,
		int	width,
		int	value
	)

Definition at line 818 of file cl_scrn.c.

{
    char    num[16], *ptr;
    int     l;
    int     frame;
 
    if (width < 1)
        return;
 
    // draw number string
    if (width > 5)
        width = 5;
 
    SCR_AddDirtyPoint (x, y);
    SCR_AddDirtyPoint (x+width*CHAR_WIDTH+2, y+23);
 
    Com_sprintf (num, sizeof(num), "%i", value);
    l = (int)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';
 
        re.DrawPic (x,y,sb_nums[color][frame]);
        x += CHAR_WIDTH;
        ptr++;
        l--;
    }
}

Referenced by SCR_ExecuteLayoutString().

SCR_DrawLayout()

void SCR_DrawLayout

(

void

)

Definition at line 1198 of file cl_scrn.c.

{
    if (!cl.frame.playerstate.stats[STAT_LAYOUTS])
        return;
    SCR_ExecuteLayoutString (cl.layout);
}

Referenced by SCR_UpdateScreen().

SCR_DrawLoading()

void SCR_DrawLoading

(

void

)

Definition at line 477 of file cl_scrn.c.

{
    int     w, h;
        
    if (!scr_draw_loading)
        return;
 
    scr_draw_loading = false;
    re.DrawGetPicSize (&w, &h, "loading");
    re.DrawPic ((viddef.width-w)/2, (viddef.height-h)/2, "loading");
}

Referenced by SCR_UpdateScreen().

SCR_DrawNet()

void SCR_DrawNet

(

void

)

Definition at line 444 of file cl_scrn.c.

{
    if (cls.netchan.outgoing_sequence - cls.netchan.incoming_acknowledged 
        < CMD_BACKUP-1)
        return;
 
    re.DrawPic (scr_vrect.x+64, scr_vrect.y, "net");
}

Referenced by SCR_UpdateScreen().

SCR_DrawPause()

void SCR_DrawPause

(

void

)

Definition at line 458 of file cl_scrn.c.

{
    int     w, h;
 
    if (!scr_showpause->value)      // turn off for screenshots
        return;
 
    if (!cl_paused->value)
        return;
 
    re.DrawGetPicSize (&w, &h, "pause");
    re.DrawPic ((viddef.width-w)/2, viddef.height/2 + 8*vid_hudscale->value, "pause");
}

Referenced by SCR_UpdateScreen().

SCR_DrawStats()

void SCR_DrawStats

(

void

)

Definition at line 1184 of file cl_scrn.c.

{
    SCR_ExecuteLayoutString (cl.configstrings[CS_STATUSBAR]);
}

Referenced by SCR_UpdateScreen().

SCR_EndLoadingPlaque()

void SCR_EndLoadingPlaque

(

void

)

Definition at line 590 of file cl_scrn.c.

{
    cls.disable_screen = 0;
    Con_ClearNotify ();
}

Referenced by CL_Drop(), CL_ParseFrame(), Con_ToggleConsole_f(), Qcommon_Init(), and SCR_PlayCinematic().

SCR_ExecuteLayoutString()

void SCR_ExecuteLayoutString

(

char *

s

)

Definition at line 889 of file cl_scrn.c.

{
    int     x, y;
    int     value;
    char    *token;
    int     width;
    int     index;
    clientinfo_t    *ci;
 
    if (cls.state != ca_active || !cl.refresh_prepped)
        return;
 
    if (!s[0])
        return;
 
    x = 0;
    y = 0;
    width = 3;
 
    while (s)
    {
        token = COM_Parse (&s);
        if (!strcmp(token, "xl"))
        {
            token = COM_Parse (&s);
            x = atoi(token) * vid_hudscale->value;
            continue;
        }
        if (!strcmp(token, "xr"))
        {
            token = COM_Parse (&s);
            x = viddef.width + atoi(token) * vid_hudscale->value;
            continue;
        }
        if (!strcmp(token, "xv"))
        {
            token = COM_Parse (&s);
            x = viddef.width/2 - 160 * vid_hudscale->value + atoi(token) * vid_hudscale->value;
            continue;
        }
 
        if (!strcmp(token, "yt"))
        {
            token = COM_Parse (&s);
            y = atoi(token) * vid_hudscale->value;
            continue;
        }
        if (!strcmp(token, "yb"))
        {
            token = COM_Parse (&s);
            y = viddef.height + atoi(token) * vid_hudscale->value;
            continue;
        }
        if (!strcmp(token, "yv"))
        {
            token = COM_Parse (&s);
            y = viddef.height/2 - 120 * vid_hudscale->value + atoi(token) * vid_hudscale->value;
            continue;
        }
 
        if (!strcmp(token, "pic"))
        {   // draw a pic from a stat number
            token = COM_Parse (&s);
            value = cl.frame.playerstate.stats[atoi(token)];
            if (value >= MAX_IMAGES)
                Com_Error (ERR_DROP, "Pic >= MAX_IMAGES");
            if (cl.configstrings[CS_IMAGES+value])
            {
                SCR_AddDirtyPoint (x, y);
                SCR_AddDirtyPoint (x+23, y+23);
                re.DrawPic (x, y, cl.configstrings[CS_IMAGES+value]);
            }
            continue;
        }
 
        if (!strcmp(token, "client"))
        {   // draw a deathmatch client block
            int     score, ping, time;
 
            token = COM_Parse (&s);
            x = viddef.width/2 - 160 * vid_hudscale->value + atoi(token)*vid_hudscale->value;
            token = COM_Parse (&s);
            y = viddef.height/2 - 120 * vid_hudscale->value + atoi(token)*vid_hudscale->value;
            SCR_AddDirtyPoint (x, y);
            SCR_AddDirtyPoint (x+159 * vid_hudscale->value, y+31 * vid_hudscale->value);
 
            token = COM_Parse (&s);
            value = atoi(token);
            if (value >= MAX_CLIENTS || value < 0)
                Com_Error (ERR_DROP, "client >= MAX_CLIENTS");
            ci = &cl.clientinfo[value];
 
            token = COM_Parse (&s);
            score = atoi(token);
 
            token = COM_Parse (&s);
            ping = atoi(token);
 
            token = COM_Parse (&s);
            time = atoi(token);
 
            DrawAltString (x+32 * vid_hudscale->value, y, ci->name);
            DrawString (x+32 * vid_hudscale->value, y+8 * vid_hudscale->value,  "Score: ");
            DrawAltString (x+32 * vid_hudscale->value +7*8 * vid_hudscale->value, y+8 * vid_hudscale->value,  va("%i", score));
            DrawString (x+32 * vid_hudscale->value, y+16 * vid_hudscale->value, va("Ping:  %i", ping));
            DrawString (x+32 * vid_hudscale->value, y+24 * vid_hudscale->value, va("Time:  %i", time));
 
            if (!ci->icon)
                ci = &cl.baseclientinfo;
            re.DrawPic (x, y, ci->iconname);
            continue;
        }
 
        if (!strcmp(token, "ctf"))
        {   // draw a ctf client block
            int     score, ping;
            char    block[80];
 
            token = COM_Parse (&s);
            x = viddef.width/2 - 160 * vid_hudscale->value + atoi(token)*vid_hudscale->value;
            token = COM_Parse (&s);
            y = viddef.height/2 - 120 * vid_hudscale->value + atoi(token)*vid_hudscale->value;
            SCR_AddDirtyPoint (x, y);
            SCR_AddDirtyPoint (x+159 * vid_hudscale->value, y+31 * vid_hudscale->value);
 
            token = COM_Parse (&s);
            value = atoi(token);
            if (value >= MAX_CLIENTS || value < 0)
                Com_Error (ERR_DROP, "client >= MAX_CLIENTS");
            ci = &cl.clientinfo[value];
 
            token = COM_Parse (&s);
            score = atoi(token);
 
            token = COM_Parse (&s);
            ping = atoi(token);
            if (ping > 999)
                ping = 999;
 
            sprintf(block, "%3d %3d %-12.12s", score, ping, ci->name);
 
            if (value == cl.playernum)
                DrawAltString (x, y, block);
            else
                DrawString (x, y, block);
            continue;
        }
 
        if (!strcmp(token, "picn"))
        {   // draw a pic from a name
            token = COM_Parse (&s);
            SCR_AddDirtyPoint (x, y);
            SCR_AddDirtyPoint (x+23, y+23);
            re.DrawPic (x, y, token);
            continue;
        }
 
        if (!strcmp(token, "num"))
        {   // draw a number
            token = COM_Parse (&s);
            width = atoi(token);
            token = COM_Parse (&s);
            value = cl.frame.playerstate.stats[atoi(token)];
            SCR_DrawField (x, y, 0, width, value);
            continue;
        }
 
        if (!strcmp(token, "hnum"))
        {   // health number
            int     color;
 
            width = 3;
            value = cl.frame.playerstate.stats[STAT_HEALTH];
            if (value > 25)
                color = 0;  // green
            else if (value > 0)
                color = (cl.frame.serverframe>>2) & 1;      // flash
            else
                color = 1;
 
            if (cl.frame.playerstate.stats[STAT_FLASHES] & 1)
                re.DrawPic (x, y, "field_3");
 
            SCR_DrawField (x, y, color, width, value);
            continue;
        }
 
        if (!strcmp(token, "anum"))
        {   // ammo number
            int     color;
 
            width = 3;
            value = cl.frame.playerstate.stats[STAT_AMMO];
            if (value > 5)
                color = 0;  // green
            else if (value >= 0)
                color = (cl.frame.serverframe>>2) & 1;      // flash
            else
                continue;   // negative number = don't show
 
            if (cl.frame.playerstate.stats[STAT_FLASHES] & 4)
                re.DrawPic (x, y, "field_3");
 
            SCR_DrawField (x, y, color, width, value);
            continue;
        }
 
        if (!strcmp(token, "rnum"))
        {   // armor number
            int     color;
 
            width = 3;
            value = cl.frame.playerstate.stats[STAT_ARMOR];
            if (value < 1)
                continue;
 
            color = 0;  // green
 
            if (cl.frame.playerstate.stats[STAT_FLASHES] & 2)
                re.DrawPic (x, y, "field_3");
 
            SCR_DrawField (x, y, color, width, value);
            continue;
        }
 
 
        if (!strcmp(token, "stat_string"))
        {
            token = COM_Parse (&s);
            index = atoi(token);
            if (index < 0 || index >= MAX_CONFIGSTRINGS)
                Com_Error (ERR_DROP, "Bad stat_string index");
            index = cl.frame.playerstate.stats[index];
            if (index < 0 || index >= MAX_CONFIGSTRINGS)
                Com_Error (ERR_DROP, "Bad stat_string index");
            DrawString (x, y, cl.configstrings[index]);
            continue;
        }
 
        if (!strcmp(token, "cstring"))
        {
            token = COM_Parse (&s);
            DrawHUDString (token, x, y, 320, 0);
            continue;
        }
 
        if (!strcmp(token, "string"))
        {
            token = COM_Parse (&s);
            DrawString (x, y, token);
            continue;
        }
 
        if (!strcmp(token, "cstring2"))
        {
            token = COM_Parse (&s);
            DrawHUDString (token, x, y, 320,0x80);
            continue;
        }
 
        if (!strcmp(token, "string2"))
        {
            token = COM_Parse (&s);
            DrawAltString (x, y, token);
            continue;
        }
 
        if (!strcmp(token, "if"))
        {   // draw a number
            token = COM_Parse (&s);
            value = cl.frame.playerstate.stats[atoi(token)];
            if (!value)
            {   // skip to endif
                while (s && strcmp(token, "endif") )
                {
                    token = COM_Parse (&s);
                }
            }
 
            continue;
        }
 
 
    }
}

Referenced by SCR_DrawLayout(), and SCR_DrawStats().

SCR_Init()

void SCR_Init

(

void

)

Definition at line 410 of file cl_scrn.c.

{
    scr_viewsize = Cvar_Get ("viewsize", "100", CVAR_ARCHIVE);
    scr_conspeed = Cvar_Get ("scr_conspeed", "3", 0);
    scr_showturtle = Cvar_Get ("scr_showturtle", "0", 0);
    scr_showpause = Cvar_Get ("scr_showpause", "1", 0);
    scr_centertime = Cvar_Get ("scr_centertime", "2.5", 0);
    scr_printspeed = Cvar_Get ("scr_printspeed", "8", 0);
    scr_netgraph = Cvar_Get ("netgraph", "0", 0);
    scr_timegraph = Cvar_Get ("timegraph", "0", 0);
    scr_debuggraph = Cvar_Get ("debuggraph", "0", 0);
    scr_graphheight = Cvar_Get ("graphheight", "32", 0);
    scr_graphscale = Cvar_Get ("graphscale", "1", 0);
    scr_graphshift = Cvar_Get ("graphshift", "0", 0);
    scr_drawall = Cvar_Get ("scr_drawall", "0", 0);
 
//
// register our commands
//
    Cmd_AddCommand ("timerefresh",SCR_TimeRefresh_f);
    Cmd_AddCommand ("loading",SCR_Loading_f);
    Cmd_AddCommand ("sizeup",SCR_SizeUp_f);
    Cmd_AddCommand ("sizedown",SCR_SizeDown_f);
    Cmd_AddCommand ("sky",SCR_Sky_f);
 
    scr_initialized = true;
}

Referenced by CL_Init().

SCR_Loading_f()

void SCR_Loading_f

(

void

)

Definition at line 601 of file cl_scrn.c.

{
    SCR_BeginLoadingPlaque ();
}

Referenced by SCR_Init().

SCR_RunConsole()

void SCR_RunConsole

(

void

)

Definition at line 498 of file cl_scrn.c.

{
// decide on the height of the console
    if (cls.key_dest == key_console)
        scr_conlines = 0.5;     // half screen
    else
        scr_conlines = 0;               // none visible
    
    if (scr_conlines < scr_con_current)
    {
        scr_con_current -= scr_conspeed->value*cls.frametime;
        if (scr_conlines > scr_con_current)
            scr_con_current = scr_conlines;
 
    }
    else if (scr_conlines > scr_con_current)
    {
        scr_con_current += scr_conspeed->value*cls.frametime;
        if (scr_conlines < scr_con_current)
            scr_con_current = scr_conlines;
    }
 
}

Referenced by CL_Frame().

SCR_SizeDown_f()

void SCR_SizeDown_f

(

void

)

Definition at line 361 of file cl_scrn.c.

{
    Cvar_SetValue ("viewsize",scr_viewsize->value-10);
}

Referenced by SCR_Init().

SCR_SizeUp_f()

void SCR_SizeUp_f

(

void

)

Definition at line 348 of file cl_scrn.c.

{
    Cvar_SetValue ("viewsize",scr_viewsize->value+10);
}

Referenced by SCR_Init().

SCR_Sky_f()

void SCR_Sky_f

(

void

)

Definition at line 373 of file cl_scrn.c.

{
    float   rotate;
    vec3_t  axis;
 
    if (Cmd_Argc() < 2)
    {
        Com_Printf ("Usage: sky <basename> <rotate> <axis x y z>\n");
        return;
    }
    if (Cmd_Argc() > 2)
        rotate = atof(Cmd_Argv(2));
    else
        rotate = 0;
    if (Cmd_Argc() == 6)
    {
        axis[0] = atof(Cmd_Argv(3));
        axis[1] = atof(Cmd_Argv(4));
        axis[2] = atof(Cmd_Argv(5));
    }
    else
    {
        axis[0] = 0;
        axis[1] = 0;
        axis[2] = 1;
    }
 
    re.SetSky (Cmd_Argv(1), rotate, axis);
}

Referenced by SCR_Init().

SCR_TileClear()

void SCR_TileClear

(

void

)

Definition at line 694 of file cl_scrn.c.

{
    if (scr_con_current == 1.0)
        return;     // full screen console
    if (scr_viewsize->value == 100)
        return;     // full screen rendering
    if (cl.cinematictime > 0)
        return;     // full screen cinematic
 
    if (scr_vrect.y > 0)
    {   // clear above view screen
        re.DrawTileClear (scr_vrect.x , 0,
            scr_vrect.width, scr_vrect.y, "backtile");
 
        // clear below view screen
        re.DrawTileClear(scr_vrect.x, scr_vrect.y + scr_vrect.height,
            scr_vrect.width, viddef.height - scr_vrect.height - scr_vrect.y, "backtile");
    }
 
    if (scr_vrect.x > 0)
    {   // clear left of view screen
        re.DrawTileClear (0, 0, scr_vrect.x, viddef.height, "backtile");
 
        // clear right of view screen
        re.DrawTileClear(scr_vrect.x + scr_vrect.width, 0, scr_vrect.width, viddef.height, "backtile");
    }
}

Referenced by SCR_UpdateScreen().

SCR_TimeRefresh_f()

void SCR_TimeRefresh_f

(

void

)

Definition at line 626 of file cl_scrn.c.

{
    int     i;
    int     start, stop;
    float   time;
 
    if ( cls.state != ca_active )
        return;
 
    start = Sys_Milliseconds ();
 
    if (Cmd_Argc() == 2)
    {   // run without page flipping
        re.BeginFrame( 0 );
        for (i=0 ; i<128 ; i++)
        {
            cl.refdef.viewangles[1] = i/128.0*360.0;
            re.RenderFrame (&cl.refdef);
        }
        re.EndFrame();
    }
    else
    {
        for (i=0 ; i<128 ; i++)
        {
            cl.refdef.viewangles[1] = i/128.0*360.0;
 
            re.BeginFrame( 0 );
            re.RenderFrame (&cl.refdef);
            re.EndFrame();
        }
    }
 
    stop = Sys_Milliseconds ();
    time = (stop-start)/1000.0;
    Com_Printf ("%f seconds (%f fps)\n", time, 128/time);
}

Referenced by SCR_Init().

SCR_TouchPics()

void SCR_TouchPics

(

void

)

Definition at line 863 of file cl_scrn.c.

{
    int     i, j;
 
    for (i=0 ; i<2 ; i++)
        for (j=0 ; j<11 ; j++)
            re.RegisterPic (sb_nums[i][j]);
 
    if (crosshair->value)
    {
        if (crosshair->value > 3 || crosshair->value < 0)
            crosshair->value = 3;
 
        Com_sprintf (crosshair_pic, sizeof(crosshair_pic), "ch%i", (int)(crosshair->value));
        re.DrawGetPicSize (&crosshair_width, &crosshair_height, crosshair_pic);
        if (!crosshair_width)
            crosshair_pic[0] = 0;
    }
}

Referenced by CL_PrepRefresh(), and SCR_DrawCrosshair().

SCR_UpdateScreen()

void SCR_UpdateScreen

(

void

)

Definition at line 1215 of file cl_scrn.c.

{
    int numframes;
    int i;
    float separation[2] = { 0, 0 };
 
    // if the screen is disabled (loading plaque is up, or vid mode changing)
    // do nothing at all
    if (cls.disable_screen)
    {
        if (Sys_Milliseconds() - cls.disable_screen > 120000)
        {
            cls.disable_screen = 0;
            Com_Printf ("Loading plaque timed out.\n");
        }
        return;
    }
 
    if (!scr_initialized || !con.initialized)
        return;             // not initialized yet
 
    /*
    ** range check cl_camera_separation so we don't inadvertently fry someone's
    ** brain
    */
    if ( cl_stereo_separation->value > 1.0 )
        Cvar_SetValue( "cl_stereo_separation", 1.0 );
    else if ( cl_stereo_separation->value < 0 )
        Cvar_SetValue( "cl_stereo_separation", 0.0 );
 
    if ( cl_stereo->value )
    {
        numframes = 2;
        separation[0] = -cl_stereo_separation->value / 2;
        separation[1] =  cl_stereo_separation->value / 2;
    }       
    else
    {
        separation[0] = 0;
        separation[1] = 0;
        numframes = 1;
    }
 
    for ( i = 0; i < numframes; i++ )
    {
        re.BeginFrame( separation[i] );
        // end frame and force video restart if swapchain is out of date
        if (vid_ref->modified)
        {
            re.EndWorldRenderpass();
            re.EndFrame();
            return;
        }
 
        if (scr_draw_loading == 2)
        {   //  loading plaque over black screen
            int     w, h;
 
            re.EndWorldRenderpass();
            re.CinematicSetPalette(NULL);
            scr_draw_loading = false;
            re.DrawGetPicSize (&w, &h, "loading");
            re.DrawPic ((viddef.width-w)/2, (viddef.height-h)/2, "loading");
//          re.EndFrame();
//          return;
        } 
        // if a cinematic is supposed to be running, handle menus
        // and console specially
        else if (cl.cinematictime > 0)
        {
            if (cls.key_dest == key_menu)
            {
                if (cl.cinematicpalette_active)
                {
                    re.CinematicSetPalette(NULL);
                    cl.cinematicpalette_active = false;
                }
                re.EndWorldRenderpass();
                M_Draw ();
//              re.EndFrame();
//              return;
            }
            else if (cls.key_dest == key_console)
            {
                if (cl.cinematicpalette_active)
                {
                    re.CinematicSetPalette(NULL);
                    cl.cinematicpalette_active = false;
                }
                re.EndWorldRenderpass();
                SCR_DrawConsole ();
//              re.EndFrame();
//              return;
            }
            else
            {
                re.EndWorldRenderpass();
                SCR_DrawCinematic();
//              re.EndFrame();
//              return;
            }
        }
        else 
        {
 
            // make sure the game palette is active
            if (cl.cinematicpalette_active)
            {
                re.CinematicSetPalette(NULL);
                cl.cinematicpalette_active = false;
            }
 
            // do 3D refresh drawing, and then update the screen
            SCR_CalcVrect ();
 
            V_RenderView ( separation[i] );
 
            // clear any dirty part of the background
            SCR_TileClear ();
 
            SCR_DrawStats ();
            if (cl.frame.playerstate.stats[STAT_LAYOUTS] & 1)
                SCR_DrawLayout ();
            if (cl.frame.playerstate.stats[STAT_LAYOUTS] & 2)
                CL_DrawInventory ();
 
            SCR_DrawNet ();
            SCR_CheckDrawCenterString ();
 
            if (scr_timegraph->value)
                SCR_DebugGraph (cls.frametime*300, 0);
 
            if (scr_debuggraph->value || scr_timegraph->value || scr_netgraph->value)
                SCR_DrawDebugGraph ();
 
            SCR_DrawPause ();
 
            SCR_DrawConsole ();
 
            M_Draw ();
 
            SCR_DrawLoading ();
        }
    }
    re.EndFrame();
}

Referenced by CL_Frame(), CL_PrepRefresh(), CL_Skins_f(), Key_Console(), and SCR_BeginLoadingPlaque().

SizeHUDString()

void SizeHUDString	(	char *	string,
		int *	w,
		int *	h
	)

Definition at line 749 of file cl_scrn.c.

{
    int     lines, width, current;
 
    lines = 1;
    width = 0;
 
    current = 0;
    while (*string)
    {
        if (*string == '\n')
        {
            lines++;
            current = 0;
        }
        else
        {
            current++;
            if (current > width)
                width = current;
        }
        string++;
    }
 
    *w = width * 8 * vid_hudscale->value;
    *h = lines * 8 * vid_hudscale->value;
}

Variable Documentation

crosshair_height

int crosshair_height

Definition at line 75 of file cl_scrn.c.

Referenced by SCR_DrawCrosshair(), and SCR_TouchPics().

crosshair_pic

char crosshair_pic[MAX_QPATH]

Definition at line 74 of file cl_scrn.c.

Referenced by SCR_DrawCrosshair(), and SCR_TouchPics().

crosshair_width

int crosshair_width

Definition at line 75 of file cl_scrn.c.

Referenced by SCR_DrawCrosshair(), and SCR_TouchPics().

current

int current

static

Definition at line 129 of file cl_scrn.c.

Referenced by CL_ParseMuzzleFlash2(), CL_PredictMovement(), M_ChangeYaw(), S_StartSound(), SCR_DebugGraph(), SCR_DrawDebugGraph(), and SizeHUDString().

sb_nums

char* sb_nums[2][11]

Initial value:

= 
{
    {"num_0", "num_1", "num_2", "num_3", "num_4", "num_5",
    "num_6", "num_7", "num_8", "num_9", "num_minus"},
    {"anum_0", "anum_1", "anum_2", "anum_3", "anum_4", "anum_5",
    "anum_6", "anum_7", "anum_8", "anum_9", "anum_minus"}
}

Definition at line 727 of file cl_scrn.c.

Referenced by SCR_DrawField(), and SCR_TouchPics().

scr_center_lines

int scr_center_lines

Definition at line 190 of file cl_scrn.c.

Referenced by SCR_CenterPrint(), and SCR_DrawCenterString().

scr_centerstring

char scr_centerstring[1024]

Definition at line 187 of file cl_scrn.c.

Referenced by SCR_CenterPrint(), and SCR_DrawCenterString().

scr_centertime

cvar_t* scr_centertime

Definition at line 51 of file cl_scrn.c.

Referenced by SCR_CenterPrint(), and SCR_Init().

scr_centertime_off

float scr_centertime_off

Definition at line 189 of file cl_scrn.c.

Referenced by SCR_CenterPrint(), and SCR_CheckDrawCenterString().

scr_centertime_start

float scr_centertime_start

Definition at line 188 of file cl_scrn.c.

Referenced by SCR_CenterPrint().

scr_con_current

float scr_con_current

Definition at line 39 of file cl_scrn.c.

Referenced by SCR_DrawConsole(), SCR_RunConsole(), and SCR_TileClear().

scr_conlines

float scr_conlines

Definition at line 40 of file cl_scrn.c.

Referenced by SCR_RunConsole().

scr_conspeed

cvar_t* scr_conspeed

Definition at line 50 of file cl_scrn.c.

Referenced by SCR_Init(), and SCR_RunConsole().

scr_debuggraph

cvar_t* scr_debuggraph

Definition at line 58 of file cl_scrn.c.

Referenced by CL_AddNetgraph(), SCR_Init(), and SCR_UpdateScreen().

scr_dirty

dirty_t scr_dirty

Definition at line 72 of file cl_scrn.c.

Referenced by SCR_AddDirtyPoint().

scr_draw_loading

int scr_draw_loading

Definition at line 44 of file cl_scrn.c.

Referenced by SCR_BeginLoadingPlaque(), SCR_DrawLoading(), and SCR_UpdateScreen().

scr_drawall

cvar_t* scr_drawall

Definition at line 62 of file cl_scrn.c.

Referenced by SCR_Init().

scr_erase_center

int scr_erase_center

Definition at line 191 of file cl_scrn.c.

Referenced by SCR_DrawCenterString().

scr_graphheight

cvar_t* scr_graphheight

Definition at line 59 of file cl_scrn.c.

Referenced by SCR_DrawDebugGraph(), and SCR_Init().

scr_graphscale

cvar_t* scr_graphscale

Definition at line 60 of file cl_scrn.c.

Referenced by SCR_DrawDebugGraph(), and SCR_Init().

scr_graphshift

cvar_t* scr_graphshift

Definition at line 61 of file cl_scrn.c.

Referenced by SCR_DrawDebugGraph(), and SCR_Init().

scr_initialized

qboolean scr_initialized

Definition at line 42 of file cl_scrn.c.

Referenced by SCR_Init(), and SCR_UpdateScreen().

scr_netgraph

cvar_t* scr_netgraph

Definition at line 56 of file cl_scrn.c.

Referenced by SCR_Init(), and SCR_UpdateScreen().

scr_old_dirty

dirty_t scr_old_dirty[2]

Definition at line 72 of file cl_scrn.c.

scr_printspeed

cvar_t* scr_printspeed

Definition at line 54 of file cl_scrn.c.

Referenced by SCR_Init().

scr_showpause

cvar_t* scr_showpause

Definition at line 53 of file cl_scrn.c.

Referenced by SCR_DrawPause(), and SCR_Init().

scr_showturtle

cvar_t* scr_showturtle

Definition at line 52 of file cl_scrn.c.

Referenced by SCR_Init().

scr_timegraph

cvar_t* scr_timegraph

Definition at line 57 of file cl_scrn.c.

Referenced by CL_AddNetgraph(), SCR_Init(), and SCR_UpdateScreen().

scr_viewsize

cvar_t* scr_viewsize

Definition at line 49 of file cl_scrn.c.

Referenced by SCR_CalcVrect(), SCR_Init(), SCR_SizeDown_f(), SCR_SizeUp_f(), SCR_TileClear(), and VID_MenuInit().

scr_vrect

vrect_t scr_vrect

Definition at line 46 of file cl_scrn.c.

Referenced by SCR_CalcVrect(), SCR_DrawCrosshair(), SCR_DrawDebugGraph(), SCR_DrawNet(), SCR_TileClear(), and V_RenderView().

values

graphsamp_t values[1024]

static

Definition at line 130 of file cl_scrn.c.

Referenced by SCR_DebugGraph(), and SCR_DrawDebugGraph().

vid_hudscale

cvar_t* vid_hudscale

Definition at line 48 of file vid_dll.c.

Referenced by DrawHUDString(), SCR_DrawCenterString(), SCR_DrawPause(), SCR_ExecuteLayoutString(), and SizeHUDString().

vid_ref

cvar_t* vid_ref

Definition at line 44 of file vid_dll.c.

Referenced by SCR_UpdateScreen().