#include "quakedef.h"
#include "cl_video.h"
#include "image.h"
#include "jpeg.h"
#include "image_png.h"
#include "cl_collision.h"
#include "libcurl.h"
#include "csprogs.h"
#include "r_stats.h"
#include "snd_main.h"

Include dependency graph for cl_screen.c:

Data Structures
struct	envmapinfo_s

struct	loadingscreenstack_t

Functions
void	CL_Screen_Init (void)

void	CL_Screen_NewMap (void)

void	CL_Screen_Shutdown (void)

void	CL_UpdateScreen (void)

void	R_ClearScreen (qbool fogcolor)

static void	R_Envmap_f (cmd_state_t *cmd)

qbool	R_Stereo_Active (void)

qbool	R_Stereo_ColorMasking (void)

void	SCR_BeginLoadingPlaque (qbool startup)

void	SCR_CenterPrint (const char *str)

static void	SCR_Centerprint_f (cmd_state_t *cmd)

static void	SCR_CheckDrawCenterString (void)

static void	SCR_ChooseLoadingPic (qbool startup)

void	SCR_ClearLoadingScreen (qbool redraw)

static void	SCR_ClearLoadingScreenTexture (void)

void	SCR_DeferLoadingPlaque (qbool startup)

static void	SCR_DrawBrand (void)

static void	SCR_DrawCenterString (void)

void	SCR_DrawConsole (void)

static int	SCR_DrawCurlDownload (int offset)

static void	SCR_DrawInfobar (void)

static int	SCR_DrawInfobarString (int offset)

static void	SCR_DrawLoadingScreen (void)

static void	SCR_DrawLoadingStack (void)

static float	SCR_DrawLoadingStack_r (loadingscreenstack_t *s, float y, float size)

static void	SCR_DrawNet (void)

static void	SCR_DrawNetGraph (void)

static void	SCR_DrawNetGraph_DrawGraph (int graphx, int graphy, int graphwidth, int graphheight, float graphscale, int graphlimit, const char label, float textsize, int packetcounter, netgraphitem_t netgraph)

static void	SCR_DrawPause (void)

static int	SCR_DrawQWDownload (int offset)

static void	SCR_DrawScreen (void)

static void	SCR_DrawTouchscreenOverlay (void)

static void	SCR_DrawTurtle (void)

void	SCR_EndLoadingPlaque (void)

static void	SCR_InfoBar_f (cmd_state_t *cmd)

static int	SCR_InfobarHeight (void)

void	SCR_PopLoadingScreen (qbool redraw)

void	SCR_PushLoadingScreen (const char *msg, float len_in_parent)

qbool	SCR_ScreenShot (char filename, unsigned char buffer1, unsigned char *buffer2, int x, int y, int width, int height, qbool flipx, qbool flipy, qbool flipdiagonal, qbool jpeg, qbool png, qbool gammacorrect, qbool keep_alpha)

static void	SCR_ScreenShot_f (cmd_state_t *cmd)

static void	SCR_SetLoadingScreenTexture (void)

static void	SCR_SetUpToDrawConsole (void)

static void	SCR_SizeDown_f (cmd_state_t *cmd)

static void	SCR_SizeUp_f (cmd_state_t *cmd)

static void	SCR_UpdateVars (void)

void	SHOWLMP_decodehide (void)

void	SHOWLMP_decodeshow (void)

void	SHOWLMP_drawall (void)

Variables
char	cl_connect_status [MAX_QPATH]
	User-friendly connection status for the menu and/or loading screen, colours and not supported.

cvar_t	cl_demo_mousegrab = {CF_CLIENT, "cl_demo_mousegrab", "0", "Allows reading the mouse input while playing demos. Useful for camera mods developed in csqc. (0: never, 1: always)"}

cvar_t	cl_minfps

cvar_t	cl_minfps_fade

cvar_t	cl_minfps_force

cvar_t	cl_minfps_qualityhysteresis

cvar_t	cl_minfps_qualitymax

cvar_t	cl_minfps_qualitymin

cvar_t	cl_minfps_qualitymultiply

cvar_t	cl_minfps_qualitystepmax

int	cl_punchangle_applied

int	con_vislines

struct envmapinfo_s	envmapinfo [12]

int	jpeg_supported = false

static int	loadingscreenpic_number = 0

static loadingscreenstack_t *	loadingscreenstack = NULL

rtexture_t *	loadingscreentexture = NULL

static float	loadingscreentexture_texcoord2f [8]

static float	loadingscreentexture_vertex3f [12]

cvar_t	net_graph = {CF_CLIENT \| CF_ARCHIVE, "net_graph", "0", "shows a graph of packet sizes and other information, 0 = off, 1 = show client netgraph, 2 = show client and server netgraphs (when hosting a server)"}

cvar_t	r_fog_clear

cvar_t	r_letterbox = {CF_CLIENT, "r_letterbox", "0", "reduces vertical height of view to simulate a letterboxed movie effect (can be used by mods for cutscenes)"}

rtexturepool_t *	r_main_texturepool

cvar_t	r_stereo_angle = {CF_CLIENT, "r_stereo_angle", "0", "separation angle of eyes (makes the views look different directions, as an example, 90 gives a 90 degree separation where the views are 45 degrees left and 45 degrees right)"}

cvar_t	r_stereo_horizontal = {CF_CLIENT, "r_stereo_horizontal", "0", "aspect skewed side by side view for special decoder/display hardware"}

cvar_t	r_stereo_redblue = {CF_CLIENT, "r_stereo_redblue", "0", "red/blue anaglyph stereo glasses (note: most of these glasses are actually red/cyan, try that one too)"}

cvar_t	r_stereo_redcyan = {CF_CLIENT, "r_stereo_redcyan", "0", "red/cyan anaglyph stereo glasses, the kind given away at drive-in movies like Creature From The Black Lagoon In 3D"}

cvar_t	r_stereo_redgreen = {CF_CLIENT, "r_stereo_redgreen", "0", "red/green anaglyph stereo glasses (for those who don't mind yellow)"}

cvar_t	r_stereo_separation = {CF_CLIENT, "r_stereo_separation", "4", "separation distance of eyes in the world (negative values are only useful for cross-eyed viewing)"}

int	r_stereo_side

cvar_t	r_stereo_sidebyside = {CF_CLIENT, "r_stereo_sidebyside", "0", "side by side views for those who can't afford glasses but can afford eye strain (note: use a negative r_stereo_separation if you want cross-eyed viewing)"}

cvar_t	r_stereo_vertical = {CF_CLIENT, "r_stereo_vertical", "0", "aspect skewed top and bottom view for special decoder/display hardware"}

cvar_t	sbar_info_pos

int	scr_center_lines

char	scr_centerstring [MAX_INPUTLINE]

cvar_t	scr_centertime = {CF_CLIENT, "scr_centertime","2", "how long centerprint messages show"}

float	scr_centertime_off

float	scr_centertime_start

unsigned int	scr_con_current

static unsigned int	scr_con_margin_bottom

cvar_t	scr_conalpha = {CF_CLIENT \| CF_ARCHIVE, "scr_conalpha", "0.9", "opacity of console background gfx/conback (when console isn't forced fullscreen)"}

cvar_t	scr_conalpha2factor = {CF_CLIENT \| CF_ARCHIVE, "scr_conalpha2factor", "0", "opacity of console background gfx/conback2 relative to scr_conalpha; when 0, gfx/conback2 is not drawn"}

cvar_t	scr_conalpha3factor = {CF_CLIENT \| CF_ARCHIVE, "scr_conalpha3factor", "0", "opacity of console background gfx/conback3 relative to scr_conalpha; when 0, gfx/conback3 is not drawn"}

cvar_t	scr_conalphafactor = {CF_CLIENT \| CF_ARCHIVE, "scr_conalphafactor", "1", "opacity of console background gfx/conback relative to scr_conalpha; when 0, gfx/conback is not drawn"}

cvar_t	scr_conbrightness = {CF_CLIENT \| CF_ARCHIVE, "scr_conbrightness", "1", "brightness of console background (0 = black, 1 = image)"}

cvar_t	scr_conforcewhiledisconnected = {CF_CLIENT, "scr_conforcewhiledisconnected", "1", "1 forces fullscreen console while disconnected, 2 also forces it when the listen server has started but the client is still loading"}

cvar_t	scr_conheight = {CF_CLIENT \| CF_ARCHIVE, "scr_conheight", "0.5", "fraction of screen height occupied by console (reduced as necessary for visibility of loading progress and infobar)"}

cvar_t	scr_conscroll2_x = {CF_CLIENT \| CF_ARCHIVE, "scr_conscroll2_x", "0", "scroll speed of gfx/conback2 in x direction"}

cvar_t	scr_conscroll2_y = {CF_CLIENT \| CF_ARCHIVE, "scr_conscroll2_y", "0", "scroll speed of gfx/conback2 in y direction"}

cvar_t	scr_conscroll3_x = {CF_CLIENT \| CF_ARCHIVE, "scr_conscroll3_x", "0", "scroll speed of gfx/conback3 in x direction"}

cvar_t	scr_conscroll3_y = {CF_CLIENT \| CF_ARCHIVE, "scr_conscroll3_y", "0", "scroll speed of gfx/conback3 in y direction"}

cvar_t	scr_conscroll_x = {CF_CLIENT \| CF_ARCHIVE, "scr_conscroll_x", "0", "scroll speed of gfx/conback in x direction"}

cvar_t	scr_conscroll_y = {CF_CLIENT \| CF_ARCHIVE, "scr_conscroll_y", "0", "scroll speed of gfx/conback in y direction"}

int	scr_erase_center

int	scr_erase_lines

cvar_t	scr_fov = {CF_CLIENT \| CF_ARCHIVE, "fov","90", "field of vision, 1-170 degrees, default 90, some players use 110-130"}

cvar_t	scr_infobar_height = {CF_CLIENT, "scr_infobar_height", "8", "the height of the infobar items"}

char	scr_infobarstring [MAX_INPUTLINE]

float	scr_infobartime_off

qbool	scr_initialized

qbool	scr_loading = false

cvar_t	scr_loadingscreen_background = {CF_CLIENT, "scr_loadingscreen_background","0", "show the last visible background during loading screen (costs one screenful of video memory)"}

cvar_t	scr_loadingscreen_barcolor = {CF_CLIENT, "scr_loadingscreen_barcolor", "0 0 1", "rgb color of loadingscreen progress bar"}

cvar_t	scr_loadingscreen_barheight = {CF_CLIENT, "scr_loadingscreen_barheight", "8", "the height of the loadingscreen progress bar"}

cvar_t	scr_loadingscreen_count = {CF_CLIENT, "scr_loadingscreen_count","1", "number of loading screen files to use randomly (named loading.tga, loading2.tga, loading3.tga, ...)"}

cvar_t	scr_loadingscreen_firstforstartup = {CF_CLIENT, "scr_loadingscreen_firstforstartup","0", "remove loading.tga from random scr_loadingscreen_count selection and only display it on client startup, 0 = normal, 1 = firstforstartup"}

cvar_t	scr_loadingscreen_maxfps = {CF_CLIENT, "scr_loadingscreen_maxfps", "20", "maximum FPS for loading screen so it will not update very often (this reduces loading time with lots of models)"}

cvar_t	scr_loadingscreen_picture = {CF_CLIENT, "scr_loadingscreen_picture", "gfx/loading", "picture shown during loading"}

cvar_t	scr_loadingscreen_scale = {CF_CLIENT, "scr_loadingscreen_scale","1", "scale factor of the background"}

cvar_t	scr_loadingscreen_scale_base = {CF_CLIENT, "scr_loadingscreen_scale_base","0", "0 = console pixels, 1 = video pixels"}

cvar_t	scr_loadingscreen_scale_limit = {CF_CLIENT, "scr_loadingscreen_scale_limit","0", "0 = no limit, 1 = until first edge hits screen edge, 2 = until last edge hits screen edge, 3 = until width hits screen width, 4 = until height hits screen height"}

int	scr_numtouchscreenareas

cvar_t	scr_printspeed = {CF_CLIENT, "scr_printspeed","0", "speed of intermission printing (episode end texts), a value of 0 disables the slow printing"}

cvar_t	scr_refresh = {CF_CLIENT, "scr_refresh", "1", "allows you to completely shut off rendering for benchmarking purposes"}

cvar_t	scr_sbarscale = {CF_CLIENT \| CF_READONLY, "scr_sbarscale", "1", "current vid_height/vid_conheight, for compatibility with csprogs that read this cvar (found in Fitzquake-derived engines and FTEQW; despite the name it's not specific to the status bar)"}

cvar_t	scr_screenshot_alpha = {CF_CLIENT, "scr_screenshot_alpha","0", "try to write an alpha channel to screenshots (debugging feature)"}

cvar_t	scr_screenshot_gammaboost = {CF_CLIENT \| CF_ARCHIVE, "scr_screenshot_gammaboost","1", "gamma correction on saved screenshots and videos, 1.0 saves unmodified images"}

cvar_t	scr_screenshot_jpeg = {CF_CLIENT \| CF_ARCHIVE, "scr_screenshot_jpeg","1", "save jpeg instead of targa or PNG"}

cvar_t	scr_screenshot_jpeg_quality = {CF_CLIENT \| CF_ARCHIVE, "scr_screenshot_jpeg_quality","0.9", "image quality of saved jpeg"}

cvar_t	scr_screenshot_name_in_mapdir = {CF_CLIENT \| CF_ARCHIVE, "scr_screenshot_name_in_mapdir", "0", "if set to 1, screenshots are placed in a subdirectory named like the map they are from"}

cvar_t	scr_screenshot_png = {CF_CLIENT \| CF_ARCHIVE, "scr_screenshot_png","0", "save png instead of targa"}

cvar_t	scr_screenshot_timestamp = {CF_CLIENT \| CF_ARCHIVE, "scr_screenshot_timestamp", "1", "use a timestamp based number of the type YYYYMMDDHHMMSSsss instead of sequential numbering"}

cvar_t	scr_showbrand = {CF_CLIENT, "showbrand","0", "shows gfx/brand.tga in a corner of the screen (different values select different positions, including centered)"}

cvar_t	scr_showpause = {CF_CLIENT \| CF_ARCHIVE, "showpause","1", "show pause icon when game is paused"}

cvar_t	scr_showram = {CF_CLIENT \| CF_ARCHIVE, "showram","1", "show ram icon if low on surface cache memory (not used)"}

cvar_t	scr_showturtle = {CF_CLIENT \| CF_ARCHIVE, "showturtle","0", "show turtle icon when framerate is too low"}

cvar_t	scr_stipple = {CF_CLIENT, "scr_stipple", "0", "interlacing-like stippling of the display"}

scr_touchscreenarea_t	scr_touchscreenareas [128]

cvar_t	scr_viewsize = {CF_CLIENT \| CF_ARCHIVE, "viewsize","100", "how large the view should be, 110 disables inventory bar, 120 disables status bar"}

cvar_t	timedemo_screenshotframelist = {CF_CLIENT, "timedemo_screenshotframelist", "", "when performing a timedemo, take screenshots of each frame in this space-separated list - example: 1 201 401"}

cvar_t	v_isometric

cvar_t	v_isometric_verticalfov

cvar_t	vid_conheight = {CF_CLIENT \| CF_ARCHIVE, "vid_conheight", "480", "virtual height of 2D graphics system"}

cvar_t	vid_conwidth = {CF_CLIENT \| CF_ARCHIVE, "vid_conwidth", "640", "virtual width of 2D graphics system (note: changes may be overwritten, see vid_conwidthauto)"}

cvar_t	vid_conwidthauto = {CF_CLIENT \| CF_ARCHIVE, "vid_conwidthauto", "1", "automatically update vid_conwidth to match aspect ratio"}

cvar_t	vid_pixelheight = {CF_CLIENT \| CF_ARCHIVE, "vid_pixelheight", "1", "adjusts vertical field of vision to account for non-square pixels (1280x1024 on a CRT monitor for example)"}

cvar_t	vid_touchscreen_outlinealpha = {CF_CLIENT, "vid_touchscreen_outlinealpha", "0", "opacity of touchscreen area outlines"}

cvar_t	vid_touchscreen_overlayalpha = {CF_CLIENT, "vid_touchscreen_overlayalpha", "0.25", "opacity of touchscreen area icons"}

Function Documentation

◆ CL_Screen_Init()

void CL_Screen_Init ( void )

Definition at line 804 of file cl_screen.c.

{
    int i;
    Cvar_RegisterVariable (&scr_fov);
    Cvar_RegisterVariable (&scr_viewsize);
    Cvar_RegisterVariable (&scr_conalpha);
    Cvar_RegisterVariable (&scr_conalphafactor);
    Cvar_RegisterVariable (&scr_conalpha2factor);
    Cvar_RegisterVariable (&scr_conalpha3factor);
    Cvar_RegisterVariable (&scr_conscroll_x);
    Cvar_RegisterVariable (&scr_conscroll_y);
    Cvar_RegisterVariable (&scr_conscroll2_x);
    Cvar_RegisterVariable (&scr_conscroll2_y);
    Cvar_RegisterVariable (&scr_conscroll3_x);
    Cvar_RegisterVariable (&scr_conscroll3_y);
    Cvar_RegisterVariable (&scr_conbrightness);
    Cvar_RegisterVariable (&scr_conforcewhiledisconnected);
    Cvar_RegisterVariable (&scr_conheight);
#ifdef CONFIG_MENU
    Cvar_RegisterVariable (&scr_menuforcewhiledisconnected);
#endif
    Cvar_RegisterVariable (&scr_loadingscreen_background);
    Cvar_RegisterVariable (&scr_loadingscreen_scale);
    Cvar_RegisterVariable (&scr_loadingscreen_scale_base);
    Cvar_RegisterVariable (&scr_loadingscreen_scale_limit);
    Cvar_RegisterVariable (&scr_loadingscreen_picture);
    Cvar_RegisterVariable (&scr_loadingscreen_count);
    Cvar_RegisterVariable (&scr_loadingscreen_firstforstartup);
    Cvar_RegisterVariable (&scr_loadingscreen_barcolor);
    Cvar_RegisterVariable (&scr_loadingscreen_barheight);
    Cvar_RegisterVariable (&scr_loadingscreen_maxfps);
    Cvar_RegisterVariable (&scr_infobar_height);
    Cvar_RegisterVariable (&scr_showram);
    Cvar_RegisterVariable (&scr_showturtle);
    Cvar_RegisterVariable (&scr_showpause);
    Cvar_RegisterVariable (&scr_showbrand);
    Cvar_RegisterVariable (&scr_centertime);
    Cvar_RegisterVariable (&scr_printspeed);
    Cvar_RegisterVariable (&scr_sbarscale);
    Cvar_RegisterVariable (&vid_conwidth);
    Cvar_RegisterVariable (&vid_conheight);
    Cvar_RegisterVariable (&vid_pixelheight);
    Cvar_RegisterVariable (&vid_conwidthauto);
    Cvar_RegisterVariable (&scr_screenshot_jpeg);
    Cvar_RegisterVariable (&scr_screenshot_jpeg_quality);
    Cvar_RegisterVariable (&scr_screenshot_png);
    Cvar_RegisterVariable (&scr_screenshot_gammaboost);
    Cvar_RegisterVariable (&scr_screenshot_name_in_mapdir);
    Cvar_RegisterVariable (&scr_screenshot_alpha);
    Cvar_RegisterVariable (&scr_screenshot_timestamp);
#ifdef CONFIG_VIDEO_CAPTURE
    Cvar_RegisterVariable (&cl_capturevideo);
    Cvar_RegisterVariable (&cl_capturevideo_demo_stop);
    Cvar_RegisterVariable (&cl_capturevideo_printfps);
    Cvar_RegisterVariable (&cl_capturevideo_width);
    Cvar_RegisterVariable (&cl_capturevideo_height);
    Cvar_RegisterVariable (&cl_capturevideo_realtime);
    Cvar_RegisterVariable (&cl_capturevideo_fps);
    Cvar_RegisterVariable (&cl_capturevideo_nameformat);
    Cvar_RegisterVariable (&cl_capturevideo_number);
    Cvar_RegisterVariable (&cl_capturevideo_ogg);
    Cvar_RegisterVariable (&cl_capturevideo_framestep);
#endif
    Cvar_RegisterVariable (&r_letterbox);
    Cvar_RegisterVariable(&r_stereo_separation);
    Cvar_RegisterVariable(&r_stereo_sidebyside);
    Cvar_RegisterVariable(&r_stereo_horizontal);
    Cvar_RegisterVariable(&r_stereo_vertical);
    Cvar_RegisterVariable(&r_stereo_redblue);
    Cvar_RegisterVariable(&r_stereo_redcyan);
    Cvar_RegisterVariable(&r_stereo_redgreen);
    Cvar_RegisterVariable(&r_stereo_angle);
    Cvar_RegisterVariable(&scr_stipple);
    Cvar_RegisterVariable(&scr_refresh);
    Cvar_RegisterVariable(&net_graph);
    Cvar_RegisterVirtual(&net_graph, "shownetgraph");
    Cvar_RegisterVariable(&cl_demo_mousegrab);
    Cvar_RegisterVariable(&timedemo_screenshotframelist);
    Cvar_RegisterVariable(&vid_touchscreen_outlinealpha);
    Cvar_RegisterVariable(&vid_touchscreen_overlayalpha);
    Cvar_RegisterVariable(&r_speeds_graph);
    for (i = 0;i < (int)(sizeof(r_speeds_graph_filter)/sizeof(r_speeds_graph_filter[0]));i++)
        Cvar_RegisterVariable(&r_speeds_graph_filter[i]);
    Cvar_RegisterVariable(&r_speeds_graph_length);
    Cvar_RegisterVariable(&r_speeds_graph_seconds);
    Cvar_RegisterVariable(&r_speeds_graph_x);
    Cvar_RegisterVariable(&r_speeds_graph_y);
    Cvar_RegisterVariable(&r_speeds_graph_width);
    Cvar_RegisterVariable(&r_speeds_graph_height);
    Cvar_RegisterVariable(&r_speeds_graph_maxtimedelta);
    Cvar_RegisterVariable(&r_speeds_graph_maxdefault);
 
    // if we want no console, turn it off here too
    if (Sys_CheckParm ("-noconsole"))
        Cvar_SetQuick(&scr_conforcewhiledisconnected, "0");
 
    Cmd_AddCommand(CF_CLIENT, "cprint", SCR_Centerprint_f, "print something at the screen center");
    Cmd_AddCommand(CF_CLIENT, "sizeup",SCR_SizeUp_f, "increase view size (increases viewsize cvar)");
    Cmd_AddCommand(CF_CLIENT, "sizedown",SCR_SizeDown_f, "decrease view size (decreases viewsize cvar)");
    Cmd_AddCommand(CF_CLIENT, "screenshot",SCR_ScreenShot_f, "takes a screenshot of the next rendered frame");
    Cmd_AddCommand(CF_CLIENT, "envmap", R_Envmap_f, "render a cubemap (skybox) of the current scene");
    Cmd_AddCommand(CF_CLIENT, "infobar", SCR_InfoBar_f, "display a text in the infobar (usage: infobar expiretime string)");
 
#ifdef CONFIG_VIDEO_CAPTURE
    SCR_CaptureVideo_Ogg_Init();
#endif
 
    scr_initialized = true;
}

Referenced by CL_Init().

◆ CL_Screen_NewMap()

void CL_Screen_NewMap ( void )

Definition at line 2346 of file cl_screen.c.

2347{

2348}

Referenced by CL_ClearState().

◆ CL_Screen_Shutdown()

void CL_Screen_Shutdown ( void )

Definition at line 797 of file cl_screen.c.

{
#ifdef CONFIG_VIDEO_CAPTURE
    SCR_CaptureVideo_EndVideo();
#endif
}

Referenced by CL_Shutdown().

◆ CL_UpdateScreen()

void CL_UpdateScreen ( void )

Definition at line 2130 of file cl_screen.c.

{
    static double cl_updatescreen_quality = 1;
 
    vec3_t vieworigin;
    static double drawscreenstart = 0.0;
    double drawscreendelta;
    r_viewport_t viewport;
 
    // TODO: Move to a better place.
    cl_punchangle_applied = 0;
 
    if(drawscreenstart)
    {
        drawscreendelta = Sys_DirtyTime() - drawscreenstart;
#ifdef CONFIG_VIDEO_CAPTURE
        if (cl_minfps.value > 0 && (cl_minfps_force.integer || !(cls.timedemo || (cls.capturevideo.active && !cls.capturevideo.realtime))) && drawscreendelta >= 0 && drawscreendelta < 60)
#else
        if (cl_minfps.value > 0 && (cl_minfps_force.integer || !cls.timedemo) && drawscreendelta >= 0 && drawscreendelta < 60)
#endif
        {
            // quality adjustment according to render time
            double actualframetime;
            double targetframetime;
            double adjust;
            double f;
            double h;
 
            // fade lastdrawscreentime
            r_refdef.lastdrawscreentime += (drawscreendelta - r_refdef.lastdrawscreentime) * cl_minfps_fade.value;
 
            // find actual and target frame times
            actualframetime = r_refdef.lastdrawscreentime;
            targetframetime = (1.0 / cl_minfps.value);
 
            // we scale hysteresis by quality
            h = cl_updatescreen_quality * cl_minfps_qualityhysteresis.value;
 
            // calculate adjustment assuming linearity
            f = cl_updatescreen_quality / actualframetime * cl_minfps_qualitymultiply.value;
            adjust = (targetframetime - actualframetime) * f;
 
            // one sided hysteresis
            if(adjust > 0)
                adjust = max(0, adjust - h);
 
            // adjust > 0 if:
            //   (targetframetime - actualframetime) * f > h
            //   ((1.0 / cl_minfps.value) - actualframetime) * (cl_updatescreen_quality / actualframetime * cl_minfps_qualitymultiply.value) > (cl_updatescreen_quality * cl_minfps_qualityhysteresis.value)
            //   ((1.0 / cl_minfps.value) - actualframetime) * (cl_minfps_qualitymultiply.value / actualframetime) > cl_minfps_qualityhysteresis.value
            //   (1.0 / cl_minfps.value) * (cl_minfps_qualitymultiply.value / actualframetime) - cl_minfps_qualitymultiply.value > cl_minfps_qualityhysteresis.value
            //   (1.0 / cl_minfps.value) * (cl_minfps_qualitymultiply.value / actualframetime) > cl_minfps_qualityhysteresis.value + cl_minfps_qualitymultiply.value
            //   (1.0 / cl_minfps.value) / actualframetime > (cl_minfps_qualityhysteresis.value + cl_minfps_qualitymultiply.value) / cl_minfps_qualitymultiply.value
            //   (1.0 / cl_minfps.value) / actualframetime > 1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value
            //   cl_minfps.value * actualframetime < 1.0 / (1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value)
            //   actualframetime < 1.0 / cl_minfps.value / (1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value)
            //   actualfps > cl_minfps.value * (1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value)
 
            // adjust < 0 if:
            //   (targetframetime - actualframetime) * f < 0
            //   ((1.0 / cl_minfps.value) - actualframetime) * (cl_updatescreen_quality / actualframetime * cl_minfps_qualitymultiply.value) < 0
            //   ((1.0 / cl_minfps.value) - actualframetime) < 0
            //   -actualframetime) < -(1.0 / cl_minfps.value)
            //   actualfps < cl_minfps.value
 
            /*
            Con_Printf("adjust UP if fps > %f, adjust DOWN if fps < %f\n",
                    cl_minfps.value * (1.0 + cl_minfps_qualityhysteresis.value / cl_minfps_qualitymultiply.value),
                    cl_minfps.value);
            */
 
            // don't adjust too much at once
            adjust = bound(-cl_minfps_qualitystepmax.value, adjust, cl_minfps_qualitystepmax.value);
 
            // adjust!
            cl_updatescreen_quality += adjust;
            cl_updatescreen_quality = bound(max(0.01, cl_minfps_qualitymin.value), cl_updatescreen_quality, cl_minfps_qualitymax.value);
        }
        else
        {
            cl_updatescreen_quality = 1;
            r_refdef.lastdrawscreentime = 0;
        }
    }
 
    drawscreenstart = Sys_DirtyTime();
 
    Sbar_ShowFPS_Update();
 
    if (!scr_initialized || !con_initialized || !scr_refresh.integer)
        return;             // not initialized yet
 
    if(IS_NEXUIZ_DERIVED(gamemode))
    {
        // play a bit with the palette (experimental)
        palette_rgb_pantscolormap[15][0] = (unsigned char) (128 + 127 * sin(cl.time / exp(1.0f) + 0.0f*M_PI/3.0f));
        palette_rgb_pantscolormap[15][1] = (unsigned char) (128 + 127 * sin(cl.time / exp(1.0f) + 2.0f*M_PI/3.0f));
        palette_rgb_pantscolormap[15][2] = (unsigned char) (128 + 127 * sin(cl.time / exp(1.0f) + 4.0f*M_PI/3.0f));
        palette_rgb_shirtcolormap[15][0] = (unsigned char) (128 + 127 * sin(cl.time /  M_PI  + 5.0f*M_PI/3.0f));
        palette_rgb_shirtcolormap[15][1] = (unsigned char) (128 + 127 * sin(cl.time /  M_PI  + 3.0f*M_PI/3.0f));
        palette_rgb_shirtcolormap[15][2] = (unsigned char) (128 + 127 * sin(cl.time /  M_PI  + 1.0f*M_PI/3.0f));
        memcpy(palette_rgb_pantsscoreboard[15], palette_rgb_pantscolormap[15], sizeof(*palette_rgb_pantscolormap));
        memcpy(palette_rgb_shirtscoreboard[15], palette_rgb_shirtcolormap[15], sizeof(*palette_rgb_shirtcolormap));
    }
 
#ifdef CONFIG_VIDEO_CAPTURE
    if (vid_hidden && !cls.capturevideo.active
    && !cl_capturevideo.integer) // so we can start capturing while hidden
#else
    if (vid_hidden)
#endif
    {
        VID_Finish();
        return;
    }
 
    if (scr_loading)
    {
        if(!loadingscreenstack && !cls.connect_trying && (cls.state != ca_connected || cls.signon == SIGNONS))
            SCR_EndLoadingPlaque();
        else if (scr_loadingscreen_maxfps.value > 0)
        {
            static double lastupdate;
            if (host.realtime - lastupdate < min(1.0f / scr_loadingscreen_maxfps.value, 0.1))
                return;
            lastupdate = host.realtime;
        }
    }
 
    SCR_UpdateVars();
 
    R_FrameData_NewFrame();
    R_BufferData_NewFrame();
 
    Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, vieworigin);
    R_HDR_UpdateIrisAdaptation(vieworigin);
 
    r_refdef.view.colormask[0] = 1;
    r_refdef.view.colormask[1] = 1;
    r_refdef.view.colormask[2] = 1;
 
    SCR_SetUpToDrawConsole();
 
#ifndef USE_GLES2
    CHECKGLERROR
    qglDrawBuffer(GL_BACK);CHECKGLERROR
#endif
 
    R_Viewport_InitOrtho(&viewport, &identitymatrix, 0, 0, vid.mode.width, vid.mode.height, 0, 0, vid_conwidth.integer, vid_conheight.integer, -10, 100, NULL);
    R_Mesh_SetRenderTargets(0);
    R_SetViewport(&viewport);
    GL_ScissorTest(false);
    GL_ColorMask(1,1,1,1);
    GL_DepthMask(true);
 
    R_ClearScreen(false);
    r_refdef.view.clear = false;
    r_refdef.view.isoverlay = false;
 
    // calculate r_refdef.view.quality
    r_refdef.view.quality = cl_updatescreen_quality;
 
    if(scr_stipple.integer)
    {
        Con_Print("FIXME: scr_stipple not implemented\n");
        Cvar_SetValueQuick(&scr_stipple, 0);
    }
 
#ifndef USE_GLES2
    if (R_Stereo_Active())
    {
        r_stereo_side = 0;
 
        if (r_stereo_redblue.integer || r_stereo_redgreen.integer || r_stereo_redcyan.integer)
        {
            r_refdef.view.colormask[0] = 1;
            r_refdef.view.colormask[1] = 0;
            r_refdef.view.colormask[2] = 0;
        }
 
        if (vid.mode.stereobuffer)
            qglDrawBuffer(GL_BACK_RIGHT);
 
        SCR_DrawScreen();
 
        r_stereo_side = 1;
        r_refdef.view.clear = true;
 
        if (r_stereo_redblue.integer || r_stereo_redgreen.integer || r_stereo_redcyan.integer)
        {
            r_refdef.view.colormask[0] = 0;
            r_refdef.view.colormask[1] = r_stereo_redcyan.integer || r_stereo_redgreen.integer;
            r_refdef.view.colormask[2] = r_stereo_redcyan.integer || r_stereo_redblue.integer;
        }
 
        if (vid.mode.stereobuffer)
            qglDrawBuffer(GL_BACK_LEFT);
 
        SCR_DrawScreen();
        r_stereo_side = 0;
    }
    else
#endif
    {
        r_stereo_side = 0;
        SCR_DrawScreen();
    }
 
#ifdef CONFIG_VIDEO_CAPTURE
    SCR_CaptureVideo();
#endif
 
    qglFlush(); // ensure that the commands are submitted to the GPU before we do other things
    VID_Finish();
}

References bound, ca_connected, CHECKGLERROR, cl, cl_minfps, cl_minfps_fade, cl_minfps_force, cl_minfps_qualityhysteresis, cl_minfps_qualitymax, cl_minfps_qualitymin, cl_minfps_qualitymultiply, cl_minfps_qualitystepmax, cl_punchangle_applied, r_refdef_view_t::clear, cls, r_refdef_view_t::colormask, con_initialized, Con_Print(), client_static_t::connect_trying, Cvar_SetValueQuick(), f, gamemode, GL_BACK, GL_BACK_LEFT, GL_BACK_RIGHT, GL_ColorMask(), GL_DepthMask(), GL_ScissorTest(), viddef_mode_t::height, host, identitymatrix, cvar_t::integer, IS_NEXUIZ_DERIVED, r_refdef_view_t::isoverlay, r_refdef_t::lastdrawscreentime, loadingscreenstack, M_PI, r_refdef_view_t::matrix, Matrix4x4_OriginFromMatrix(), max, min, viddef_t::mode, NULL, palette_rgb_pantscolormap, palette_rgb_pantsscoreboard, palette_rgb_shirtcolormap, palette_rgb_shirtscoreboard, r_refdef_view_t::quality, R_BufferData_NewFrame(), R_ClearScreen(), R_FrameData_NewFrame(), R_HDR_UpdateIrisAdaptation(), R_Mesh_SetRenderTargets(), r_refdef, R_SetViewport(), R_Stereo_Active(), r_stereo_redblue, r_stereo_redcyan, r_stereo_redgreen, r_stereo_side, R_Viewport_InitOrtho(), host_static_t::realtime, Sbar_ShowFPS_Update(), SCR_DrawScreen(), SCR_EndLoadingPlaque(), scr_initialized, scr_loading, scr_loadingscreen_maxfps, scr_refresh, SCR_SetUpToDrawConsole(), scr_stipple, SCR_UpdateVars(), client_static_t::signon, SIGNONS, sin(), client_static_t::state, viddef_mode_t::stereobuffer, Sys_DirtyTime(), client_state_t::time, client_static_t::timedemo, cvar_t::value, vid, vid_conheight, vid_conwidth, VID_Finish(), vid_hidden, r_refdef_t::view, and viddef_mode_t::width.

Referenced by CL_Frame(), CL_TimeRefresh_f(), Key_Console(), SCR_BeginLoadingPlaque(), SCR_PopLoadingScreen(), and SCR_PushLoadingScreen().

◆ R_ClearScreen()

void R_ClearScreen ( qbool fogcolor )

Definition at line 1534 of file cl_screen.c.

{
    float clearcolor[4];
    if (scr_screenshot_alpha.integer)
        // clear to transparency (so png screenshots can contain alpha channel, useful for building model pictures)
        Vector4Set(clearcolor, 0.0f, 0.0f, 0.0f, 0.0f);
    else
        // clear to opaque black (if we're being composited it might otherwise render as transparent)
        Vector4Set(clearcolor, 0.0f, 0.0f, 0.0f, 1.0f);
    if (fogcolor && r_fog_clear.integer)
    {
        R_UpdateFog();
        VectorCopy(r_refdef.fogcolor, clearcolor);
    }
    // clear depth is 1.0
    // clear the screen
    GL_Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | (vid.stencil ? GL_STENCIL_BUFFER_BIT : 0), clearcolor, 1.0f, 0);
}

References r_refdef_t::fogcolor, GL_Clear(), GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_STENCIL_BUFFER_BIT, cvar_t::integer, r_fog_clear, r_refdef, R_UpdateFog(), scr_screenshot_alpha, viddef_t::stencil, Vector4Set, VectorCopy, and vid.

Referenced by CL_UpdateScreen(), R_RenderView(), and R_Water_ProcessPlanes().

◆ R_Envmap_f()

static void R_Envmap_f ( cmd_state_t * cmd )

static

Definition at line 1291 of file cl_screen.c.

{
    int j, size;
    char filename[MAX_QPATH], basename[MAX_QPATH];
    unsigned char *buffer1;
    unsigned char *buffer2;
    r_rendertarget_t *rt;
 
    if (Cmd_Argc(cmd) != 3)
    {
        Con_Print("envmap <basename> <size>: save out 6 cubic environment map images, usable with loadsky, note that size must one of 128, 256, 512, or 1024 and can't be bigger than your current resolution\n");
        return;
    }
 
    if(cls.state != ca_connected) {
        Con_Printf("envmap: No map loaded\n");
        return;
    }
 
    dp_strlcpy (basename, Cmd_Argv(cmd, 1), sizeof (basename));
    size = atoi(Cmd_Argv(cmd, 2));
    if (size != 128 && size != 256 && size != 512 && size != 1024)
    {
        Con_Print("envmap: size must be one of 128, 256, 512, or 1024\n");
        return;
    }
    if (size > vid.mode.width || size > vid.mode.height)
    {
        Con_Print("envmap: your resolution is not big enough to render that size\n");
        return;
    }
 
    r_refdef.envmap = true;
 
    R_UpdateVariables();
 
    r_refdef.view.x = 0;
    r_refdef.view.y = 0;
    r_refdef.view.z = 0;
    r_refdef.view.width = size;
    r_refdef.view.height = size;
    r_refdef.view.depth = 1;
    r_refdef.view.useperspective = true;
    r_refdef.view.isoverlay = false;
    r_refdef.view.ismain = true;
 
    r_refdef.view.frustum_x = 1; // tan(45 * M_PI / 180.0);
    r_refdef.view.frustum_y = 1; // tan(45 * M_PI / 180.0);
    r_refdef.view.ortho_x = 90; // abused as angle by VM_CL_R_SetView
    r_refdef.view.ortho_y = 90; // abused as angle by VM_CL_R_SetView
 
    buffer1 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 4);
    buffer2 = (unsigned char *)Mem_Alloc(tempmempool, size * size * 3);
 
    // TODO: use TEXTYPE_COLORBUFFER16F and output to .exr files as well?
    rt = R_RenderTarget_Get(size, size, TEXTYPE_DEPTHBUFFER24STENCIL8, true, TEXTYPE_COLORBUFFER, TEXTYPE_UNUSED, TEXTYPE_UNUSED, TEXTYPE_UNUSED);
    CL_UpdateEntityShading();
    for (j = 0;j < 12;j++)
    {
        dpsnprintf(filename, sizeof(filename), "env/%s%s.tga", basename, envmapinfo[j].name);
        Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, r_refdef.view.origin[0], r_refdef.view.origin[1], r_refdef.view.origin[2], envmapinfo[j].angles[0], envmapinfo[j].angles[1], envmapinfo[j].angles[2], 1);
        r_refdef.view.quality = 1;
        r_refdef.view.clear = true;
        R_Mesh_Start();
        R_RenderView(rt->fbo, rt->depthtexture, rt->colortexture[0], 0, 0, size, size);
        R_Mesh_Finish();
        SCR_ScreenShot(filename, buffer1, buffer2, 0, vid.mode.height - (r_refdef.view.y + r_refdef.view.height), size, size, envmapinfo[j].flipx, envmapinfo[j].flipy, envmapinfo[j].flipdiagonaly, false, false, false, false);
    }
 
    Mem_Free (buffer1);
    Mem_Free (buffer2);
 
    r_refdef.envmap = false;
}

References envmapinfo_s::angles, ca_connected, CL_UpdateEntityShading(), r_refdef_view_t::clear, cls, cmd(), Cmd_Argc(), Cmd_Argv(), r_rendertarget_t::colortexture, Con_Print(), Con_Printf(), r_refdef_view_t::depth, r_rendertarget_t::depthtexture, dp_strlcpy, dpsnprintf(), r_refdef_t::envmap, envmapinfo, r_rendertarget_t::fbo, envmapinfo_s::flipdiagonaly, envmapinfo_s::flipx, envmapinfo_s::flipy, r_refdef_view_t::frustum_x, r_refdef_view_t::frustum_y, r_refdef_view_t::height, viddef_mode_t::height, r_refdef_view_t::ismain, r_refdef_view_t::isoverlay, r_refdef_view_t::matrix, Matrix4x4_CreateFromQuakeEntity(), MAX_QPATH, Mem_Alloc, Mem_Free, viddef_t::mode, name, r_refdef_view_t::origin, r_refdef_view_t::ortho_x, r_refdef_view_t::ortho_y, r_refdef_view_t::quality, R_Mesh_Finish(), R_Mesh_Start(), r_refdef, R_RenderTarget_Get(), R_RenderView(), R_UpdateVariables(), SCR_ScreenShot(), size, client_static_t::state, tempmempool, TEXTYPE_COLORBUFFER, TEXTYPE_DEPTHBUFFER24STENCIL8, TEXTYPE_UNUSED, r_refdef_view_t::useperspective, vid, r_refdef_t::view, r_refdef_view_t::width, viddef_mode_t::width, r_refdef_view_t::x, r_refdef_view_t::y, and r_refdef_view_t::z.

Referenced by CL_Screen_Init().

◆ R_Stereo_Active()

qbool R_Stereo_Active ( void )

Definition at line 2077 of file cl_screen.c.

{
    return (vid.mode.stereobuffer || r_stereo_sidebyside.integer || r_stereo_horizontal.integer || r_stereo_vertical.integer || R_Stereo_ColorMasking());
}

References cvar_t::integer, viddef_t::mode, R_Stereo_ColorMasking(), r_stereo_horizontal, r_stereo_sidebyside, r_stereo_vertical, viddef_mode_t::stereobuffer, and vid.

Referenced by CL_UpdateScreen(), R_Bloom_StartFrame(), R_MotionBlurView(), and R_RenderView().

◆ R_Stereo_ColorMasking()

qbool R_Stereo_ColorMasking ( void )

Definition at line 2072 of file cl_screen.c.

{
    return r_stereo_redblue.integer || r_stereo_redgreen.integer || r_stereo_redcyan.integer;
}

References cvar_t::integer, r_stereo_redblue, r_stereo_redcyan, and r_stereo_redgreen.

Referenced by R_BlendView(), R_BlendView_IsTrivial(), and R_Stereo_Active().

◆ SCR_BeginLoadingPlaque()

void SCR_BeginLoadingPlaque ( qbool startup )

Definition at line 1838 of file cl_screen.c.

{
    loadingscreenstack_t dummy_status;
 
    // we need to push a dummy status so CL_UpdateScreen knows we have things to load...
    if (!loadingscreenstack)
    {
        dummy_status.msg[0] = '\0';
        dummy_status.absolute_loading_amount_min = 0;
        loadingscreenstack = &dummy_status;
    }
 
    SCR_DeferLoadingPlaque(startup);
    if (scr_loadingscreen_background.integer)
        SCR_SetLoadingScreenTexture();
    CL_UpdateScreen();
 
    if (loadingscreenstack == &dummy_status)
        loadingscreenstack = NULL;
}

References loadingscreenstack_t::absolute_loading_amount_min, CL_UpdateScreen(), cvar_t::integer, loadingscreenstack, loadingscreenstack_t::msg, NULL, SCR_DeferLoadingPlaque(), scr_loadingscreen_background, and SCR_SetLoadingScreenTexture().

Referenced by CL_EstablishConnection(), CL_ParseServerInfo(), Host_Init(), R_Modules_Restart_f(), and SV_SpawnServer().

◆ SCR_CenterPrint()

void SCR_CenterPrint ( const char * str )

Definition at line 144 of file cl_screen.c.

{
    scr_centertime_off = scr_centertime.value;
    scr_centertime_start = cl.time;
 
    // Print the message to the console and update the scr buffer
    // but only if it's different to the previous message
    if (strcmp(str, scr_centerstring) == 0)
        return;
    dp_strlcpy(scr_centerstring, str, sizeof(scr_centerstring));
    scr_center_lines = 1;
    if (str[0] == '\0') // happens when stepping out of a centreprint trigger on alk1.2 start.bsp
        return;
    Con_CenterPrint(str);
 
// count the number of lines for centering
    while (*str)
    {
        if (*str == '\n')
            scr_center_lines++;
        str++;
    }
}

References cl, Con_CenterPrint(), dp_strlcpy, scr_center_lines, scr_centerstring, scr_centertime, scr_centertime_off, scr_centertime_start, client_state_t::time, and cvar_t::value.

Referenced by CL_ParseServerMessage(), CL_VM_Parse_CenterPrint(), SCR_Centerprint_f(), and VM_centerprint().

◆ SCR_Centerprint_f()

static void SCR_Centerprint_f ( cmd_state_t * cmd )

static

Definition at line 175 of file cl_screen.c.

{
    char msg[MAX_INPUTLINE];
    unsigned int i, c, p;
 
    c = Cmd_Argc(cmd);
    if(c >= 2)
    {
        // Merge all the cprint arguments into one string
        dp_strlcpy(msg, Cmd_Argv(cmd,1), sizeof(msg));
        for(i = 2; i < c; ++i)
        {
            dp_strlcat(msg, " ", sizeof(msg));
            dp_strlcat(msg, Cmd_Argv(cmd, i), sizeof(msg));
        }
 
        c = (unsigned int)strlen(msg);
        for(p = 0, i = 0; i < c; ++i)
        {
            if(msg[i] == '\\')
            {
                if(msg[i+1] == 'n')
                    msg[p++] = '\n';
                else if(msg[i+1] == '\\')
                    msg[p++] = '\\';
                else {
                    msg[p++] = '\\';
                    msg[p++] = msg[i+1];
                }
                ++i;
            } else {
                msg[p++] = msg[i];
            }
        }
        msg[p] = '\0';
        SCR_CenterPrint(msg);
    }
}

References cmd(), Cmd_Argc(), Cmd_Argv(), dp_strlcat, dp_strlcpy, i, int(), MAX_INPUTLINE, SCR_CenterPrint(), and strlen().

Referenced by CL_Screen_Init().

◆ SCR_CheckDrawCenterString()

static void SCR_CheckDrawCenterString ( void )

static

Definition at line 271 of file cl_screen.c.

{
    if (scr_center_lines > scr_erase_lines)
        scr_erase_lines = scr_center_lines;
 
    if (cl.time > cl.oldtime)
        scr_centertime_off -= cl.time - cl.oldtime;
 
    // don't draw if this is a normal stats-screen intermission,
    // only if it is not an intermission, or a finale intermission
    if (cl.intermission == 1)
        return;
    if (scr_centertime_off <= 0 && !cl.intermission)
        return;
    if (key_dest != key_game)
        return;
 
    SCR_DrawCenterString ();
}

References cl, client_state_t::intermission, key_dest, key_game, client_state_t::oldtime, scr_center_lines, scr_centertime_off, SCR_DrawCenterString(), scr_erase_lines, and client_state_t::time.

Referenced by SCR_DrawScreen().

◆ SCR_ChooseLoadingPic()

static void SCR_ChooseLoadingPic ( qbool startup )

static

Definition at line 1819 of file cl_screen.c.

{
    if(startup && scr_loadingscreen_firstforstartup.integer)
        loadingscreenpic_number = 0;
    else if(scr_loadingscreen_firstforstartup.integer)
        if(scr_loadingscreen_count.integer > 1)
            loadingscreenpic_number = rand() % (scr_loadingscreen_count.integer - 1) + 1;
        else
            loadingscreenpic_number = 0;
    else
        loadingscreenpic_number = rand() % (scr_loadingscreen_count.integer > 1 ? scr_loadingscreen_count.integer : 1);
}

References cvar_t::integer, loadingscreenpic_number, scr_loadingscreen_count, and scr_loadingscreen_firstforstartup.

Referenced by SCR_DeferLoadingPlaque().

◆ SCR_ClearLoadingScreen()

void SCR_ClearLoadingScreen ( qbool redraw )

Definition at line 1918 of file cl_screen.c.

{
    while(loadingscreenstack)
        SCR_PopLoadingScreen(redraw && !loadingscreenstack->prev);
}

References loadingscreenstack, loadingscreenstack_t::prev, and SCR_PopLoadingScreen().

Referenced by CL_DisconnectEx().

◆ SCR_ClearLoadingScreenTexture()

static void SCR_ClearLoadingScreenTexture ( void )

static

Definition at line 1786 of file cl_screen.c.

{
    if(loadingscreentexture)
        R_FreeTexture(loadingscreentexture);
    loadingscreentexture = NULL;
}

References loadingscreentexture, NULL, and R_FreeTexture().

Referenced by SCR_EndLoadingPlaque(), and SCR_SetLoadingScreenTexture().

◆ SCR_DeferLoadingPlaque()

void SCR_DeferLoadingPlaque ( qbool startup )

Definition at line 1859 of file cl_screen.c.

{
    SCR_ChooseLoadingPic(startup);
    scr_loading = true;
}

References SCR_ChooseLoadingPic(), and scr_loading.

Referenced by SCR_BeginLoadingPlaque(), and VID_Restart_f().

◆ SCR_DrawBrand()

static void SCR_DrawBrand ( void )

static

Definition at line 485 of file cl_screen.c.

{
    cachepic_t  *pic;
    float       x, y;
 
    if (!scr_showbrand.value)
        return;
 
    pic = Draw_CachePic ("gfx/brand");
 
    switch ((int)scr_showbrand.value)
    {
    case 1: // bottom left
        x = 0;
        y = vid_conheight.integer - Draw_GetPicHeight(pic);
        break;
    case 2: // bottom centre
        x = (vid_conwidth.integer - Draw_GetPicWidth(pic)) / 2;
        y = vid_conheight.integer - Draw_GetPicHeight(pic);
        break;
    case 3: // bottom right
        x = vid_conwidth.integer - Draw_GetPicWidth(pic);
        y = vid_conheight.integer - Draw_GetPicHeight(pic);
        break;
    case 4: // centre right
        x = vid_conwidth.integer - Draw_GetPicWidth(pic);
        y = (vid_conheight.integer - Draw_GetPicHeight(pic)) / 2;
        break;
    case 5: // top right
        x = vid_conwidth.integer - Draw_GetPicWidth(pic);
        y = 0;
        break;
    case 6: // top centre
        x = (vid_conwidth.integer - Draw_GetPicWidth(pic)) / 2;
        y = 0;
        break;
    case 7: // top left
        x = 0;
        y = 0;
        break;
    case 8: // centre left
        x = 0;
        y = (vid_conheight.integer - Draw_GetPicHeight(pic)) / 2;
        break;
    default:
        return;
    }
 
    DrawQ_Pic (x, y, pic, 0, 0, 1, 1, 1, 1, 0);
}

References Draw_CachePic(), Draw_GetPicHeight(), Draw_GetPicWidth(), DrawQ_Pic(), cvar_t::integer, scr_showbrand, cvar_t::value, vid_conheight, vid_conwidth, x, and y.

Referenced by SCR_DrawScreen().

◆ SCR_DrawCenterString()

static void SCR_DrawCenterString ( void )

static

Definition at line 214 of file cl_screen.c.

{
    char    *start;
    int     x, y;
    int     remaining;
    int     color;
 
    if(cl.intermission == 2) // in finale,
        if(sb_showscores) // make TAB hide the finale message (sb_showscores overrides finale in sbar.c)
            return;
 
    if(scr_centertime.value <= 0 && !cl.intermission)
        return;
 
// the finale prints the characters one at a time, except if printspeed is an absurdly high value
    if (cl.intermission && scr_printspeed.value > 0 && scr_printspeed.value < 1000000)
        remaining = (int)(scr_printspeed.value * (cl.time - scr_centertime_start));
    else
        remaining = 9999;
 
    scr_erase_center = 0;
    start = scr_centerstring;
 
    if (remaining < 1)
        return;
 
    if (scr_center_lines <= 4)
        y = (int)(vid_conheight.integer*0.35);
    else
        y = 48;
 
    color = -1;
    do
    {
        // scan the number of characters on the line, not counting color codes
        char *newline = strchr(start, '\n');
        int l = newline ? (newline - start) : (int)strlen(start);
        float width = DrawQ_TextWidth(start, l, 8, 8, false, FONT_CENTERPRINT);
 
        x = (int) (vid_conwidth.integer - width)/2;
        if (l > 0)
        {
            if (remaining < l)
                l = remaining;
            DrawQ_String(x, y, start, l, 8, 8, 1, 1, 1, 1, 0, &color, false, FONT_CENTERPRINT);
            remaining -= l;
            if (remaining <= 0)
                return;
        }
        y += 8;
 
        if (!newline)
            break;
        start = newline + 1; // skip the \n
    } while (1);
}

References cl, color, DrawQ_String(), DrawQ_TextWidth(), FONT_CENTERPRINT, int(), cvar_t::integer, client_state_t::intermission, sb_showscores, scr_center_lines, scr_centerstring, scr_centertime, scr_centertime_start, scr_erase_center, scr_printspeed, strlen(), client_state_t::time, cvar_t::value, vid_conheight, vid_conwidth, width, x, and y.

Referenced by SCR_CheckDrawCenterString().

◆ SCR_DrawConsole()

void SCR_DrawConsole ( void )

Definition at line 750 of file cl_screen.c.

{
    // infobar and loading progress are not drawn simultaneously
    scr_con_margin_bottom = SCR_InfobarHeight();
    if (!scr_con_margin_bottom && scr_loading)
        scr_con_margin_bottom = scr_loadingscreen_barheight.integer;
    if (key_consoleactive & KEY_CONSOLEACTIVE_FORCED)
    {
        // full screen
        Con_DrawConsole (vid_conheight.integer - scr_con_margin_bottom, true);
    }
    else if (scr_con_current)
        Con_DrawConsole (min(scr_con_current, vid_conheight.integer - scr_con_margin_bottom), false);
    else
        con_vislines = 0;
}

References Con_DrawConsole(), con_vislines, cvar_t::integer, key_consoleactive, KEY_CONSOLEACTIVE_FORCED, min, scr_con_current, scr_con_margin_bottom, SCR_InfobarHeight(), scr_loading, scr_loadingscreen_barheight, and vid_conheight.

Referenced by SCR_DrawScreen().

◆ SCR_DrawCurlDownload()

static int SCR_DrawCurlDownload ( int offset )

static

Definition at line 597 of file cl_screen.c.

{
    // sync with SCR_InfobarHeight
    int len;
    int nDownloads;
    int i;
    float x, y;
    float size = scr_infobar_height.value;
    Curl_downloadinfo_t *downinfo;
    char temp[256];
    char addinfobuf[128];
    const char *addinfo;
 
    downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo, addinfobuf, sizeof(addinfobuf));
    if(!downinfo)
        return 0;
 
    y = vid_conheight.integer - size * nDownloads - offset;
 
    if(addinfo)
    {
        len = (int)strlen(addinfo);
        x = (vid_conwidth.integer - DrawQ_TextWidth(addinfo, len, size, size, true, FONT_INFOBAR)) / 2;
        DrawQ_Fill(0, y - size, vid_conwidth.integer, size, 1, 1, 1, cls.signon == SIGNONS ? 0.8 : 1, 0);
        DrawQ_String(x, y - size, addinfo, len, size, size, 0, 0, 0, 1, 0, NULL, true, FONT_INFOBAR);
    }
 
    for(i = 0; i != nDownloads; ++i)
    {
        if(downinfo[i].queued)
            dpsnprintf(temp, sizeof(temp), "Still in queue: %s", downinfo[i].filename);
        else if(downinfo[i].progress <= 0)
            dpsnprintf(temp, sizeof(temp), "Downloading %s ...  ???.?%% @ %.1f KiB/s", downinfo[i].filename, downinfo[i].speed / 1024.0);
        else
            dpsnprintf(temp, sizeof(temp), "Downloading %s ...  %5.1f%% @ %.1f KiB/s", downinfo[i].filename, 100.0 * downinfo[i].progress, downinfo[i].speed / 1024.0);
        len = (int)strlen(temp);
        x = (vid_conwidth.integer - DrawQ_TextWidth(temp, len, size, size, true, FONT_INFOBAR)) / 2;
        DrawQ_Fill(0, y + i * size, vid_conwidth.integer, size, 0, 0, 0, cls.signon == SIGNONS ? 0.5 : 1, 0);
        DrawQ_String(x, y + i * size, temp, len, size, size, 1, 1, 1, 1, 0, NULL, true, FONT_INFOBAR);
    }
 
    Z_Free(downinfo);
 
    return size * (nDownloads + (addinfo ? 1 : 0));
}

References cls, Curl_GetDownloadInfo(), dpsnprintf(), DrawQ_Fill(), DrawQ_String(), DrawQ_TextWidth(), FONT_INFOBAR, i, int(), cvar_t::integer, NULL, offset, scr_infobar_height, client_static_t::signon, SIGNONS, size, strlen(), cvar_t::value, vid_conheight, vid_conwidth, x, y, and Z_Free.

Referenced by SCR_DrawInfobar().

◆ SCR_DrawInfobar()

static void SCR_DrawInfobar ( void )

static

Definition at line 648 of file cl_screen.c.

{
    unsigned int offset = 0;
    offset += SCR_DrawQWDownload(offset);
    offset += SCR_DrawCurlDownload(offset);
    if(scr_infobartime_off > 0)
        offset += SCR_DrawInfobarString(offset);
    if(!offset && scr_loading)
        offset = scr_loadingscreen_barheight.integer;
    if(offset != scr_con_margin_bottom)
        Con_DPrintf("broken console margin calculation: %d != %d\n", offset, scr_con_margin_bottom);
}

References Con_DPrintf(), cvar_t::integer, offset, scr_con_margin_bottom, SCR_DrawCurlDownload(), SCR_DrawInfobarString(), SCR_DrawQWDownload(), scr_infobartime_off, scr_loading, and scr_loadingscreen_barheight.

Referenced by SCR_DrawScreen().

◆ SCR_DrawInfobarString()

static int SCR_DrawInfobarString ( int offset )

static

Definition at line 578 of file cl_screen.c.

{
    int len;
    float x, y;
    float size = scr_infobar_height.value;
 
    len = (int)strlen(scr_infobarstring);
    x = (vid_conwidth.integer - DrawQ_TextWidth(scr_infobarstring, len, size, size, false, FONT_INFOBAR)) / 2;
    y = vid_conheight.integer - size - offset;
    DrawQ_Fill(0, y, vid_conwidth.integer, size, 0, 0, 0, cls.signon == SIGNONS ? 0.5 : 1, 0);
    DrawQ_String(x, y, scr_infobarstring, len, size, size, 1, 1, 1, 1, 0, NULL, false, FONT_INFOBAR);
    return size;
}

References cls, DrawQ_Fill(), DrawQ_String(), DrawQ_TextWidth(), FONT_INFOBAR, int(), cvar_t::integer, NULL, offset, scr_infobar_height, scr_infobarstring, client_static_t::signon, SIGNONS, size, strlen(), cvar_t::value, vid_conheight, vid_conwidth, x, and y.

Referenced by SCR_DrawInfobar().

◆ SCR_DrawLoadingScreen()

static void SCR_DrawLoadingScreen ( void )

static

Definition at line 1992 of file cl_screen.c.

{
    cachepic_t *loadingscreenpic;
    float loadingscreenpic_vertex3f[12];
    float loadingscreenpic_texcoord2f[8];
    float x, y, w, h, sw, sh, f;
    char vabuf[1024];
 
    GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    GL_DepthRange(0, 1);
    GL_PolygonOffset(0, 0);
    GL_DepthTest(false);
    GL_Color(1,1,1,1);
 
    if(loadingscreentexture)
    {
        R_Mesh_PrepareVertices_Generic_Arrays(4, loadingscreentexture_vertex3f, NULL, loadingscreentexture_texcoord2f);
        R_SetupShader_Generic(loadingscreentexture, false, true, true);
        R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
    }
 
    loadingscreenpic = Draw_CachePic_Flags(loadingscreenpic_number ? va(vabuf, sizeof(vabuf), "%s%d", scr_loadingscreen_picture.string, loadingscreenpic_number+1) : scr_loadingscreen_picture.string, loadingscreenpic_number ? CACHEPICFLAG_NOTPERSISTENT : 0);
    w = Draw_GetPicWidth(loadingscreenpic);
    h = Draw_GetPicHeight(loadingscreenpic);
 
    // apply scale
    w *= scr_loadingscreen_scale.value;
    h *= scr_loadingscreen_scale.value;
 
    // apply scale base
    if(scr_loadingscreen_scale_base.integer)
    {
        w *= vid_conwidth.integer / (float) vid.mode.width;
        h *= vid_conheight.integer / (float) vid.mode.height;
    }
 
    // apply scale limit
    sw = w / vid_conwidth.integer;
    sh = h / vid_conheight.integer;
    f = 1;
    switch(scr_loadingscreen_scale_limit.integer)
    {
        case 1:
            f = max(sw, sh);
            break;
        case 2:
            f = min(sw, sh);
            break;
        case 3:
            f = sw;
            break;
        case 4:
            f = sh;
            break;
    }
    if(f > 1)
    {
        w /= f;
        h /= f;
    }
 
    x = (vid_conwidth.integer - w)/2;
    y = (vid_conheight.integer - h)/2;
    loadingscreenpic_vertex3f[2] = loadingscreenpic_vertex3f[5] = loadingscreenpic_vertex3f[8] = loadingscreenpic_vertex3f[11] = 0;
    loadingscreenpic_vertex3f[0] = loadingscreenpic_vertex3f[9] = x;
    loadingscreenpic_vertex3f[1] = loadingscreenpic_vertex3f[4] = y;
    loadingscreenpic_vertex3f[3] = loadingscreenpic_vertex3f[6] = x + w;
    loadingscreenpic_vertex3f[7] = loadingscreenpic_vertex3f[10] = y + h;
    loadingscreenpic_texcoord2f[0] = 0;loadingscreenpic_texcoord2f[1] = 0;
    loadingscreenpic_texcoord2f[2] = 1;loadingscreenpic_texcoord2f[3] = 0;
    loadingscreenpic_texcoord2f[4] = 1;loadingscreenpic_texcoord2f[5] = 1;
    loadingscreenpic_texcoord2f[6] = 0;loadingscreenpic_texcoord2f[7] = 1;
 
    R_Mesh_PrepareVertices_Generic_Arrays(4, loadingscreenpic_vertex3f, NULL, loadingscreenpic_texcoord2f);
    R_SetupShader_Generic(Draw_GetPicTexture(loadingscreenpic), true, true, false);
    R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
 
    SCR_DrawLoadingStack();
}

References CACHEPICFLAG_NOTPERSISTENT, Draw_CachePic_Flags(), Draw_GetPicHeight(), Draw_GetPicTexture(), Draw_GetPicWidth(), f, float, GL_BlendFunc(), GL_Color(), GL_DepthRange(), GL_DepthTest(), GL_ONE_MINUS_SRC_ALPHA, GL_PolygonOffset(), GL_SRC_ALPHA, viddef_mode_t::height, cvar_t::integer, loadingscreenpic_number, loadingscreentexture, loadingscreentexture_texcoord2f, loadingscreentexture_vertex3f, max, min, viddef_t::mode, NULL, polygonelement3i, polygonelement3s, R_Mesh_Draw(), R_Mesh_PrepareVertices_Generic_Arrays(), R_SetupShader_Generic(), SCR_DrawLoadingStack(), scr_loadingscreen_picture, scr_loadingscreen_scale, scr_loadingscreen_scale_base, scr_loadingscreen_scale_limit, cvar_t::string, sw, va(), cvar_t::value, vid, vid_conheight, vid_conwidth, w, viddef_mode_t::width, x, and y.

Referenced by SCR_DrawScreen().

◆ SCR_DrawLoadingStack()

static void SCR_DrawLoadingStack ( void )

static

Definition at line 1958 of file cl_screen.c.

{
    float verts[12];
    float colors[16];
 
    SCR_DrawLoadingStack_r(loadingscreenstack, vid_conheight.integer, scr_loadingscreen_barheight.value);
    if(loadingscreenstack)
    {
        // height = 32; // sorry, using the actual one is ugly
        GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
        GL_DepthRange(0, 1);
        GL_PolygonOffset(0, 0);
        GL_DepthTest(false);
        //R_Mesh_ResetTextureState();
        verts[2] = verts[5] = verts[8] = verts[11] = 0;
        verts[0] = verts[9] = 0;
        verts[1] = verts[4] = vid_conheight.integer - scr_loadingscreen_barheight.value;
        verts[3] = verts[6] = vid_conwidth.integer * loadingscreenstack->absolute_loading_amount_min;
        verts[7] = verts[10] = vid_conheight.integer;
        
#if _MSC_VER >= 1400
#define sscanf sscanf_s
#endif
        colors[0] = 0; colors[1] = 0; colors[2] = 0; colors[3] = 1;
        colors[4] = 0; colors[5] = 0; colors[6] = 0; colors[7] = 1;
        sscanf(scr_loadingscreen_barcolor.string, "%f %f %f", &colors[8], &colors[9], &colors[10]); colors[11] = 1;
        sscanf(scr_loadingscreen_barcolor.string, "%f %f %f", &colors[12], &colors[13], &colors[14]);  colors[15] = 1;
 
        R_Mesh_PrepareVertices_Generic_Arrays(4, verts, colors, NULL);
        R_SetupShader_Generic_NoTexture(true, true);
        R_Mesh_Draw(0, 4, 0, 2, polygonelement3i, NULL, 0, polygonelement3s, NULL, 0);
    }
}

References loadingscreenstack_t::absolute_loading_amount_min, GL_BlendFunc(), GL_DepthRange(), GL_DepthTest(), GL_ONE, GL_PolygonOffset(), GL_SRC_ALPHA, cvar_t::integer, loadingscreenstack, NULL, polygonelement3i, polygonelement3s, R_Mesh_Draw(), R_Mesh_PrepareVertices_Generic_Arrays(), R_SetupShader_Generic_NoTexture(), SCR_DrawLoadingStack_r(), scr_loadingscreen_barcolor, scr_loadingscreen_barheight, cvar_t::string, cvar_t::value, vid_conheight, and vid_conwidth.

Referenced by SCR_DrawLoadingScreen().

◆ SCR_DrawLoadingStack_r()

static float SCR_DrawLoadingStack_r	(	loadingscreenstack_t *	s,
		float	y,
		float	size )

static

Definition at line 1924 of file cl_screen.c.

{
    float x;
    size_t len;
    float total;
 
    total = 0;
#if 0
    if(s)
    {
        total += SCR_DrawLoadingStack_r(s->prev, y, 8);
        y -= total;
        if(!s->prev || strcmp(s->msg, s->prev->msg))
        {
            len = strlen(s->msg);
            x = (vid_conwidth.integer - DrawQ_TextWidth(s->msg, len, size, size, true, FONT_INFOBAR)) / 2;
            y -= size;
            DrawQ_String(x, y, s->msg, len, size, size, 1, 1, 1, 1, 0, NULL, true, FONT_INFOBAR);
            total += size;
        }
    }
#else
    if(s)
    {
        len = strlen(s->msg);
        x = (vid_conwidth.integer - DrawQ_TextWidth(s->msg, len, size, size, true, FONT_INFOBAR)) / 2;
        y -= size;
        DrawQ_String(x, y, s->msg, len, size, size, 1, 1, 1, 1, 0, NULL, true, FONT_INFOBAR);
        total += size;
    }
#endif
    return total;
}

References DrawQ_String(), DrawQ_TextWidth(), FONT_INFOBAR, cvar_t::integer, loadingscreenstack_t::msg, NULL, loadingscreenstack_t::prev, SCR_DrawLoadingStack_r(), size, strlen(), vid_conwidth, x, and y.

Referenced by SCR_DrawLoadingStack(), and SCR_DrawLoadingStack_r().

◆ SCR_DrawNet()

static void SCR_DrawNet ( void )

static

Definition at line 446 of file cl_screen.c.

{
    if (cls.state != ca_connected)
        return;
    if (host.realtime - cl.last_received_message < 0.3)
        return;
    if (cls.demoplayback)
        return;
 
    DrawQ_Pic (64, 0, Draw_CachePic ("gfx/net"), 0, 0, 1, 1, 1, 1, 0);
}

References ca_connected, cl, cls, client_static_t::demoplayback, Draw_CachePic(), DrawQ_Pic(), host, client_state_t::last_received_message, host_static_t::realtime, and client_static_t::state.

Referenced by SCR_DrawScreen().

◆ SCR_DrawNetGraph()

static void SCR_DrawNetGraph ( void )

static

Definition at line 364 of file cl_screen.c.

{
    int i, separator1, separator2, graphwidth, graphheight, netgraph_x, netgraph_y, textsize, index, netgraphsperrow, graphlimit;
    float graphscale;
    netconn_t *c;
    char vabuf[1024];
 
    if (cls.state != ca_connected)
        return;
    if (!cls.netcon)
        return;
    if (!net_graph.integer)
        return;
 
    separator1 = 2;
    separator2 = 4;
    textsize = 8;
    graphwidth = 120;
    graphheight = 70;
    graphscale = 1.0f / 1500.0f;
    graphlimit = cl_rate.integer;
 
    netgraphsperrow = (vid_conwidth.integer + separator2) / (graphwidth * 2 + separator1 + separator2);
    netgraphsperrow = max(netgraphsperrow, 1);
 
    index = 0;
    netgraph_x = (vid_conwidth.integer + separator2) - (1 + (index % netgraphsperrow)) * (graphwidth * 2 + separator1 + separator2);
    netgraph_y = (vid_conheight.integer - 48 - sbar_info_pos.integer + separator2) - (1 + (index / netgraphsperrow)) * (graphheight + textsize + separator2);
    c = cls.netcon;
    SCR_DrawNetGraph_DrawGraph(netgraph_x                          , netgraph_y, graphwidth, graphheight, graphscale, graphlimit, "incoming", textsize, c->incoming_packetcounter, c->incoming_netgraph);
    SCR_DrawNetGraph_DrawGraph(netgraph_x + graphwidth + separator1, netgraph_y, graphwidth, graphheight, graphscale, graphlimit, "outgoing", textsize, c->outgoing_packetcounter, c->outgoing_netgraph);
    index++;
 
    if (sv.active && net_graph.integer >= 2)
    {
        for (i = 0;i < svs.maxclients;i++)
        {
            c = svs.clients[i].netconnection;
            if (!c)
                continue;
            netgraph_x = (vid_conwidth.integer + separator2) - (1 + (index % netgraphsperrow)) * (graphwidth * 2 + separator1 + separator2);
            netgraph_y = (vid_conheight.integer - 48 + separator2) - (1 + (index / netgraphsperrow)) * (graphheight + textsize + separator2);
            SCR_DrawNetGraph_DrawGraph(netgraph_x                          , netgraph_y, graphwidth, graphheight, graphscale, graphlimit, va(vabuf, sizeof(vabuf), "%s", svs.clients[i].name), textsize, c->outgoing_packetcounter, c->outgoing_netgraph);
            SCR_DrawNetGraph_DrawGraph(netgraph_x + graphwidth + separator1, netgraph_y, graphwidth, graphheight, graphscale, graphlimit, ""                           , textsize, c->incoming_packetcounter, c->incoming_netgraph);
            index++;
        }
    }
}

References server_t::active, ca_connected, cl_rate, server_static_t::clients, cls, i, netconn_t::incoming_netgraph, netconn_t::incoming_packetcounter, index, cvar_t::integer, max, server_static_t::maxclients, net_graph, client_static_t::netcon, netconn_t::outgoing_netgraph, netconn_t::outgoing_packetcounter, sbar_info_pos, SCR_DrawNetGraph_DrawGraph(), client_static_t::state, sv, svs, va(), vid_conheight, and vid_conwidth.

Referenced by SCR_DrawScreen().

◆ SCR_DrawNetGraph_DrawGraph()

static void SCR_DrawNetGraph_DrawGraph	(	int	graphx,
		int	graphy,
		int	graphwidth,
		int	graphheight,
		float	graphscale,
		int	graphlimit,
		const char *	label,
		float	textsize,
		int	packetcounter,
		netgraphitem_t *	netgraph )

static

Definition at line 291 of file cl_screen.c.

{
    netgraphitem_t *graph;
    int j, x, y;
    int totalbytes = 0;
    char bytesstring[128];
    float g[NETGRAPH_PACKETS][7];
    float *a;
    float *b;
    DrawQ_Fill(graphx, graphy, graphwidth, graphheight + textsize * 2, 0, 0, 0, 0.5, 0);
    // draw the bar graph itself
    memset(g, 0, sizeof(g));
    for (j = 0;j < NETGRAPH_PACKETS;j++)
    {
        graph = netgraph + j;
        g[j][0] = 1.0f - 0.25f * (host.realtime - graph->time);
        g[j][1] = 1.0f;
        g[j][2] = 1.0f;
        g[j][3] = 1.0f;
        g[j][4] = 1.0f;
        g[j][5] = 1.0f;
        g[j][6] = 1.0f;
        if (graph->unreliablebytes == NETGRAPH_LOSTPACKET)
            g[j][1] = 0.00f;
        else if (graph->unreliablebytes == NETGRAPH_CHOKEDPACKET)
            g[j][2] = 0.90f;
        else
        {
            if(netgraph[j].time >= netgraph[(j+NETGRAPH_PACKETS-1)%NETGRAPH_PACKETS].time)
                if(graph->unreliablebytes + graph->reliablebytes + graph->ackbytes >= graphlimit * (netgraph[j].time - netgraph[(j+NETGRAPH_PACKETS-1)%NETGRAPH_PACKETS].time))
                    g[j][2] = 0.98f;
            g[j][3] = 1.0f    - graph->unreliablebytes * graphscale;
            g[j][4] = g[j][3] - graph->reliablebytes   * graphscale;
            g[j][5] = g[j][4] - graph->ackbytes        * graphscale;
            // count bytes in the last second
            if (host.realtime - graph->time < 1.0f)
                totalbytes += graph->unreliablebytes + graph->reliablebytes + graph->ackbytes;
        }
        if(graph->cleartime >= 0)
            g[j][6] = 0.5f + 0.5f * (2.0 / M_PI) * atan((M_PI / 2.0) * (graph->cleartime - graph->time));
        g[j][1] = bound(0.0f, g[j][1], 1.0f);
        g[j][2] = bound(0.0f, g[j][2], 1.0f);
        g[j][3] = bound(0.0f, g[j][3], 1.0f);
        g[j][4] = bound(0.0f, g[j][4], 1.0f);
        g[j][5] = bound(0.0f, g[j][5], 1.0f);
        g[j][6] = bound(0.0f, g[j][6], 1.0f);
    }
    // render the lines for the graph
    for (j = 0;j < NETGRAPH_PACKETS;j++)
    {
        a = g[j];
        b = g[(j+1)%NETGRAPH_PACKETS];
        if (a[0] < 0.0f || b[0] > 1.0f || b[0] < a[0])
            continue;
        DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[2], graphx + graphwidth * b[0], graphy + graphheight * b[2], 1.0f, 1.0f, 1.0f, 1.0f, 0);
        DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[1], graphx + graphwidth * b[0], graphy + graphheight * b[1], 1.0f, 0.0f, 0.0f, 1.0f, 0);
        DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[5], graphx + graphwidth * b[0], graphy + graphheight * b[5], 0.0f, 1.0f, 0.0f, 1.0f, 0);
        DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[4], graphx + graphwidth * b[0], graphy + graphheight * b[4], 1.0f, 1.0f, 1.0f, 1.0f, 0);
        DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[3], graphx + graphwidth * b[0], graphy + graphheight * b[3], 1.0f, 0.5f, 0.0f, 1.0f, 0);
        DrawQ_Line(1, graphx + graphwidth * a[0], graphy + graphheight * a[6], graphx + graphwidth * b[0], graphy + graphheight * b[6], 0.0f, 0.0f, 1.0f, 1.0f, 0);
    }
    x = graphx;
    y = graphy + graphheight;
    dpsnprintf(bytesstring, sizeof(bytesstring), "%i", totalbytes);
    DrawQ_String(x, y, label      , 0, textsize, textsize, 1.0f, 1.0f, 1.0f, 1.0f, 0, NULL, false, FONT_DEFAULT);y += textsize;
    DrawQ_String(x, y, bytesstring, 0, textsize, textsize, 1.0f, 1.0f, 1.0f, 1.0f, 0, NULL, false, FONT_DEFAULT);y += textsize;
}

References a, netgraphitem_t::ackbytes, b, bound, netgraphitem_t::cleartime, dpsnprintf(), DrawQ_Fill(), DrawQ_Line(), DrawQ_String(), FONT_DEFAULT, g, host, M_PI, NETGRAPH_CHOKEDPACKET, NETGRAPH_LOSTPACKET, NETGRAPH_PACKETS, NULL, host_static_t::realtime, netgraphitem_t::reliablebytes, netgraphitem_t::time, time, netgraphitem_t::unreliablebytes, x, and y.

Referenced by SCR_DrawNetGraph().

◆ SCR_DrawPause()

static void SCR_DrawPause ( void )

static

Definition at line 463 of file cl_screen.c.

{
    cachepic_t  *pic;
 
    if (cls.state != ca_connected)
        return;
 
    if (!scr_showpause.integer)     // turn off for screenshots
        return;
 
    if (!cl.paused)
        return;
 
    pic = Draw_CachePic ("gfx/pause");
    DrawQ_Pic ((vid_conwidth.integer - Draw_GetPicWidth(pic))/2, (vid_conheight.integer - Draw_GetPicHeight(pic))/2, pic, 0, 0, 1, 1, 1, 1, 0);
}

References ca_connected, cl, cls, Draw_CachePic(), Draw_GetPicHeight(), Draw_GetPicWidth(), DrawQ_Pic(), cvar_t::integer, client_state_t::paused, scr_showpause, client_static_t::state, vid_conheight, and vid_conwidth.

Referenced by SCR_DrawScreen().

◆ SCR_DrawQWDownload()

static int SCR_DrawQWDownload ( int offset )

static

Definition at line 541 of file cl_screen.c.

{
    // sync with SCR_InfobarHeight
    int len;
    float x, y;
    float size = scr_infobar_height.value;
    char temp[256];
 
    if (!cls.qw_downloadname[0])
    {
        cls.qw_downloadspeedrate = 0;
        cls.qw_downloadspeedtime = host.realtime;
        cls.qw_downloadspeedcount = 0;
        return 0;
    }
    if (host.realtime >= cls.qw_downloadspeedtime + 1)
    {
        cls.qw_downloadspeedrate = cls.qw_downloadspeedcount;
        cls.qw_downloadspeedtime = host.realtime;
        cls.qw_downloadspeedcount = 0;
    }
    if (cls.protocol == PROTOCOL_QUAKEWORLD)
        dpsnprintf(temp, sizeof(temp), "Downloading %s %3i%% (%i) at %i bytes/s", cls.qw_downloadname, cls.qw_downloadpercent, cls.qw_downloadmemorycursize, cls.qw_downloadspeedrate);
    else
        dpsnprintf(temp, sizeof(temp), "Downloading %s %3i%% (%i/%i) at %i bytes/s", cls.qw_downloadname, cls.qw_downloadpercent, cls.qw_downloadmemorycursize, cls.qw_downloadmemorymaxsize, cls.qw_downloadspeedrate);
    len = (int)strlen(temp);
    x = (vid_conwidth.integer - DrawQ_TextWidth(temp, len, size, size, true, FONT_INFOBAR)) / 2;
    y = vid_conheight.integer - size - offset;
    DrawQ_Fill(0, y, vid_conwidth.integer, size, 0, 0, 0, cls.signon == SIGNONS ? 0.5 : 1, 0);
    DrawQ_String(x, y, temp, len, size, size, 1, 1, 1, 1, 0, NULL, true, FONT_INFOBAR);
    return size;
}

References cls, dpsnprintf(), DrawQ_Fill(), DrawQ_String(), DrawQ_TextWidth(), FONT_INFOBAR, host, int(), cvar_t::integer, NULL, offset, client_static_t::protocol, PROTOCOL_QUAKEWORLD, client_static_t::qw_downloadmemorycursize, client_static_t::qw_downloadmemorymaxsize, client_static_t::qw_downloadname, client_static_t::qw_downloadpercent, client_static_t::qw_downloadspeedcount, client_static_t::qw_downloadspeedrate, client_static_t::qw_downloadspeedtime, host_static_t::realtime, scr_infobar_height, client_static_t::signon, SIGNONS, size, strlen(), cvar_t::value, vid_conheight, vid_conwidth, x, and y.

Referenced by SCR_DrawInfobar().

◆ SCR_DrawScreen()

static void SCR_DrawScreen ( void )

static

Definition at line 1576 of file cl_screen.c.

{
    Draw_Frame();
    DrawQ_Start();
    R_Mesh_Start();
    R_UpdateVariables();
 
    // Quake uses clockwise winding, so these are swapped
    r_refdef.view.cullface_front = GL_BACK;
    r_refdef.view.cullface_back = GL_FRONT;
 
    if (!scr_loading && cls.signon == SIGNONS)
    {
        float size;
 
        size = scr_viewsize.value * (1.0 / 100.0);
        size = min(size, 1);
 
        if (r_stereo_sidebyside.integer)
        {
            r_refdef.view.width = (int)(vid.mode.width * size / 2.5);
            r_refdef.view.height = (int)(vid.mode.height * size / 2.5 * (1 - bound(0, r_letterbox.value, 100) / 100));
            r_refdef.view.depth = 1;
            r_refdef.view.x = (int)((vid.mode.width - r_refdef.view.width * 2.5) * 0.5);
            r_refdef.view.y = (int)((vid.mode.height - r_refdef.view.height)/2);
            r_refdef.view.z = 0;
            if (r_stereo_side)
                r_refdef.view.x += (int)(r_refdef.view.width * 1.5);
        }
        else if (r_stereo_horizontal.integer)
        {
            r_refdef.view.width = (int)(vid.mode.width * size / 2);
            r_refdef.view.height = (int)(vid.mode.height * size * (1 - bound(0, r_letterbox.value, 100) / 100));
            r_refdef.view.depth = 1;
            r_refdef.view.x = (int)((vid.mode.width - r_refdef.view.width * 2.0)/2);
            r_refdef.view.y = (int)((vid.mode.height - r_refdef.view.height)/2);
            r_refdef.view.z = 0;
            if (r_stereo_side)
                r_refdef.view.x += (int)(r_refdef.view.width);
        }
        else if (r_stereo_vertical.integer)
        {
            r_refdef.view.width = (int)(vid.mode.width * size);
            r_refdef.view.height = (int)(vid.mode.height * size * (1 - bound(0, r_letterbox.value, 100) / 100) / 2);
            r_refdef.view.depth = 1;
            r_refdef.view.x = (int)((vid.mode.width - r_refdef.view.width)/2);
            r_refdef.view.y = (int)((vid.mode.height - r_refdef.view.height * 2.0)/2);
            r_refdef.view.z = 0;
            if (r_stereo_side)
                r_refdef.view.y += (int)(r_refdef.view.height);
        }
        else
        {
            r_refdef.view.width = (int)(vid.mode.width * size);
            r_refdef.view.height = (int)(vid.mode.height * size * (1 - bound(0, r_letterbox.value, 100) / 100));
            r_refdef.view.depth = 1;
            r_refdef.view.x = (int)((vid.mode.width - r_refdef.view.width)/2);
            r_refdef.view.y = (int)((vid.mode.height - r_refdef.view.height)/2);
            r_refdef.view.z = 0;
        }
 
        // LadyHavoc: viewzoom (zoom in for sniper rifles, etc)
        // LadyHavoc: this is designed to produce widescreen fov values
        // when the screen is wider than 4/3 width/height aspect, to do
        // this it simply assumes the requested fov is the vertical fov
        // for a 4x3 display, if the ratio is not 4x3 this makes the fov
        // higher/lower according to the ratio
        r_refdef.view.useperspective = true;
        r_refdef.view.frustum_y = tan(scr_fov.value * M_PI / 360.0) * (3.0 / 4.0) * cl.viewzoom;
        r_refdef.view.frustum_x = r_refdef.view.frustum_y * (float)r_refdef.view.width / (float)r_refdef.view.height / vid_pixelheight.value;
 
        r_refdef.view.frustum_x *= r_refdef.frustumscale_x;
        r_refdef.view.frustum_y *= r_refdef.frustumscale_y;
        r_refdef.view.ortho_x = atan(r_refdef.view.frustum_x) * (360.0 / M_PI); // abused as angle by VM_CL_R_SetView
        r_refdef.view.ortho_y = atan(r_refdef.view.frustum_y) * (360.0 / M_PI); // abused as angle by VM_CL_R_SetView
 
        r_refdef.view.ismain = true;
 
        // if CSQC is loaded, it is required to provide the CSQC_UpdateView function,
        // and won't render a view if it does not call that.
        if (CLVM_prog->loaded && !(CLVM_prog->flag & PRVM_CSQC_SIMPLE))
            CL_VM_UpdateView(r_stereo_side ? 0.0 : max(0.0, cl.time - cl.oldtime));
        else
        {
            // Prepare the scene mesh for rendering - this is lightning beams and other effects rendered as normal surfaces
            CL_MeshEntities_Scene_FinalizeRenderEntity();
 
            CL_UpdateEntityShading();
            R_RenderView(0, NULL, NULL, r_refdef.view.x, r_refdef.view.y, r_refdef.view.width, r_refdef.view.height);
        }
    }
 
    // Don't apply debugging stuff like r_showsurfaces to the UI
    r_refdef.view.showdebug = false;
 
    if (!r_stereo_sidebyside.integer && !r_stereo_horizontal.integer && !r_stereo_vertical.integer)
    {
        r_refdef.view.width = vid.mode.width;
        r_refdef.view.height = vid.mode.height;
        r_refdef.view.depth = 1;
        r_refdef.view.x = 0;
        r_refdef.view.y = 0;
        r_refdef.view.z = 0;
        r_refdef.view.useperspective = false;
    }
 
    if (cls.timedemo && cls.td_frames > 0 && timedemo_screenshotframelist.string && timedemo_screenshotframelist.string[0])
    {
        const char *t;
        int framenum;
        t = timedemo_screenshotframelist.string;
        while (*t)
        {
            while (*t == ' ')
                t++;
            if (!*t)
                break;
            framenum = atof(t);
            if (framenum == cls.td_frames)
                break;
            while (*t && *t != ' ')
                t++;
        }
        if (*t)
        {
            // we need to take a screenshot of this frame...
            char filename[MAX_QPATH];
            unsigned char *buffer1;
            unsigned char *buffer2;
            dpsnprintf(filename, sizeof(filename), "timedemoscreenshots/%s%06d.tga", cls.demoname, cls.td_frames);
            buffer1 = (unsigned char *)Mem_Alloc(tempmempool, vid.mode.width * vid.mode.height * 4);
            buffer2 = (unsigned char *)Mem_Alloc(tempmempool, vid.mode.width * vid.mode.height * 3);
            SCR_ScreenShot(filename, buffer1, buffer2, 0, 0, vid.mode.width, vid.mode.height, false, false, false, false, false, true, false);
            Mem_Free(buffer1);
            Mem_Free(buffer2);
        }
    }
 
    // draw 2D stuff
 
    if(!scr_con_current && !(key_consoleactive & KEY_CONSOLEACTIVE_FORCED))
        if ((key_dest == key_game || key_dest == key_message) && !r_letterbox.value && !scr_loading)
            Con_DrawNotify ();  // only draw notify in game
 
    if (cl.islocalgame && (key_dest != key_game || key_consoleactive))
        host.paused = true;
    else
        host.paused = false;
 
    if (!scr_loading && cls.signon == SIGNONS)
    {
        SCR_DrawNet ();
        SCR_DrawTurtle ();
        SCR_DrawPause ();
        if (!r_letterbox.value)
        {
            Sbar_Draw();
            if (CLVM_prog->loaded && CLVM_prog->flag & PRVM_CSQC_SIMPLE)
                CL_VM_DrawHud(r_stereo_side ? 0.0 : max(0.0, cl.time - cl.oldtime));
        }
        SHOWLMP_drawall();
        SCR_CheckDrawCenterString();
    }
    SCR_DrawNetGraph ();
#ifdef CONFIG_MENU
    if(!scr_loading)
        MR_Draw();
#endif
    CL_DrawVideo();
    R_Shadow_EditLights_DrawSelectedLightProperties();
 
    if (scr_loading)
    {
        // connect_status replaces any dummy_status
        if ((!loadingscreenstack || loadingscreenstack->msg[0] == '\0') && cl_connect_status[0] != '\0')
        {
            loadingscreenstack_t connect_status, *og_ptr = loadingscreenstack;
 
            connect_status.absolute_loading_amount_min = 0;
            dp_strlcpy(connect_status.msg, cl_connect_status, sizeof(cl_connect_status));
            loadingscreenstack = &connect_status;
            SCR_DrawLoadingScreen();
            loadingscreenstack = og_ptr;
        }
        else
            SCR_DrawLoadingScreen();
    }
 
    SCR_DrawConsole();
    SCR_DrawInfobar();
 
    if (!scr_loading)
    {
        SCR_DrawBrand();
        SCR_DrawTouchscreenOverlay();
    }
    if (r_timereport_active)
        R_TimeReport("2d");
 
    R_TimeReport_EndFrame();
    R_TimeReport_BeginFrame();
    
    if(!scr_loading)
        Sbar_ShowFPS();
 
    R_Mesh_Finish();
    DrawQ_Finish();
    R_RenderTarget_FreeUnused(false);
}

References loadingscreenstack_t::absolute_loading_amount_min, bound, cl, cl_connect_status, CL_DrawVideo(), CL_MeshEntities_Scene_FinalizeRenderEntity(), CL_UpdateEntityShading(), CL_VM_DrawHud(), CL_VM_UpdateView(), cls, CLVM_prog, Con_DrawNotify(), r_refdef_view_t::cullface_back, r_refdef_view_t::cullface_front, client_static_t::demoname, r_refdef_view_t::depth, dp_strlcpy, dpsnprintf(), Draw_Frame(), DrawQ_Finish(), DrawQ_Start(), float, r_refdef_view_t::frustum_x, r_refdef_view_t::frustum_y, r_refdef_t::frustumscale_x, r_refdef_t::frustumscale_y, GL_BACK, GL_FRONT, r_refdef_view_t::height, viddef_mode_t::height, host, int(), cvar_t::integer, client_state_t::islocalgame, r_refdef_view_t::ismain, key_consoleactive, KEY_CONSOLEACTIVE_FORCED, key_dest, key_game, key_message, loadingscreenstack, M_PI, max, MAX_QPATH, Mem_Alloc, Mem_Free, min, viddef_t::mode, MR_Draw, loadingscreenstack_t::msg, NULL, client_state_t::oldtime, r_refdef_view_t::ortho_x, r_refdef_view_t::ortho_y, host_static_t::paused, PRVM_CSQC_SIMPLE, r_letterbox, R_Mesh_Finish(), R_Mesh_Start(), r_refdef, R_RenderTarget_FreeUnused(), R_RenderView(), R_Shadow_EditLights_DrawSelectedLightProperties(), r_stereo_horizontal, r_stereo_side, r_stereo_sidebyside, r_stereo_vertical, R_TimeReport(), r_timereport_active, R_TimeReport_BeginFrame(), R_TimeReport_EndFrame(), R_UpdateVariables(), Sbar_Draw(), Sbar_ShowFPS(), SCR_CheckDrawCenterString(), scr_con_current, SCR_DrawBrand(), SCR_DrawConsole(), SCR_DrawInfobar(), SCR_DrawLoadingScreen(), SCR_DrawNet(), SCR_DrawNetGraph(), SCR_DrawPause(), SCR_DrawTouchscreenOverlay(), SCR_DrawTurtle(), scr_fov, scr_loading, SCR_ScreenShot(), scr_viewsize, r_refdef_view_t::showdebug, SHOWLMP_drawall(), client_static_t::signon, SIGNONS, size, cvar_t::string, client_static_t::td_frames, tempmempool, client_state_t::time, client_static_t::timedemo, timedemo_screenshotframelist, r_refdef_view_t::useperspective, cvar_t::value, vid, vid_pixelheight, r_refdef_t::view, client_state_t::viewzoom, r_refdef_view_t::width, viddef_mode_t::width, r_refdef_view_t::x, r_refdef_view_t::y, and r_refdef_view_t::z.

Referenced by CL_UpdateScreen().

◆ SCR_DrawTouchscreenOverlay()

static void SCR_DrawTouchscreenOverlay ( void )

static

Definition at line 1507 of file cl_screen.c.

{
    int i;
    scr_touchscreenarea_t *a;
    cachepic_t *pic;
    for (i = 0, a = scr_touchscreenareas;i < scr_numtouchscreenareas;i++, a++)
    {
        if (vid_touchscreen_outlinealpha.value > 0 && a->rect[0] >= 0 && a->rect[1] >= 0 && a->rect[2] >= 4 && a->rect[3] >= 4)
        {
            DrawQ_Fill(a->rect[0] +              2, a->rect[1]                 , a->rect[2] - 4,          1    , 1, 1, 1, vid_touchscreen_outlinealpha.value * (0.5f + 0.5f * a->active), 0);
            DrawQ_Fill(a->rect[0] +              1, a->rect[1] +              1, a->rect[2] - 2,          1    , 1, 1, 1, vid_touchscreen_outlinealpha.value * (0.5f + 0.5f * a->active), 0);
            DrawQ_Fill(a->rect[0]                 , a->rect[1] +              2,          2    , a->rect[3] - 2, 1, 1, 1, vid_touchscreen_outlinealpha.value * (0.5f + 0.5f * a->active), 0);
            DrawQ_Fill(a->rect[0] + a->rect[2] - 2, a->rect[1] +              2,          2    , a->rect[3] - 2, 1, 1, 1, vid_touchscreen_outlinealpha.value * (0.5f + 0.5f * a->active), 0);
            DrawQ_Fill(a->rect[0] +              1, a->rect[1] + a->rect[3] - 2, a->rect[2] - 2,          1    , 1, 1, 1, vid_touchscreen_outlinealpha.value * (0.5f + 0.5f * a->active), 0);
            DrawQ_Fill(a->rect[0] +              2, a->rect[1] + a->rect[3] - 1, a->rect[2] - 4,          1    , 1, 1, 1, vid_touchscreen_outlinealpha.value * (0.5f + 0.5f * a->active), 0);
        }
        pic = a->pic ? Draw_CachePic_Flags(a->pic, CACHEPICFLAG_FAILONMISSING) : NULL;
        if (Draw_IsPicLoaded(pic))
            DrawQ_Pic(a->rect[0], a->rect[1], pic, a->rect[2], a->rect[3], 1, 1, 1, vid_touchscreen_overlayalpha.value * (0.5f + 0.5f * a->active), 0);
        if (a->text && a->text[0])
        {
            int textwidth = DrawQ_TextWidth(a->text, 0, a->textheight, a->textheight, false, FONT_CHAT);
            DrawQ_String(a->rect[0] + (a->rect[2] - textwidth) * 0.5f, a->rect[1] + (a->rect[3] - a->textheight) * 0.5f, a->text, 0, a->textheight, a->textheight, 1.0f, 1.0f, 1.0f, vid_touchscreen_overlayalpha.value, 0, NULL, false, FONT_CHAT);
        }
    }
}

References a, CACHEPICFLAG_FAILONMISSING, Draw_CachePic_Flags(), Draw_IsPicLoaded(), DrawQ_Fill(), DrawQ_Pic(), DrawQ_String(), DrawQ_TextWidth(), FONT_CHAT, i, NULL, scr_numtouchscreenareas, scr_touchscreenareas, cvar_t::value, vid_touchscreen_outlinealpha, and vid_touchscreen_overlayalpha.

Referenced by SCR_DrawScreen().

◆ SCR_DrawTurtle()

static void SCR_DrawTurtle ( void )

static

Definition at line 418 of file cl_screen.c.

{
    static int  count;
 
    if (cls.state != ca_connected)
        return;
 
    if (!scr_showturtle.integer)
        return;
 
    if (cl.realframetime < 0.1)
    {
        count = 0;
        return;
    }
 
    count++;
    if (count < 3)
        return;
 
    DrawQ_Pic (0, 0, Draw_CachePic ("gfx/turtle"), 0, 0, 1, 1, 1, 1, 0);
}

References ca_connected, cl, cls, count, Draw_CachePic(), DrawQ_Pic(), cvar_t::integer, client_state_t::realframetime, scr_showturtle, and client_static_t::state.

Referenced by SCR_DrawScreen().

◆ SCR_EndLoadingPlaque()

void SCR_EndLoadingPlaque ( void )

Definition at line 1865 of file cl_screen.c.

{
    scr_loading = false;
    SCR_ClearLoadingScreenTexture();
}

References SCR_ClearLoadingScreenTexture(), and scr_loading.

Referenced by CL_UpdateScreen().

◆ SCR_InfoBar_f()

static void SCR_InfoBar_f ( cmd_state_t * cmd )

static

Definition at line 692 of file cl_screen.c.

{
    if(Cmd_Argc(cmd) == 3)
    {
        scr_infobartime_off = atof(Cmd_Argv(cmd, 1));
        dp_strlcpy(scr_infobarstring, Cmd_Argv(cmd, 2), sizeof(scr_infobarstring));
    }
    else
    {
        Con_Printf("usage:\ninfobar expiretime \"string\"\n");
    }
}

References cmd(), Cmd_Argc(), Cmd_Argv(), Con_Printf(), dp_strlcpy, scr_infobarstring, and scr_infobartime_off.

Referenced by CL_Screen_Init().

◆ SCR_InfobarHeight()

static int SCR_InfobarHeight ( void )

static

Definition at line 661 of file cl_screen.c.

{
    int offset = 0;
    Curl_downloadinfo_t *downinfo;
    const char *addinfo;
    int nDownloads;
    char addinfobuf[128];
 
    if (cl.time > cl.oldtime)
        scr_infobartime_off -= cl.time - cl.oldtime;
    if(scr_infobartime_off > 0)
        offset += 1;
    if(cls.qw_downloadname[0])
        offset += 1;
 
    downinfo = Curl_GetDownloadInfo(&nDownloads, &addinfo, addinfobuf, sizeof(addinfobuf));
    if(downinfo)
    {
        offset += (nDownloads + (addinfo ? 1 : 0));
        Z_Free(downinfo);
    }
    offset *= scr_infobar_height.value;
 
    return offset;
}

References cl, cls, Curl_GetDownloadInfo(), offset, client_state_t::oldtime, client_static_t::qw_downloadname, scr_infobar_height, scr_infobartime_off, client_state_t::time, cvar_t::value, and Z_Free.

Referenced by SCR_DrawConsole().

◆ SCR_PopLoadingScreen()

void SCR_PopLoadingScreen ( qbool redraw )

Definition at line 1899 of file cl_screen.c.

{
    loadingscreenstack_t *s = loadingscreenstack;
 
    if(!s)
    {
        Con_DPrintf("Popping a loading screen item from an empty stack!\n");
        return;
    }
 
    loadingscreenstack = s->prev;
    if(s->prev)
        s->prev->relative_completion = (s->absolute_loading_amount_min + s->absolute_loading_amount_len - s->prev->absolute_loading_amount_min) / s->prev->absolute_loading_amount_len;
    Z_Free(s);
 
    if (scr_loading && redraw)
        CL_UpdateScreen();
}

References loadingscreenstack_t::absolute_loading_amount_len, loadingscreenstack_t::absolute_loading_amount_min, CL_UpdateScreen(), Con_DPrintf(), loadingscreenstack, loadingscreenstack_t::prev, scr_loading, and Z_Free.

Referenced by CL_BeginDownloads(), Mod_LoadModel(), Mod_Reload(), mod_start(), S_LoadSound(), and SCR_ClearLoadingScreen().

◆ SCR_PushLoadingScreen()

void SCR_PushLoadingScreen	(	const char *	msg,
		float	len_in_parent )

Definition at line 1873 of file cl_screen.c.

{
    loadingscreenstack_t *s = (loadingscreenstack_t *) Z_Malloc(sizeof(loadingscreenstack_t));
    s->prev = loadingscreenstack;
    loadingscreenstack = s;
 
    dp_strlcpy(s->msg, msg, sizeof(s->msg));
    s->relative_completion = 0;
 
    if(s->prev)
    {
        s->absolute_loading_amount_min = s->prev->absolute_loading_amount_min + s->prev->absolute_loading_amount_len * s->prev->relative_completion;
        s->absolute_loading_amount_len = s->prev->absolute_loading_amount_len * len_in_parent;
        if(s->absolute_loading_amount_len > s->prev->absolute_loading_amount_min + s->prev->absolute_loading_amount_len - s->absolute_loading_amount_min)
            s->absolute_loading_amount_len = s->prev->absolute_loading_amount_min + s->prev->absolute_loading_amount_len - s->absolute_loading_amount_min;
    }
    else
    {
        s->absolute_loading_amount_min = 0;
        s->absolute_loading_amount_len = 1;
    }
 
    if (scr_loading)
        CL_UpdateScreen();
}

References loadingscreenstack_t::absolute_loading_amount_len, loadingscreenstack_t::absolute_loading_amount_min, CL_UpdateScreen(), dp_strlcpy, loadingscreenstack, loadingscreenstack_t::msg, loadingscreenstack_t::prev, loadingscreenstack_t::relative_completion, scr_loading, and Z_Malloc.

Referenced by CL_BeginDownloads(), Mod_LoadModel(), Mod_Reload(), mod_start(), and S_LoadSound().

◆ SCR_ScreenShot()

qbool SCR_ScreenShot	(	char *	filename,
		unsigned char *	buffer1,
		unsigned char *	buffer2,
		int	x,
		int	y,
		int	width,
		int	height,
		qbool	flipx,
		qbool	flipy,
		qbool	flipdiagonal,
		qbool	jpeg,
		qbool	png,
		qbool	gammacorrect,
		qbool	keep_alpha )

Definition at line 1443 of file cl_screen.c.

{
    int indices[4] = {0,1,2,3}; // BGRA
    qbool ret;
 
    GL_ReadPixelsBGRA(x, y, width, height, buffer1);
 
    if(gammacorrect && (scr_screenshot_gammaboost.value != 1))
    {
        int i;
        double igamma = 1.0 / scr_screenshot_gammaboost.value;
        unsigned short vidramp[256 * 3];
        // identity gamma table
        BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, vidramp, 256);
        BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, vidramp + 256, 256);
        BuildGammaTable16(1.0f, 1.0f, 1.0f, 0.0f, 1.0f, vidramp + 256*2, 256);
        if(scr_screenshot_gammaboost.value != 1)
        {
            for (i = 0;i < 256 * 3;i++)
                vidramp[i] = (unsigned short) (0.5 + pow(vidramp[i] * (1.0 / 65535.0), igamma) * 65535.0);
        }
        for (i = 0;i < width*height*4;i += 4)
        {
            buffer1[i] = (unsigned char) (vidramp[buffer1[i] + 512] * 255.0 / 65535.0 + 0.5); // B
            buffer1[i+1] = (unsigned char) (vidramp[buffer1[i+1] + 256] * 255.0 / 65535.0 + 0.5); // G
            buffer1[i+2] = (unsigned char) (vidramp[buffer1[i+2]] * 255.0 / 65535.0 + 0.5); // R
            // A
        }
    }
 
    if(keep_alpha && !jpeg)
    {
        if(!png)
            flipy = !flipy; // TGA: not preflipped
        Image_CopyMux (buffer2, buffer1, width, height, flipx, flipy, flipdiagonal, 4, 4, indices);
        if (png)
            ret = PNG_SaveImage_preflipped (filename, width, height, true, buffer2);
        else
            ret = Image_WriteTGABGRA(filename, width, height, buffer2);
    }
    else
    {
        if(jpeg)
        {
            indices[0] = 2;
            indices[2] = 0; // RGB
        }
        Image_CopyMux (buffer2, buffer1, width, height, flipx, flipy, flipdiagonal, 3, 4, indices);
        if (jpeg)
            ret = JPEG_SaveImage_preflipped (filename, width, height, buffer2);
        else if (png)
            ret = PNG_SaveImage_preflipped (filename, width, height, false, buffer2);
        else
            ret = Image_WriteTGABGR_preflipped (filename, width, height, buffer2);
    }
 
    return ret;
}

References BuildGammaTable16(), GL_ReadPixelsBGRA(), height, i, Image_CopyMux(), Image_WriteTGABGR_preflipped(), Image_WriteTGABGRA(), indices, JPEG_SaveImage_preflipped(), PNG_SaveImage_preflipped(), pow(), ret, scr_screenshot_gammaboost, cvar_t::value, width, x, and y.

Referenced by R_Envmap_f(), SCR_DrawScreen(), and SCR_ScreenShot_f().

◆ SCR_ScreenShot_f()

void SCR_ScreenShot_f ( cmd_state_t * cmd )

static

Definition at line 919 of file cl_screen.c.

{
    static int shotnumber;
    static char old_prefix_name[MAX_QPATH];
    char prefix_name[MAX_QPATH];
    char filename[MAX_QPATH];
    unsigned char *buffer1;
    unsigned char *buffer2;
    qbool jpeg = (scr_screenshot_jpeg.integer != 0);
    qbool png = (scr_screenshot_png.integer != 0) && !jpeg;
    char vabuf[1024];
 
    if (Cmd_Argc(cmd) == 2)
    {
        const char *ext;
        dp_strlcpy(filename, Cmd_Argv(cmd, 1), sizeof(filename));
        ext = FS_FileExtension(filename);
        if (!strcasecmp(ext, "jpg"))
        {
            jpeg = true;
            png = false;
        }
        else if (!strcasecmp(ext, "tga"))
        {
            jpeg = false;
            png = false;
        }
        else if (!strcasecmp(ext, "png"))
        {
            jpeg = false;
            png = true;
        }
        else
        {
            Con_Printf("screenshot: supplied filename must end in .jpg or .tga or .png\n");
            return;
        }
    }
    else if (scr_screenshot_timestamp.integer)
    {
        int shotnumber100;
 
        // TODO maybe make capturevideo and screenshot use similar name patterns?
        Sys_TimeString(vabuf, sizeof(vabuf), "%Y%m%d%H%M%S");
        if (scr_screenshot_name_in_mapdir.integer && cl.worldbasename[0])
            dpsnprintf(prefix_name, sizeof(prefix_name), "%s/%s%s", cl.worldbasename, scr_screenshot_name.string, vabuf);
        else
            dpsnprintf(prefix_name, sizeof(prefix_name), "%s%s", scr_screenshot_name.string, vabuf);
 
        // find a file name to save it to
        for (shotnumber100 = 0;shotnumber100 < 100;shotnumber100++)
            if (!FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s-%02d.tga", fs_gamedir, prefix_name, shotnumber100))
             && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s-%02d.jpg", fs_gamedir, prefix_name, shotnumber100))
             && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s-%02d.png", fs_gamedir, prefix_name, shotnumber100)))
                break;
        if (shotnumber100 >= 100)
        {
            Con_Print("Couldn't create the image file - already 100 shots taken this second!\n");
            return;
        }
 
        dpsnprintf(filename, sizeof(filename), "screenshots/%s-%02d.%s", prefix_name, shotnumber100, jpeg ? "jpg" : png ? "png" : "tga");
    }
    else
    {
        // TODO maybe make capturevideo and screenshot use similar name patterns?
        Sys_TimeString(vabuf, sizeof(vabuf), scr_screenshot_name.string);
        if (scr_screenshot_name_in_mapdir.integer && cl.worldbasename[0])
            dpsnprintf(prefix_name, sizeof(prefix_name), "%s/%s", cl.worldbasename, vabuf);
        else
            dpsnprintf(prefix_name, sizeof(prefix_name), "%s", vabuf);
 
        // if prefix changed, gamedir or map changed, reset the shotnumber so
        // we scan again
        // FIXME: should probably do this whenever FS_Rescan or something like that occurs?
        if (strcmp(old_prefix_name, prefix_name))
        {
            dpsnprintf(old_prefix_name, sizeof(old_prefix_name), "%s", prefix_name );
            shotnumber = 0;
        }
 
        // find a file name to save it to
        for (;shotnumber < 1000000;shotnumber++)
            if (!FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s%06d.tga", fs_gamedir, prefix_name, shotnumber))
             && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s%06d.jpg", fs_gamedir, prefix_name, shotnumber))
             && !FS_SysFileExists(va(vabuf, sizeof(vabuf), "%s/screenshots/%s%06d.png", fs_gamedir, prefix_name, shotnumber)))
                break;
        if (shotnumber >= 1000000)
        {
            Con_Print("Couldn't create the image file - you already have 1000000 screenshots!\n");
            return;
        }
 
        dpsnprintf(filename, sizeof(filename), "screenshots/%s%06d.%s", prefix_name, shotnumber, jpeg ? "jpg" : png ? "png" : "tga");
 
        shotnumber++;
    }
 
    buffer1 = (unsigned char *)Mem_Alloc(tempmempool, vid.mode.width * vid.mode.height * 4);
    buffer2 = (unsigned char *)Mem_Alloc(tempmempool, vid.mode.width * vid.mode.height * (scr_screenshot_alpha.integer ? 4 : 3));
 
    if (SCR_ScreenShot (filename, buffer1, buffer2, 0, 0, vid.mode.width, vid.mode.height, false, false, false, jpeg, png, true, scr_screenshot_alpha.integer != 0))
        Con_Printf("Wrote %s\n", filename);
    else
    {
        Con_Printf(CON_ERROR "Unable to write %s\n", filename);
        if(jpeg || png)
        {
            if(SCR_ScreenShot (filename, buffer1, buffer2, 0, 0, vid.mode.width, vid.mode.height, false, false, false, false, false, true, scr_screenshot_alpha.integer != 0))
            {
                dp_strlcpy(filename + strlen(filename) - 3, "tga", 4);
                Con_Printf("Wrote %s\n", filename);
            }
        }
    }
 
    Mem_Free (buffer1);
    Mem_Free (buffer2);
}

References cl, cmd(), Cmd_Argc(), Cmd_Argv(), CON_ERROR, Con_Print(), Con_Printf(), dp_strlcpy, dpsnprintf(), FS_FileExtension(), fs_gamedir, FS_SysFileExists(), viddef_mode_t::height, cvar_t::integer, MAX_QPATH, Mem_Alloc, Mem_Free, viddef_t::mode, SCR_ScreenShot(), scr_screenshot_alpha, scr_screenshot_jpeg, scr_screenshot_name, scr_screenshot_name_in_mapdir, scr_screenshot_png, scr_screenshot_timestamp, strlen(), Sys_TimeString(), tempmempool, va(), vid, viddef_mode_t::width, and client_state_t::worldbasename.

Referenced by CL_Screen_Init().

◆ SCR_SetLoadingScreenTexture()

static void SCR_SetLoadingScreenTexture ( void )

static

Definition at line 1794 of file cl_screen.c.

{
    int w, h;
    float loadingscreentexture_w;
    float loadingscreentexture_h;
 
    SCR_ClearLoadingScreenTexture();
 
    w = vid.mode.width; h = vid.mode.height;
    loadingscreentexture_w = loadingscreentexture_h = 1;
 
    loadingscreentexture = R_LoadTexture2D(r_main_texturepool, "loadingscreentexture", w, h, NULL, TEXTYPE_COLORBUFFER, TEXF_RENDERTARGET | TEXF_FORCENEAREST | TEXF_CLAMP, -1, NULL);
    R_Mesh_CopyToTexture(loadingscreentexture, 0, 0, 0, 0, vid.mode.width, vid.mode.height);
 
    loadingscreentexture_vertex3f[2] = loadingscreentexture_vertex3f[5] = loadingscreentexture_vertex3f[8] = loadingscreentexture_vertex3f[11] = 0;
    loadingscreentexture_vertex3f[0] = loadingscreentexture_vertex3f[9] = 0;
    loadingscreentexture_vertex3f[1] = loadingscreentexture_vertex3f[4] = 0;
    loadingscreentexture_vertex3f[3] = loadingscreentexture_vertex3f[6] = vid_conwidth.integer;
    loadingscreentexture_vertex3f[7] = loadingscreentexture_vertex3f[10] = vid_conheight.integer;
    loadingscreentexture_texcoord2f[0] = 0;loadingscreentexture_texcoord2f[1] = loadingscreentexture_h;
    loadingscreentexture_texcoord2f[2] = loadingscreentexture_w;loadingscreentexture_texcoord2f[3] = loadingscreentexture_h;
    loadingscreentexture_texcoord2f[4] = loadingscreentexture_w;loadingscreentexture_texcoord2f[5] = 0;
    loadingscreentexture_texcoord2f[6] = 0;loadingscreentexture_texcoord2f[7] = 0;
}

References viddef_mode_t::height, cvar_t::integer, loadingscreentexture, loadingscreentexture_texcoord2f, loadingscreentexture_vertex3f, viddef_t::mode, NULL, R_LoadTexture2D(), r_main_texturepool, R_Mesh_CopyToTexture(), SCR_ClearLoadingScreenTexture(), TEXF_CLAMP, TEXF_FORCENEAREST, TEXF_RENDERTARGET, TEXTYPE_COLORBUFFER, vid, vid_conheight, vid_conwidth, w, and viddef_mode_t::width.

Referenced by SCR_BeginLoadingPlaque().

◆ SCR_SetUpToDrawConsole()

static void SCR_SetUpToDrawConsole ( void )

static

Definition at line 711 of file cl_screen.c.

{
#ifdef CONFIG_MENU
    static int framecounter = 0;
#endif
 
    Con_CheckResize ();
 
#ifdef CONFIG_MENU
    if (scr_menuforcewhiledisconnected.integer && key_dest == key_game && cls.state == ca_disconnected)
    {
        if (framecounter >= 2)
            MR_ToggleMenu(1);
        else
            framecounter++;
    }
    else
        framecounter = 0;
#endif
 
    if (scr_conforcewhiledisconnected.integer >= 2 && key_dest == key_game && cls.signon != SIGNONS)
        key_consoleactive |= KEY_CONSOLEACTIVE_FORCED;
    else if (scr_conforcewhiledisconnected.integer >= 1 && key_dest == key_game && cls.signon != SIGNONS && !sv.active)
        key_consoleactive |= KEY_CONSOLEACTIVE_FORCED;
    else
        key_consoleactive &= ~KEY_CONSOLEACTIVE_FORCED;
 
    // decide on the height of the console
    if (key_consoleactive & KEY_CONSOLEACTIVE_USER)
        scr_con_current = vid_conheight.integer * scr_conheight.value;
    else
        scr_con_current = 0; // none visible
}

References server_t::active, ca_disconnected, cls, Con_CheckResize(), cvar_t::integer, key_consoleactive, KEY_CONSOLEACTIVE_FORCED, KEY_CONSOLEACTIVE_USER, key_dest, key_game, MR_ToggleMenu, scr_con_current, scr_conforcewhiledisconnected, scr_conheight, client_static_t::signon, SIGNONS, client_static_t::state, sv, cvar_t::value, and vid_conheight.

Referenced by CL_UpdateScreen().

◆ SCR_SizeDown_f()

static void SCR_SizeDown_f ( cmd_state_t * cmd )

static

Definition at line 789 of file cl_screen.c.

{
    Cvar_SetValueQuick(&scr_viewsize, scr_viewsize.value - 10);
}

References Cvar_SetValueQuick(), scr_viewsize, and cvar_t::value.

Referenced by CL_Screen_Init().

◆ SCR_SizeUp_f()

static void SCR_SizeUp_f ( cmd_state_t * cmd )

static

Definition at line 776 of file cl_screen.c.

{
    Cvar_SetValueQuick(&scr_viewsize, scr_viewsize.value + 10);
}

References Cvar_SetValueQuick(), scr_viewsize, and cvar_t::value.

Referenced by CL_Screen_Init().

◆ SCR_UpdateVars()

static void SCR_UpdateVars ( void )

static

Definition at line 2082 of file cl_screen.c.

{
    float conwidth = bound(160, vid_conwidth.value, 32768);
    float conheight = bound(90, vid_conheight.value, 24576);
    float conscale = vid.mode.height / vid_conheight.value;
    if (vid_conwidthauto.integer)
        conwidth = floor(conheight * vid.mode.width / (vid.mode.height * vid_pixelheight.value));
    if (vid_conwidth.value != conwidth)
        Cvar_SetValueQuick(&vid_conwidth, conwidth);
    if (vid_conheight.value != conheight)
        Cvar_SetValueQuick(&vid_conheight, conheight);
    if (scr_sbarscale.value != conscale)
        Cvar_SetValueQuick(&scr_sbarscale, conscale);
 
    // bound viewsize
    if (scr_viewsize.value < 30)
        Cvar_SetValueQuick(&scr_viewsize, 30);
    if (scr_viewsize.value > 120)
        Cvar_SetValueQuick(&scr_viewsize, 120);
 
    // bound field of view
    if (scr_fov.value < 1)
        Cvar_SetValueQuick(&scr_fov, 1);
    if (scr_fov.value > 170)
        Cvar_SetValueQuick(&scr_fov, 170);
 
    // intermission is always full screen
    if (cl.intermission)
        sb_lines = 0;
    else
    {
        if (scr_viewsize.value >= 120)
            sb_lines = 0;       // no status bar at all
        else if (scr_viewsize.value >= 110)
            sb_lines = 24;      // no inventory
        else
            sb_lines = 24 + 16 + 8;
    }
}

References bound, cl, Cvar_SetValueQuick(), floor(), viddef_mode_t::height, cvar_t::integer, client_state_t::intermission, viddef_t::mode, sb_lines, scr_fov, scr_sbarscale, scr_viewsize, cvar_t::value, vid, vid_conheight, vid_conwidth, vid_conwidthauto, vid_pixelheight, and viddef_mode_t::width.

Referenced by CL_UpdateScreen().

◆ SHOWLMP_decodehide()

void SHOWLMP_decodehide ( void )

Definition at line 1368 of file cl_screen.c.

{
    int i;
    char *lmplabel;
    lmplabel = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
    for (i = 0;i < cl.num_showlmps;i++)
        if (cl.showlmps[i].isactive && strcmp(cl.showlmps[i].label, lmplabel) == 0)
        {
            cl.showlmps[i].isactive = false;
            return;
        }
}

References cl, cl_message, cl_readstring, i, showlmp_t::isactive, showlmp_t::label, MSG_ReadString(), client_state_t::num_showlmps, and client_state_t::showlmps.

Referenced by CL_ParseServerMessage().

◆ SHOWLMP_decodeshow()

void SHOWLMP_decodeshow ( void )

Definition at line 1381 of file cl_screen.c.

{
    int k;
    char lmplabel[256], picname[256];
    float x, y;
    dp_strlcpy (lmplabel,MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (lmplabel));
    dp_strlcpy (picname, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)), sizeof (picname));
    if (gamemode == GAME_NEHAHRA) // LadyHavoc: nasty old legacy junk
    {
        x = MSG_ReadByte(&cl_message);
        y = MSG_ReadByte(&cl_message);
    }
    else
    {
        x = MSG_ReadShort(&cl_message);
        y = MSG_ReadShort(&cl_message);
    }
    if (!cl.showlmps || cl.num_showlmps >= cl.max_showlmps)
    {
        showlmp_t *oldshowlmps = cl.showlmps;
        cl.max_showlmps += 16;
        cl.showlmps = (showlmp_t *) Mem_Alloc(cls.levelmempool, cl.max_showlmps * sizeof(showlmp_t));
        if (oldshowlmps)
        {
            if (cl.num_showlmps)
                memcpy(cl.showlmps, oldshowlmps, cl.num_showlmps * sizeof(showlmp_t));
            Mem_Free(oldshowlmps);
        }
    }
    for (k = 0;k < cl.max_showlmps;k++)
        if (cl.showlmps[k].isactive && !strcmp(cl.showlmps[k].label, lmplabel))
            break;
    if (k == cl.max_showlmps)
        for (k = 0;k < cl.max_showlmps;k++)
            if (!cl.showlmps[k].isactive)
                break;
    cl.showlmps[k].isactive = true;
    dp_strlcpy (cl.showlmps[k].label, lmplabel, sizeof (cl.showlmps[k].label));
    dp_strlcpy (cl.showlmps[k].pic, picname, sizeof (cl.showlmps[k].pic));
    cl.showlmps[k].x = x;
    cl.showlmps[k].y = y;
    cl.num_showlmps = max(cl.num_showlmps, k + 1);
}

References cl, cl_message, cl_readstring, cls, dp_strlcpy, GAME_NEHAHRA, gamemode, showlmp_t::isactive, showlmp_t::label, client_static_t::levelmempool, max, client_state_t::max_showlmps, Mem_Alloc, Mem_Free, MSG_ReadByte, MSG_ReadShort, MSG_ReadString(), client_state_t::num_showlmps, showlmp_t::pic, client_state_t::showlmps, showlmp_t::x, x, showlmp_t::y, and y.

Referenced by CL_ParseServerMessage().

◆ SHOWLMP_drawall()

void SHOWLMP_drawall ( void )

Definition at line 1425 of file cl_screen.c.

{
    int i;
    for (i = 0;i < cl.num_showlmps;i++)
        if (cl.showlmps[i].isactive)
            DrawQ_Pic(cl.showlmps[i].x, cl.showlmps[i].y, Draw_CachePic_Flags (cl.showlmps[i].pic, CACHEPICFLAG_NOTPERSISTENT), 0, 0, 1, 1, 1, 1, 0);
}

References CACHEPICFLAG_NOTPERSISTENT, cl, Draw_CachePic_Flags(), DrawQ_Pic(), i, showlmp_t::isactive, client_state_t::num_showlmps, showlmp_t::pic, client_state_t::showlmps, showlmp_t::x, and showlmp_t::y.

Referenced by SCR_DrawScreen().

Variable Documentation

◆ cl_connect_status

char cl_connect_status[MAX_QPATH]

User-friendly connection status for the menu and/or loading screen, colours and
not supported.

Definition at line 1573 of file cl_screen.c.

Referenced by CL_DisconnectEx(), CL_EstablishConnection(), CL_SetSignonStage_WithMsg(), M_LanConfig_Draw(), M_Menu_LanConfig_f(), M_Menu_ModList_f(), M_Menu_ServerList_f(), M_ModList_Draw(), M_ServerList_Draw(), NetConn_ClientFrame(), NetConn_ClientParsePacket(), NetConn_ConnectionEstablished(), and SCR_DrawScreen().

◆ cl_demo_mousegrab

cvar_t cl_demo_mousegrab = {CF_CLIENT, "cl_demo_mousegrab", "0", "Allows reading the mouse input while playing demos. Useful for camera mods developed in csqc. (0: never, 1: always)"}

Definition at line 92 of file cl_screen.c.

92{CF_CLIENT, "cl_demo_mousegrab", "0", "Allows reading the mouse input while playing demos. Useful for camera mods developed in csqc. (0: never, 1: always)"};

Referenced by CL_Screen_Init(), and Sys_SDL_HandleEvents().

◆ cl_minfps

cvar_t cl_minfps

extern

Definition at line 100 of file cl_main.c.

100{CF_CLIENT | CF_ARCHIVE, "cl_minfps", "40", "minimum fps target - while the rendering performance is below this, it will drift toward lower quality"};

CF_ARCHIVE

#define CF_ARCHIVE

cvar should have its set value saved to config.cfg and persist across sessions

Definition cmd.h:53

Referenced by CL_Init(), and CL_UpdateScreen().

◆ cl_minfps_fade

cvar_t cl_minfps_fade

extern

Definition at line 101 of file cl_main.c.

101{CF_CLIENT | CF_ARCHIVE, "cl_minfps_fade", "1", "how fast the quality adapts to varying framerate"};

Referenced by CL_Init(), and CL_UpdateScreen().

◆ cl_minfps_force

cvar_t cl_minfps_force

extern

Definition at line 107 of file cl_main.c.

107{CF_CLIENT, "cl_minfps_force", "0", "also apply quality reductions in timedemo/capturevideo"};

Referenced by CL_Init(), and CL_UpdateScreen().

◆ cl_minfps_qualityhysteresis

cvar_t cl_minfps_qualityhysteresis

extern

Definition at line 105 of file cl_main.c.

105{CF_CLIENT | CF_ARCHIVE, "cl_minfps_qualityhysteresis", "0.05", "reduce all quality increments by this to reduce flickering"};

Referenced by CL_Init(), and CL_UpdateScreen().

◆ cl_minfps_qualitymax

cvar_t cl_minfps_qualitymax

extern

Definition at line 102 of file cl_main.c.

102{CF_CLIENT | CF_ARCHIVE, "cl_minfps_qualitymax", "1", "highest allowed drawdistance multiplier"};

Referenced by CL_Init(), and CL_UpdateScreen().

◆ cl_minfps_qualitymin

cvar_t cl_minfps_qualitymin

extern

Definition at line 103 of file cl_main.c.

103{CF_CLIENT | CF_ARCHIVE, "cl_minfps_qualitymin", "0.25", "lowest allowed drawdistance multiplier"};

Referenced by CL_Init(), and CL_UpdateScreen().

◆ cl_minfps_qualitymultiply

cvar_t cl_minfps_qualitymultiply

extern

Definition at line 104 of file cl_main.c.

104{CF_CLIENT | CF_ARCHIVE, "cl_minfps_qualitymultiply", "0.2", "multiplier for quality changes in quality change per second render time (1 assumes linearity of quality and render time)"};

Referenced by CL_Init(), and CL_UpdateScreen().

◆ cl_minfps_qualitystepmax

cvar_t cl_minfps_qualitystepmax

extern

Definition at line 106 of file cl_main.c.

106{CF_CLIENT | CF_ARCHIVE, "cl_minfps_qualitystepmax", "0.1", "maximum quality change in a single frame"};

Referenced by CL_Init(), and CL_UpdateScreen().

◆ cl_punchangle_applied

int cl_punchangle_applied

extern

Definition at line 149 of file view.c.

Referenced by CL_UpdateScreen(), and V_CalcRefdefUsing().

◆ con_vislines

int con_vislines

extern

Definition at line 95 of file console.c.

Referenced by SCR_DrawConsole().

◆ envmapinfo

struct envmapinfo_s envmapinfo[12]

Initial value:

=
{
    {{  0,   0, 0}, "rt", false, false, false},
    {{  0, 270, 0}, "ft", false, false, false},
    {{  0, 180, 0}, "lf", false, false, false},
    {{  0,  90, 0}, "bk", false, false, false},
    {{-90, 180, 0}, "up",  true,  true, false},
    {{ 90, 180, 0}, "dn",  true,  true, false},
 
    {{  0,   0, 0}, "px",  true,  true,  true},
    {{  0,  90, 0}, "py", false,  true, false},
    {{  0, 180, 0}, "nx", false, false,  true},
    {{  0, 270, 0}, "ny",  true, false, false},
    {{-90, 180, 0}, "pz", false, false,  true},
    {{ 90, 180, 0}, "nz", false, false,  true}
}

Referenced by R_Envmap_f().

◆ jpeg_supported

int jpeg_supported = false

Definition at line 100 of file cl_screen.c.

◆ loadingscreenpic_number

int loadingscreenpic_number = 0

static

Definition at line 1570 of file cl_screen.c.

Referenced by SCR_ChooseLoadingPic(), and SCR_DrawLoadingScreen().

◆ loadingscreenstack

loadingscreenstack_t* loadingscreenstack = NULL

static

Definition at line 1566 of file cl_screen.c.

Referenced by CL_UpdateScreen(), SCR_BeginLoadingPlaque(), SCR_ClearLoadingScreen(), SCR_DrawLoadingStack(), SCR_DrawScreen(), SCR_PopLoadingScreen(), and SCR_PushLoadingScreen().

◆ loadingscreentexture

rtexture_t* loadingscreentexture = NULL

Definition at line 1567 of file cl_screen.c.

Referenced by gl_main_shutdown(), gl_main_start(), SCR_ClearLoadingScreenTexture(), SCR_DrawLoadingScreen(), and SCR_SetLoadingScreenTexture().

◆ loadingscreentexture_texcoord2f

float loadingscreentexture_texcoord2f[8]

static

Definition at line 1569 of file cl_screen.c.

Referenced by SCR_DrawLoadingScreen(), and SCR_SetLoadingScreenTexture().

◆ loadingscreentexture_vertex3f

float loadingscreentexture_vertex3f[12]

static

Definition at line 1568 of file cl_screen.c.

Referenced by SCR_DrawLoadingScreen(), and SCR_SetLoadingScreenTexture().

◆ net_graph

cvar_t net_graph = {CF_CLIENT | CF_ARCHIVE, "net_graph", "0", "shows a graph of packet sizes and other information, 0 = off, 1 = show client netgraph, 2 = show client and server netgraphs (when hosting a server)"}

Definition at line 91 of file cl_screen.c.

91{CF_CLIENT | CF_ARCHIVE, "net_graph", "0", "shows a graph of packet sizes and other information, 0 = off, 1 = show client netgraph, 2 = show client and server netgraphs (when hosting a server)"};

Referenced by CL_Screen_Init(), and SCR_DrawNetGraph().

◆ r_fog_clear

cvar_t r_fog_clear

extern

Definition at line 138 of file gl_rmain.c.

138{CF_CLIENT, "r_fog_clear", "1", "clears renderbuffer with fog color before render starts"};

Referenced by GL_Main_Init(), and R_ClearScreen().

◆ r_letterbox

cvar_t r_letterbox = {CF_CLIENT, "r_letterbox", "0", "reduces vertical height of view to simulate a letterboxed movie effect (can be used by mods for cutscenes)"}

Definition at line 79 of file cl_screen.c.

79{CF_CLIENT, "r_letterbox", "0", "reduces vertical height of view to simulate a letterboxed movie effect (can be used by mods for cutscenes)"};

Referenced by CL_Screen_Init(), Sbar_Draw(), and SCR_DrawScreen().

◆ r_main_texturepool

rtexturepool_t* r_main_texturepool

extern

Definition at line 43 of file gl_rmain.c.

Referenced by gl_main_shutdown(), gl_main_start(), R_Bloom_StartFrame(), R_BuildBlankTextures(), R_BuildFogHeightTexture(), R_BuildFogTexture(), R_BuildNormalizationCube(), R_BuildNoTexture(), R_BuildWhiteCube(), R_LoadCubemap(), R_RenderTarget_Get(), R_SkinFrame_GenerateTexturesFromQPixels(), R_SkinFrame_LoadExternal_SkinFrame(), R_SkinFrame_LoadInternal8bit(), R_SkinFrame_LoadInternalBGRA(), R_UpdateVariables(), and SCR_SetLoadingScreenTexture().

◆ r_stereo_angle

cvar_t r_stereo_angle = {CF_CLIENT, "r_stereo_angle", "0", "separation angle of eyes (makes the views look different directions, as an example, 90 gives a 90 degree separation where the views are 45 degrees left and 45 degrees right)"}

Definition at line 87 of file cl_screen.c.

87{CF_CLIENT, "r_stereo_angle", "0", "separation angle of eyes (makes the views look different directions, as an example, 90 gives a 90 degree separation where the views are 45 degrees left and 45 degrees right)"};

Referenced by CL_Screen_Init(), and R_RenderView().

◆ r_stereo_horizontal

cvar_t r_stereo_horizontal = {CF_CLIENT, "r_stereo_horizontal", "0", "aspect skewed side by side view for special decoder/display hardware"}

Definition at line 82 of file cl_screen.c.

82{CF_CLIENT, "r_stereo_horizontal", "0", "aspect skewed side by side view for special decoder/display hardware"};

Referenced by CL_Screen_Init(), R_Stereo_Active(), and SCR_DrawScreen().

◆ r_stereo_redblue

cvar_t r_stereo_redblue = {CF_CLIENT, "r_stereo_redblue", "0", "red/blue anaglyph stereo glasses (note: most of these glasses are actually red/cyan, try that one too)"}

Definition at line 84 of file cl_screen.c.

84{CF_CLIENT, "r_stereo_redblue", "0", "red/blue anaglyph stereo glasses (note: most of these glasses are actually red/cyan, try that one too)"};

Referenced by CL_Screen_Init(), CL_UpdateScreen(), and R_Stereo_ColorMasking().

◆ r_stereo_redcyan

cvar_t r_stereo_redcyan = {CF_CLIENT, "r_stereo_redcyan", "0", "red/cyan anaglyph stereo glasses, the kind given away at drive-in movies like Creature From The Black Lagoon In 3D"}

Definition at line 85 of file cl_screen.c.

85{CF_CLIENT, "r_stereo_redcyan", "0", "red/cyan anaglyph stereo glasses, the kind given away at drive-in movies like Creature From The Black Lagoon In 3D"};

Referenced by CL_Screen_Init(), CL_UpdateScreen(), and R_Stereo_ColorMasking().

◆ r_stereo_redgreen

cvar_t r_stereo_redgreen = {CF_CLIENT, "r_stereo_redgreen", "0", "red/green anaglyph stereo glasses (for those who don't mind yellow)"}

Definition at line 86 of file cl_screen.c.

86{CF_CLIENT, "r_stereo_redgreen", "0", "red/green anaglyph stereo glasses (for those who don't mind yellow)"};

Referenced by CL_Screen_Init(), CL_UpdateScreen(), and R_Stereo_ColorMasking().

◆ r_stereo_separation

cvar_t r_stereo_separation = {CF_CLIENT, "r_stereo_separation", "4", "separation distance of eyes in the world (negative values are only useful for cross-eyed viewing)"}

Definition at line 80 of file cl_screen.c.

80{CF_CLIENT, "r_stereo_separation", "4", "separation distance of eyes in the world (negative values are only useful for cross-eyed viewing)"};

Referenced by CL_Screen_Init(), and R_RenderView().

◆ r_stereo_side

int r_stereo_side

Definition at line 1553 of file cl_screen.c.

Referenced by CL_UpdateScreen(), R_RenderView(), and SCR_DrawScreen().

◆ r_stereo_sidebyside

cvar_t r_stereo_sidebyside = {CF_CLIENT, "r_stereo_sidebyside", "0", "side by side views for those who can't afford glasses but can afford eye strain (note: use a negative r_stereo_separation if you want cross-eyed viewing)"}

Definition at line 81 of file cl_screen.c.

81{CF_CLIENT, "r_stereo_sidebyside", "0", "side by side views for those who can't afford glasses but can afford eye strain (note: use a negative r_stereo_separation if you want cross-eyed viewing)"};

Referenced by CL_Screen_Init(), R_Stereo_Active(), and SCR_DrawScreen().

◆ r_stereo_vertical

cvar_t r_stereo_vertical = {CF_CLIENT, "r_stereo_vertical", "0", "aspect skewed top and bottom view for special decoder/display hardware"}

Definition at line 83 of file cl_screen.c.

83{CF_CLIENT, "r_stereo_vertical", "0", "aspect skewed top and bottom view for special decoder/display hardware"};

Referenced by CL_Screen_Init(), R_Stereo_Active(), and SCR_DrawScreen().

◆ sbar_info_pos

cvar_t sbar_info_pos

extern

Definition at line 108 of file sbar.c.

108{CF_CLIENT | CF_ARCHIVE, "sbar_info_pos", "0", "pixel position of the info strings (such as showfps), from the bottom"};

Referenced by Sbar_Init(), Sbar_ShowFPS(), and SCR_DrawNetGraph().

◆ scr_center_lines

int scr_center_lines

Definition at line 130 of file cl_screen.c.

Referenced by SCR_CenterPrint(), SCR_CheckDrawCenterString(), and SCR_DrawCenterString().

◆ scr_centerstring

char scr_centerstring[MAX_INPUTLINE]

Definition at line 127 of file cl_screen.c.

Referenced by SCR_CenterPrint(), and SCR_DrawCenterString().

◆ scr_centertime

cvar_t scr_centertime = {CF_CLIENT, "scr_centertime","2", "how long centerprint messages show"}

Definition at line 37 of file cl_screen.c.

37{CF_CLIENT, "scr_centertime","2", "how long centerprint messages show"};

Referenced by CL_Screen_Init(), SCR_CenterPrint(), and SCR_DrawCenterString().

◆ scr_centertime_off

float scr_centertime_off

Definition at line 129 of file cl_screen.c.

Referenced by SCR_CenterPrint(), SCR_CheckDrawCenterString(), and SV_SpawnServer().

◆ scr_centertime_start

float scr_centertime_start

Definition at line 128 of file cl_screen.c.

Referenced by SCR_CenterPrint(), and SCR_DrawCenterString().

◆ scr_con_current

unsigned int scr_con_current

Definition at line 106 of file cl_screen.c.

Referenced by CL_TimeDemo_f(), SCR_DrawConsole(), SCR_DrawScreen(), and SCR_SetUpToDrawConsole().

◆ scr_con_margin_bottom

unsigned int scr_con_margin_bottom

static

Definition at line 107 of file cl_screen.c.

Referenced by SCR_DrawConsole(), and SCR_DrawInfobar().

◆ scr_conalpha

cvar_t scr_conalpha = {CF_CLIENT | CF_ARCHIVE, "scr_conalpha", "0.9", "opacity of console background gfx/conback (when console isn't forced fullscreen)"}

Definition at line 21 of file cl_screen.c.

21{CF_CLIENT | CF_ARCHIVE, "scr_conalpha", "0.9", "opacity of console background gfx/conback (when console isn't forced fullscreen)"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conalpha2factor

cvar_t scr_conalpha2factor = {CF_CLIENT | CF_ARCHIVE, "scr_conalpha2factor", "0", "opacity of console background gfx/conback2 relative to scr_conalpha; when 0, gfx/conback2 is not drawn"}

Definition at line 23 of file cl_screen.c.

23{CF_CLIENT | CF_ARCHIVE, "scr_conalpha2factor", "0", "opacity of console background gfx/conback2 relative to scr_conalpha; when 0, gfx/conback2 is not drawn"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conalpha3factor

cvar_t scr_conalpha3factor = {CF_CLIENT | CF_ARCHIVE, "scr_conalpha3factor", "0", "opacity of console background gfx/conback3 relative to scr_conalpha; when 0, gfx/conback3 is not drawn"}

Definition at line 24 of file cl_screen.c.

24{CF_CLIENT | CF_ARCHIVE, "scr_conalpha3factor", "0", "opacity of console background gfx/conback3 relative to scr_conalpha; when 0, gfx/conback3 is not drawn"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conalphafactor

cvar_t scr_conalphafactor = {CF_CLIENT | CF_ARCHIVE, "scr_conalphafactor", "1", "opacity of console background gfx/conback relative to scr_conalpha; when 0, gfx/conback is not drawn"}

Definition at line 22 of file cl_screen.c.

22{CF_CLIENT | CF_ARCHIVE, "scr_conalphafactor", "1", "opacity of console background gfx/conback relative to scr_conalpha; when 0, gfx/conback is not drawn"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conbrightness

cvar_t scr_conbrightness = {CF_CLIENT | CF_ARCHIVE, "scr_conbrightness", "1", "brightness of console background (0 = black, 1 = image)"}

Definition at line 25 of file cl_screen.c.

25{CF_CLIENT | CF_ARCHIVE, "scr_conbrightness", "1", "brightness of console background (0 = black, 1 = image)"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conforcewhiledisconnected

cvar_t scr_conforcewhiledisconnected = {CF_CLIENT, "scr_conforcewhiledisconnected", "1", "1 forces fullscreen console while disconnected, 2 also forces it when the listen server has started but the client is still loading"}

Definition at line 26 of file cl_screen.c.

26{CF_CLIENT, "scr_conforcewhiledisconnected", "1", "1 forces fullscreen console while disconnected, 2 also forces it when the listen server has started but the client is still loading"};

Referenced by CL_Screen_Init(), and SCR_SetUpToDrawConsole().

◆ scr_conheight

cvar_t scr_conheight = {CF_CLIENT | CF_ARCHIVE, "scr_conheight", "0.5", "fraction of screen height occupied by console (reduced as necessary for visibility of loading progress and infobar)"}

Definition at line 27 of file cl_screen.c.

27{CF_CLIENT | CF_ARCHIVE, "scr_conheight", "0.5", "fraction of screen height occupied by console (reduced as necessary for visibility of loading progress and infobar)"};

Referenced by CL_Screen_Init(), and SCR_SetUpToDrawConsole().

◆ scr_conscroll2_x

cvar_t scr_conscroll2_x = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll2_x", "0", "scroll speed of gfx/conback2 in x direction"}

Definition at line 30 of file cl_screen.c.

30{CF_CLIENT | CF_ARCHIVE, "scr_conscroll2_x", "0", "scroll speed of gfx/conback2 in x direction"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conscroll2_y

cvar_t scr_conscroll2_y = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll2_y", "0", "scroll speed of gfx/conback2 in y direction"}

Definition at line 31 of file cl_screen.c.

31{CF_CLIENT | CF_ARCHIVE, "scr_conscroll2_y", "0", "scroll speed of gfx/conback2 in y direction"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conscroll3_x

cvar_t scr_conscroll3_x = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll3_x", "0", "scroll speed of gfx/conback3 in x direction"}

Definition at line 32 of file cl_screen.c.

32{CF_CLIENT | CF_ARCHIVE, "scr_conscroll3_x", "0", "scroll speed of gfx/conback3 in x direction"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conscroll3_y

cvar_t scr_conscroll3_y = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll3_y", "0", "scroll speed of gfx/conback3 in y direction"}

Definition at line 33 of file cl_screen.c.

33{CF_CLIENT | CF_ARCHIVE, "scr_conscroll3_y", "0", "scroll speed of gfx/conback3 in y direction"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conscroll_x

cvar_t scr_conscroll_x = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll_x", "0", "scroll speed of gfx/conback in x direction"}

Definition at line 28 of file cl_screen.c.

28{CF_CLIENT | CF_ARCHIVE, "scr_conscroll_x", "0", "scroll speed of gfx/conback in x direction"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_conscroll_y

cvar_t scr_conscroll_y = {CF_CLIENT | CF_ARCHIVE, "scr_conscroll_y", "0", "scroll speed of gfx/conback in y direction"}

Definition at line 29 of file cl_screen.c.

29{CF_CLIENT | CF_ARCHIVE, "scr_conscroll_y", "0", "scroll speed of gfx/conback in y direction"};

Referenced by CL_Screen_Init(), and Con_DrawConsole().

◆ scr_erase_center

int scr_erase_center

Definition at line 132 of file cl_screen.c.

Referenced by SCR_DrawCenterString().

◆ scr_erase_lines

int scr_erase_lines

Definition at line 131 of file cl_screen.c.

Referenced by SCR_CheckDrawCenterString().

◆ scr_fov

cvar_t scr_fov = {CF_CLIENT | CF_ARCHIVE, "fov","90", "field of vision, 1-170 degrees, default 90, some players use 110-130"}

Definition at line 20 of file cl_screen.c.

20{CF_CLIENT | CF_ARCHIVE, "fov","90", "field of vision, 1-170 degrees, default 90, some players use 110-130"};

Referenced by CL_Screen_Init(), M_Menu_Options_AdjustSliders(), M_Options_Draw(), SCR_DrawScreen(), and SCR_UpdateVars().

◆ scr_infobar_height

cvar_t scr_infobar_height = {CF_CLIENT, "scr_infobar_height", "8", "the height of the infobar items"}

Definition at line 53 of file cl_screen.c.

53{CF_CLIENT, "scr_infobar_height", "8", "the height of the infobar items"};

Referenced by CL_Screen_Init(), SCR_DrawCurlDownload(), SCR_DrawInfobarString(), SCR_DrawQWDownload(), and SCR_InfobarHeight().

◆ scr_infobarstring

char scr_infobarstring[MAX_INPUTLINE]

Definition at line 133 of file cl_screen.c.

Referenced by SCR_DrawInfobarString(), and SCR_InfoBar_f().

◆ scr_infobartime_off

float scr_infobartime_off

Definition at line 134 of file cl_screen.c.

Referenced by SCR_DrawInfobar(), SCR_InfoBar_f(), and SCR_InfobarHeight().

◆ scr_initialized

qbool scr_initialized

Definition at line 102 of file cl_screen.c.

Referenced by CL_Screen_Init(), and CL_UpdateScreen().

◆ scr_loading

qbool scr_loading = false

Definition at line 104 of file cl_screen.c.

Referenced by CL_UpdateScreen(), SCR_DeferLoadingPlaque(), SCR_DrawConsole(), SCR_DrawInfobar(), SCR_DrawScreen(), SCR_EndLoadingPlaque(), SCR_PopLoadingScreen(), SCR_PushLoadingScreen(), and Sys_SDL_HandleEvents().

◆ scr_loadingscreen_background

cvar_t scr_loadingscreen_background = {CF_CLIENT, "scr_loadingscreen_background","0", "show the last visible background during loading screen (costs one screenful of video memory)"}

Definition at line 43 of file cl_screen.c.

43{CF_CLIENT, "scr_loadingscreen_background","0", "show the last visible background during loading screen (costs one screenful of video memory)"};

Referenced by CL_Screen_Init(), and SCR_BeginLoadingPlaque().

◆ scr_loadingscreen_barcolor

cvar_t scr_loadingscreen_barcolor = {CF_CLIENT, "scr_loadingscreen_barcolor", "0 0 1", "rgb color of loadingscreen progress bar"}

Definition at line 50 of file cl_screen.c.

50{CF_CLIENT, "scr_loadingscreen_barcolor", "0 0 1", "rgb color of loadingscreen progress bar"};

Referenced by CL_Screen_Init(), and SCR_DrawLoadingStack().

◆ scr_loadingscreen_barheight

cvar_t scr_loadingscreen_barheight = {CF_CLIENT, "scr_loadingscreen_barheight", "8", "the height of the loadingscreen progress bar"}

Definition at line 51 of file cl_screen.c.

51{CF_CLIENT, "scr_loadingscreen_barheight", "8", "the height of the loadingscreen progress bar"};

Referenced by CL_Screen_Init(), SCR_DrawConsole(), SCR_DrawInfobar(), and SCR_DrawLoadingStack().

◆ scr_loadingscreen_count

cvar_t scr_loadingscreen_count = {CF_CLIENT, "scr_loadingscreen_count","1", "number of loading screen files to use randomly (named loading.tga, loading2.tga, loading3.tga, ...)"}

Definition at line 48 of file cl_screen.c.

48{CF_CLIENT, "scr_loadingscreen_count","1", "number of loading screen files to use randomly (named loading.tga, loading2.tga, loading3.tga, ...)"};

Referenced by CL_Screen_Init(), and SCR_ChooseLoadingPic().

◆ scr_loadingscreen_firstforstartup

cvar_t scr_loadingscreen_firstforstartup = {CF_CLIENT, "scr_loadingscreen_firstforstartup","0", "remove loading.tga from random scr_loadingscreen_count selection and only display it on client startup, 0 = normal, 1 = firstforstartup"}

Definition at line 49 of file cl_screen.c.

49{CF_CLIENT, "scr_loadingscreen_firstforstartup","0", "remove loading.tga from random scr_loadingscreen_count selection and only display it on client startup, 0 = normal, 1 = firstforstartup"};

Referenced by CL_Screen_Init(), and SCR_ChooseLoadingPic().

◆ scr_loadingscreen_maxfps

cvar_t scr_loadingscreen_maxfps = {CF_CLIENT, "scr_loadingscreen_maxfps", "20", "maximum FPS for loading screen so it will not update very often (this reduces loading time with lots of models)"}

Definition at line 52 of file cl_screen.c.

52{CF_CLIENT, "scr_loadingscreen_maxfps", "20", "maximum FPS for loading screen so it will not update very often (this reduces loading time with lots of models)"};

Referenced by CL_Screen_Init(), and CL_UpdateScreen().

◆ scr_loadingscreen_picture

cvar_t scr_loadingscreen_picture = {CF_CLIENT, "scr_loadingscreen_picture", "gfx/loading", "picture shown during loading"}

Definition at line 47 of file cl_screen.c.

47{CF_CLIENT, "scr_loadingscreen_picture", "gfx/loading", "picture shown during loading"};

Referenced by CL_Screen_Init(), and SCR_DrawLoadingScreen().

◆ scr_loadingscreen_scale

cvar_t scr_loadingscreen_scale = {CF_CLIENT, "scr_loadingscreen_scale","1", "scale factor of the background"}

Definition at line 44 of file cl_screen.c.

44{CF_CLIENT, "scr_loadingscreen_scale","1", "scale factor of the background"};

Referenced by CL_Screen_Init(), and SCR_DrawLoadingScreen().

◆ scr_loadingscreen_scale_base

cvar_t scr_loadingscreen_scale_base = {CF_CLIENT, "scr_loadingscreen_scale_base","0", "0 = console pixels, 1 = video pixels"}

Definition at line 45 of file cl_screen.c.

45{CF_CLIENT, "scr_loadingscreen_scale_base","0", "0 = console pixels, 1 = video pixels"};

Referenced by CL_Screen_Init(), and SCR_DrawLoadingScreen().

◆ scr_loadingscreen_scale_limit

cvar_t scr_loadingscreen_scale_limit = {CF_CLIENT, "scr_loadingscreen_scale_limit","0", "0 = no limit, 1 = until first edge hits screen edge, 2 = until last edge hits screen edge, 3 = until width hits screen width, 4 = until height hits screen height"}

Definition at line 46 of file cl_screen.c.

46{CF_CLIENT, "scr_loadingscreen_scale_limit","0", "0 = no limit, 1 = until first edge hits screen edge, 2 = until last edge hits screen edge, 3 = until width hits screen width, 4 = until height hits screen height"};

Referenced by CL_Screen_Init(), and SCR_DrawLoadingScreen().

◆ scr_numtouchscreenareas

int scr_numtouchscreenareas

Definition at line 1504 of file cl_screen.c.

Referenced by IN_Move(), SCR_DrawTouchscreenOverlay(), VID_TouchscreenArea(), and VID_TouchscreenCursor().

◆ scr_printspeed

cvar_t scr_printspeed = {CF_CLIENT, "scr_printspeed","0", "speed of intermission printing (episode end texts), a value of 0 disables the slow printing"}

Definition at line 42 of file cl_screen.c.

42{CF_CLIENT, "scr_printspeed","0", "speed of intermission printing (episode end texts), a value of 0 disables the slow printing"};

Referenced by CL_Screen_Init(), and SCR_DrawCenterString().

◆ scr_refresh

cvar_t scr_refresh = {CF_CLIENT, "scr_refresh", "1", "allows you to completely shut off rendering for benchmarking purposes"}

Definition at line 89 of file cl_screen.c.

89{CF_CLIENT, "scr_refresh", "1", "allows you to completely shut off rendering for benchmarking purposes"};

Referenced by CL_Screen_Init(), and CL_UpdateScreen().

◆ scr_sbarscale

cvar_t scr_sbarscale = {CF_CLIENT | CF_READONLY, "scr_sbarscale", "1", "current vid_height/vid_conheight, for compatibility with csprogs that read this cvar (found in Fitzquake-derived engines and FTEQW; despite the name it's not specific to the status bar)"}

Definition at line 54 of file cl_screen.c.

54{CF_CLIENT | CF_READONLY, "scr_sbarscale", "1", "current vid_height/vid_conheight, for compatibility with csprogs that read this cvar (found in Fitzquake-derived engines and FTEQW; despite the name it's not specific to the status bar)"};

CF_READONLY

#define CF_READONLY

cvar cannot be changed from the console or the command buffer, and is considered CF_PERSISTENT

Definition cmd.h:54

Referenced by CL_Screen_Init(), and SCR_UpdateVars().

◆ scr_screenshot_alpha

cvar_t scr_screenshot_alpha = {CF_CLIENT, "scr_screenshot_alpha","0", "try to write an alpha channel to screenshots (debugging feature)"}

Definition at line 63 of file cl_screen.c.

63{CF_CLIENT, "scr_screenshot_alpha","0", "try to write an alpha channel to screenshots (debugging feature)"};

Referenced by CL_Screen_Init(), R_ClearScreen(), and SCR_ScreenShot_f().

◆ scr_screenshot_gammaboost

cvar_t scr_screenshot_gammaboost = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_gammaboost","1", "gamma correction on saved screenshots and videos, 1.0 saves unmodified images"}

Definition at line 62 of file cl_screen.c.

62{CF_CLIENT | CF_ARCHIVE, "scr_screenshot_gammaboost","1", "gamma correction on saved screenshots and videos, 1.0 saves unmodified images"};

Referenced by CL_Screen_Init(), and SCR_ScreenShot().

◆ scr_screenshot_jpeg

cvar_t scr_screenshot_jpeg = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_jpeg","1", "save jpeg instead of targa or PNG"}

Definition at line 59 of file cl_screen.c.

59{CF_CLIENT | CF_ARCHIVE, "scr_screenshot_jpeg","1", "save jpeg instead of targa or PNG"};

Referenced by CL_Screen_Init(), r_textures_start(), and SCR_ScreenShot_f().

◆ scr_screenshot_jpeg_quality

cvar_t scr_screenshot_jpeg_quality = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_jpeg_quality","0.9", "image quality of saved jpeg"}

Definition at line 60 of file cl_screen.c.

60{CF_CLIENT | CF_ARCHIVE, "scr_screenshot_jpeg_quality","0.9", "image quality of saved jpeg"};

Referenced by CL_Screen_Init(), and JPEG_SaveImage_preflipped().

◆ scr_screenshot_name_in_mapdir

cvar_t scr_screenshot_name_in_mapdir = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_name_in_mapdir", "0", "if set to 1, screenshots are placed in a subdirectory named like the map they are from"}

Definition at line 90 of file cl_screen.c.

90{CF_CLIENT | CF_ARCHIVE, "scr_screenshot_name_in_mapdir", "0", "if set to 1, screenshots are placed in a subdirectory named like the map they are from"};

Referenced by CL_Screen_Init(), and SCR_ScreenShot_f().

◆ scr_screenshot_png

cvar_t scr_screenshot_png = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_png","0", "save png instead of targa"}

Definition at line 61 of file cl_screen.c.

61{CF_CLIENT | CF_ARCHIVE, "scr_screenshot_png","0", "save png instead of targa"};

Referenced by CL_Screen_Init(), r_textures_start(), and SCR_ScreenShot_f().

◆ scr_screenshot_timestamp

cvar_t scr_screenshot_timestamp = {CF_CLIENT | CF_ARCHIVE, "scr_screenshot_timestamp", "1", "use a timestamp based number of the type YYYYMMDDHHMMSSsss instead of sequential numbering"}

Definition at line 64 of file cl_screen.c.

64{CF_CLIENT | CF_ARCHIVE, "scr_screenshot_timestamp", "1", "use a timestamp based number of the type YYYYMMDDHHMMSSsss instead of sequential numbering"};

Referenced by CL_Screen_Init(), and SCR_ScreenShot_f().

◆ scr_showbrand

cvar_t scr_showbrand = {CF_CLIENT, "showbrand","0", "shows gfx/brand.tga in a corner of the screen (different values select different positions, including centered)"}

Definition at line 41 of file cl_screen.c.

41{CF_CLIENT, "showbrand","0", "shows gfx/brand.tga in a corner of the screen (different values select different positions, including centered)"};

Referenced by CL_Screen_Init(), and SCR_DrawBrand().

◆ scr_showpause

cvar_t scr_showpause = {CF_CLIENT | CF_ARCHIVE, "showpause","1", "show pause icon when game is paused"}

Definition at line 40 of file cl_screen.c.

40{CF_CLIENT | CF_ARCHIVE, "showpause","1", "show pause icon when game is paused"};

Referenced by CL_Screen_Init(), and SCR_DrawPause().

◆ scr_showram

cvar_t scr_showram = {CF_CLIENT | CF_ARCHIVE, "showram","1", "show ram icon if low on surface cache memory (not used)"}

Definition at line 38 of file cl_screen.c.

38{CF_CLIENT | CF_ARCHIVE, "showram","1", "show ram icon if low on surface cache memory (not used)"};

Referenced by CL_Screen_Init().

◆ scr_showturtle

cvar_t scr_showturtle = {CF_CLIENT | CF_ARCHIVE, "showturtle","0", "show turtle icon when framerate is too low"}

Definition at line 39 of file cl_screen.c.

39{CF_CLIENT | CF_ARCHIVE, "showturtle","0", "show turtle icon when framerate is too low"};

Referenced by CL_Screen_Init(), and SCR_DrawTurtle().

◆ scr_stipple

cvar_t scr_stipple = {CF_CLIENT, "scr_stipple", "0", "interlacing-like stippling of the display"}

Definition at line 88 of file cl_screen.c.

88{CF_CLIENT, "scr_stipple", "0", "interlacing-like stippling of the display"};

Referenced by CL_DrawVideo(), CL_Screen_Init(), and CL_UpdateScreen().

◆ scr_touchscreenareas

scr_touchscreenarea_t scr_touchscreenareas[128]

Definition at line 1505 of file cl_screen.c.

Referenced by SCR_DrawTouchscreenOverlay(), VID_TouchscreenArea(), and VID_TouchscreenCursor().

◆ scr_viewsize

cvar_t scr_viewsize = {CF_CLIENT | CF_ARCHIVE, "viewsize","100", "how large the view should be, 110 disables inventory bar, 120 disables status bar"}

Definition at line 19 of file cl_screen.c.

19{CF_CLIENT | CF_ARCHIVE, "viewsize","100", "how large the view should be, 110 disables inventory bar, 120 disables status bar"};

Referenced by CL_Screen_Init(), SCR_DrawScreen(), SCR_SizeDown_f(), SCR_SizeUp_f(), SCR_UpdateVars(), and V_CalcRefdefUsing().

◆ timedemo_screenshotframelist

cvar_t timedemo_screenshotframelist = {CF_CLIENT, "timedemo_screenshotframelist", "", "when performing a timedemo, take screenshots of each frame in this space-separated list - example: 1 201 401"}

Definition at line 93 of file cl_screen.c.

93{CF_CLIENT, "timedemo_screenshotframelist", "", "when performing a timedemo, take screenshots of each frame in this space-separated list - example: 1 201 401"};

Referenced by CL_Screen_Init(), and SCR_DrawScreen().

◆ v_isometric

cvar_t v_isometric

extern

Definition at line 97 of file view.c.

97{CF_CLIENT, "v_isometric", "0", "changes view to isometric (non-perspective)"};

◆ v_isometric_verticalfov

cvar_t v_isometric_verticalfov

extern

Definition at line 98 of file view.c.

98{CF_CLIENT, "v_isometric_verticalfov", "512", "vertical field of view in game units (horizontal is computed using aspect ratio based on this)"};

Referenced by V_Init(), and V_MakeViewIsometric().

◆ vid_conheight

cvar_t vid_conheight = {CF_CLIENT | CF_ARCHIVE, "vid_conheight", "480", "virtual height of 2D graphics system"}

Definition at line 57 of file cl_screen.c.

57{CF_CLIENT | CF_ARCHIVE, "vid_conheight", "480", "virtual height of 2D graphics system"};

Referenced by CL_DrawVideo(), CL_Input(), CL_Screen_Init(), CL_UpdateScreen(), CL_VM_DrawHud(), CL_VM_UpdateView(), Con_DrawConsole(), Con_DrawNotify(), DrawQ_Line(), DrawQ_SetClipArea(), DrawQ_Start(), DrawQ_String_Scale(), Font_IndexForSize(), Font_VirtualToRealSize(), IN_Move_TouchScreen_SteelStorm(), Key_Console(), M_Background(), M_Draw(), M_ModList_Draw(), M_Options_ColorControl_Draw(), M_Options_Draw(), M_Options_Effects_Draw(), M_Options_Graphics_Draw(), M_ServerList_Draw(), M_Video_Key(), R_DebugLine(), R_Model_Sprite_Draw_TransparentCallback(), R_TimeReport_EndFrame(), Sbar_DeathmatchOverlay(), Sbar_Draw(), Sbar_DrawFace(), Sbar_DrawWeapon(), Sbar_IntermissionOverlay(), Sbar_MiniDeathmatchOverlay(), Sbar_Score(), Sbar_ShowFPS(), SCR_DrawBrand(), SCR_DrawCenterString(), SCR_DrawConsole(), SCR_DrawCurlDownload(), SCR_DrawInfobarString(), SCR_DrawLoadingScreen(), SCR_DrawLoadingStack(), SCR_DrawNetGraph(), SCR_DrawPause(), SCR_DrawQWDownload(), SCR_SetLoadingScreenTexture(), SCR_SetUpToDrawConsole(), SCR_UpdateVars(), snap_to_pixel_y(), VID_TouchscreenArea(), VID_TouchscreenCursor(), VM_CL_getmousepos(), VM_CL_project(), VM_CL_unproject(), VM_drawsetcliparea(), and VM_M_getmousepos().

◆ vid_conwidth

cvar_t vid_conwidth = {CF_CLIENT | CF_ARCHIVE, "vid_conwidth", "640", "virtual width of 2D graphics system (note: changes may be overwritten, see vid_conwidthauto)"}

Definition at line 56 of file cl_screen.c.

56{CF_CLIENT | CF_ARCHIVE, "vid_conwidth", "640", "virtual width of 2D graphics system (note: changes may be overwritten, see vid_conwidthauto)"};

Referenced by CL_DrawVideo(), CL_Input(), CL_Screen_Init(), CL_UpdateScreen(), CL_VM_DrawHud(), CL_VM_UpdateView(), Con_CheckResize(), Con_DrawConsole(), Con_DrawConsoleLine(), Con_DrawInput(), Con_DrawNotify(), Con_LineHeight(), DrawQ_Line(), DrawQ_SetClipArea(), DrawQ_Start(), DrawQ_String_Scale(), Font_IndexForSize(), IN_Move_TouchScreen_SteelStorm(), M_Background(), M_Draw(), M_Options_ColorControl_Draw(), M_Video_Key(), R_DebugLine(), R_Model_Sprite_Draw_TransparentCallback(), R_Shadow_EditLights_DrawSelectedLightProperties(), R_TimeReport(), R_TimeReport_EndFrame(), Sbar_DeathmatchOverlay(), Sbar_Draw(), Sbar_DrawWeapon(), Sbar_FinaleOverlay(), Sbar_IntermissionOverlay(), Sbar_MiniDeathmatchOverlay(), Sbar_ShowFPS(), SCR_DrawBrand(), SCR_DrawCenterString(), SCR_DrawCurlDownload(), SCR_DrawInfobarString(), SCR_DrawLoadingScreen(), SCR_DrawLoadingStack(), SCR_DrawLoadingStack_r(), SCR_DrawNetGraph(), SCR_DrawPause(), SCR_DrawQWDownload(), SCR_SetLoadingScreenTexture(), SCR_UpdateVars(), snap_to_pixel_x(), VID_TouchscreenArea(), VID_TouchscreenCursor(), VM_CL_getmousepos(), VM_CL_project(), VM_CL_R_SetView(), VM_CL_unproject(), VM_drawsetcliparea(), and VM_M_getmousepos().

◆ vid_conwidthauto

cvar_t vid_conwidthauto = {CF_CLIENT | CF_ARCHIVE, "vid_conwidthauto", "1", "automatically update vid_conwidth to match aspect ratio"}

Definition at line 55 of file cl_screen.c.

55{CF_CLIENT | CF_ARCHIVE, "vid_conwidthauto", "1", "automatically update vid_conwidth to match aspect ratio"};

Referenced by CL_Screen_Init(), and SCR_UpdateVars().

◆ vid_pixelheight

cvar_t vid_pixelheight = {CF_CLIENT | CF_ARCHIVE, "vid_pixelheight", "1", "adjusts vertical field of vision to account for non-square pixels (1280x1024 on a CRT monitor for example)"}

Definition at line 58 of file cl_screen.c.

58{CF_CLIENT | CF_ARCHIVE, "vid_pixelheight", "1", "adjusts vertical field of vision to account for non-square pixels (1280x1024 on a CRT monitor for example)"};

Referenced by CL_Screen_Init(), M_Menu_Video_f(), M_Video_Key(), MR_Init(), SCR_CaptureVideo_Avi_BeginVideo(), SCR_CaptureVideo_Ogg_BeginVideo(), SCR_DrawScreen(), SCR_UpdateVars(), and V_MakeViewIsometric().

◆ vid_touchscreen_outlinealpha

cvar_t vid_touchscreen_outlinealpha = {CF_CLIENT, "vid_touchscreen_outlinealpha", "0", "opacity of touchscreen area outlines"}

Definition at line 94 of file cl_screen.c.

94{CF_CLIENT, "vid_touchscreen_outlinealpha", "0", "opacity of touchscreen area outlines"};

Referenced by CL_Screen_Init(), and SCR_DrawTouchscreenOverlay().

◆ vid_touchscreen_overlayalpha

cvar_t vid_touchscreen_overlayalpha = {CF_CLIENT, "vid_touchscreen_overlayalpha", "0.25", "opacity of touchscreen area icons"}

Definition at line 95 of file cl_screen.c.

95{CF_CLIENT, "vid_touchscreen_overlayalpha", "0.25", "opacity of touchscreen area icons"};

Referenced by CL_Screen_Init(), and SCR_DrawTouchscreenOverlay().

Data Structures

Functions

Variables

Function Documentation

◆ CL_Screen_Init()

◆ CL_Screen_NewMap()

◆ CL_Screen_Shutdown()

◆ CL_UpdateScreen()

◆ R_ClearScreen()

◆ R_Envmap_f()

◆ R_Stereo_Active()

◆ R_Stereo_ColorMasking()

◆ SCR_BeginLoadingPlaque()

◆ SCR_CenterPrint()

◆ SCR_Centerprint_f()

◆ SCR_CheckDrawCenterString()

◆ SCR_ChooseLoadingPic()

◆ SCR_ClearLoadingScreen()

◆ SCR_ClearLoadingScreenTexture()

◆ SCR_DeferLoadingPlaque()

◆ SCR_DrawBrand()

◆ SCR_DrawCenterString()

◆ SCR_DrawConsole()

◆ SCR_DrawCurlDownload()

◆ SCR_DrawInfobar()

◆ SCR_DrawInfobarString()

◆ SCR_DrawLoadingScreen()

◆ SCR_DrawLoadingStack()

◆ SCR_DrawLoadingStack_r()

◆ SCR_DrawNet()

◆ SCR_DrawNetGraph()

◆ SCR_DrawNetGraph_DrawGraph()

◆ SCR_DrawPause()

◆ SCR_DrawQWDownload()

◆ SCR_DrawScreen()

◆ SCR_DrawTouchscreenOverlay()

◆ SCR_DrawTurtle()

◆ SCR_EndLoadingPlaque()

◆ SCR_InfoBar_f()

◆ SCR_InfobarHeight()

◆ SCR_PopLoadingScreen()

◆ SCR_PushLoadingScreen()

◆ SCR_ScreenShot()

◆ SCR_ScreenShot_f()

◆ SCR_SetLoadingScreenTexture()

◆ SCR_SetUpToDrawConsole()

◆ SCR_SizeDown_f()

◆ SCR_SizeUp_f()

◆ SCR_UpdateVars()

◆ SHOWLMP_decodehide()

◆ SHOWLMP_decodeshow()

◆ SHOWLMP_drawall()

Variable Documentation

◆ cl_connect_status

◆ cl_demo_mousegrab

◆ cl_minfps

◆ cl_minfps_fade

◆ cl_minfps_force

◆ cl_minfps_qualityhysteresis

◆ cl_minfps_qualitymax

◆ cl_minfps_qualitymin

◆ cl_minfps_qualitymultiply

◆ cl_minfps_qualitystepmax

◆ cl_punchangle_applied

◆ con_vislines

◆ envmapinfo

◆ jpeg_supported

◆ loadingscreenpic_number

◆ loadingscreenstack

◆ loadingscreentexture

◆ loadingscreentexture_texcoord2f

◆ loadingscreentexture_vertex3f

◆ net_graph

◆ r_fog_clear

◆ r_letterbox

◆ r_main_texturepool

◆ r_stereo_angle

◆ r_stereo_horizontal

◆ r_stereo_redblue

◆ r_stereo_redcyan