#include "client.h"
#include "refresh/images.h"
#include "refresh/models.h"

Macros
#define	MODE_GEOMETRY 1

#define	MODE_FULLSCREEN 2

#define	MODE_MODELIST 4

Functions
qboolean	VID_GetFullscreen (vrect_t rc, int freq_p, int *depth_p)

qboolean	VID_GetGeometry (vrect_t *rc)

void	VID_SetGeometry (vrect_t *rc)

void	VID_ToggleFullscreen (void)

void	CL_RunRefresh (void)

static void	vid_geometry_changed (cvar_t *self)

static void	vid_fullscreen_changed (cvar_t *self)

static void	vid_modelist_changed (cvar_t *self)

void	CL_InitRefresh (void)

void	CL_ShutdownRefresh (void)

float	R_ClampScale (cvar_t *var)

Variables
cvar_t *	vid_rtx

cvar_t *	vid_geometry

cvar_t *	vid_modelist

cvar_t *	vid_fullscreen

cvar_t *	_vid_fullscreen

cvar_t *	vid_display

cvar_t *	vid_displaylist

static int	mode_changed

refcfg_t	r_config

qboolean(*	R_Init )(qboolean total) = NULL

void(*	R_Shutdown )(qboolean total) = NULL

void(*	R_BeginRegistration )(const char *map) = NULL

void(*	R_SetSky )(const char *name, float rotate, vec3_t axis) = NULL

void(*	R_EndRegistration )(void) = NULL

void(*	R_RenderFrame )(refdef_t *fd) = NULL

void(*	R_LightPoint )(vec3_t origin, vec3_t light) = NULL

void(*	R_ClearColor )(void) = NULL

void(*	R_SetAlpha )(float clpha) = NULL

void(*	R_SetAlphaScale )(float alpha) = NULL

void(*	R_SetColor )(uint32_t color) = NULL

void(*	R_SetClipRect )(const clipRect_t *clip) = NULL

void(*	R_SetScale )(float scale) = NULL

void(*	R_DrawChar )(int x, int y, int flags, int ch, qhandle_t font) = NULL

int(*	R_DrawString )(int x, int y, int flags, size_t maxChars, const char *string, qhandle_t font) = NULL

void(*	R_DrawPic )(int x, int y, qhandle_t pic) = NULL

void(*	R_DrawStretchPic )(int x, int y, int w, int h, qhandle_t pic) = NULL

void(*	R_TileClear )(int x, int y, int w, int h, qhandle_t pic) = NULL

void(*	R_DrawFill8 )(int x, int y, int w, int h, int c) = NULL

void(*	R_DrawFill32 )(int x, int y, int w, int h, uint32_t color) = NULL

void(*	R_BeginFrame )(void) = NULL

void(*	R_EndFrame )(void) = NULL

void(*	R_ModeChanged )(int width, int height, int flags, int rowbytes, void *pixels) = NULL

void(*	R_AddDecal )(decal_t *d) = NULL

qboolean(*	R_InterceptKey )(unsigned key, qboolean down) = NULL

void(*	IMG_Unload )(image_t *image) = NULL

void(*	IMG_Load )(image_t image, byte pic) = NULL

byte (	IMG_ReadPixels )(int width, int height, int *rowbytes) = NULL

qerror_t(*	MOD_LoadMD2 )(model_t model, const void rawdata, size_t length) = NULL

void(*	MOD_Reference )(model_t *model) = NULL

Macro Definition Documentation

◆ MODE_FULLSCREEN

#define MODE_FULLSCREEN 2

Definition at line 39 of file refresh.c.

◆ MODE_GEOMETRY

#define MODE_GEOMETRY 1

Definition at line 38 of file refresh.c.

◆ MODE_MODELIST

#define MODE_MODELIST 4

Definition at line 40 of file refresh.c.

Function Documentation

◆ CL_InitRefresh()

void CL_InitRefresh ( void )

Definition at line 289 of file refresh.c.

 {
     char *modelist;
  
     if (cls.ref_initialized) {
         return;
     }
  
     vid_display = Cvar_Get("vid_display", "0", CVAR_ARCHIVE | CVAR_REFRESH);
     vid_displaylist = Cvar_Get("vid_displaylist", "\"<unknown>\" 0", CVAR_ROM);
  
     Com_SetLastError(NULL);
  
     modelist = VID_GetDefaultModeList();
     if (!modelist) {
         Com_Error(ERR_FATAL, "Couldn't initialize refresh: %s", Com_GetLastError());
     }
  
     // Create the video variables so we know how to start the graphics drivers
  
     vid_rtx = Cvar_Get("vid_rtx", 
 #if REF_VKPT
         "1",
 #else
         "0",
 #endif
         CVAR_REFRESH | CVAR_ARCHIVE);
  
     vid_fullscreen = Cvar_Get("vid_fullscreen", "0", CVAR_ARCHIVE);
     _vid_fullscreen = Cvar_Get("_vid_fullscreen", "1", CVAR_ARCHIVE);
     vid_modelist = Cvar_Get("vid_modelist", modelist, 0);
     vid_geometry = Cvar_Get("vid_geometry", VID_GEOMETRY, CVAR_ARCHIVE);
  
     Z_Free(modelist);
  
     if (vid_fullscreen->integer) {
         Cvar_Set("_vid_fullscreen", vid_fullscreen->string);
     } else if (!_vid_fullscreen->integer) {
         Cvar_Set("_vid_fullscreen", "1");
     }
  
     Com_SetLastError(NULL);
  
 #if REF_GL && REF_VKPT
     if (vid_rtx->integer)
         R_RegisterFunctionsRTX();
     else
         R_RegisterFunctionsGL();
 #elif REF_GL
     R_RegisterFunctionsGL();
 #elif REF_VKPT
     R_RegisterFunctionsRTX();
 #else
 #error "REF_GL and REF_VKPT are both disabled, at least one has to be enableds"
 #endif
  
     if (!R_Init(qtrue)) {
         Com_Error(ERR_FATAL, "Couldn't initialize refresh: %s", Com_GetLastError());
     }
  
     cls.ref_initialized = qtrue;
  
     vid_geometry->changed = vid_geometry_changed;
     vid_fullscreen->changed = vid_fullscreen_changed;
     vid_modelist->changed = vid_modelist_changed;
  
     mode_changed = 0;
  
     FX_Init();
  
     // Initialize the rest of graphics subsystems
     V_Init();
     SCR_Init();
     UI_Init();
  
     SCR_RegisterMedia();
     Con_RegisterMedia();
  
     cvar_modified &= ~(CVAR_FILES | CVAR_REFRESH);
 }

Referenced by CL_Init(), and CL_RestartRefresh().

◆ CL_RunRefresh()

void CL_RunRefresh ( void )

Definition at line 232 of file refresh.c.

 {
     if (!cls.ref_initialized) {
         return;
     }
  
     VID_PumpEvents();
  
     if (mode_changed) {
         if (mode_changed & MODE_FULLSCREEN) {
             VID_SetMode();
             if (vid_fullscreen->integer) {
                 Cvar_Set("_vid_fullscreen", vid_fullscreen->string);
             }
         } else {
             if (vid_fullscreen->integer) {
                 if (mode_changed & MODE_MODELIST) {
                     VID_SetMode();
                 }
             } else {
                 if (mode_changed & MODE_GEOMETRY) {
                     VID_SetMode();
                 }
             }
         }
         mode_changed = 0;
     }
  
     if (cvar_modified & CVAR_REFRESH) {
         CL_RestartRefresh(qtrue);
         cvar_modified &= ~CVAR_REFRESH;
     } else if (cvar_modified & CVAR_FILES) {
         CL_RestartRefresh(qfalse);
         cvar_modified &= ~CVAR_FILES;
     }
 }

Referenced by CL_ProcessEvents().

◆ CL_ShutdownRefresh()

void CL_ShutdownRefresh ( void )

Definition at line 375 of file refresh.c.

 {
     if (!cls.ref_initialized) {
         return;
     }
  
     // Shutdown the rest of graphics subsystems
     V_Shutdown();
     SCR_Shutdown();
     UI_Shutdown();
  
     vid_geometry->changed = NULL;
     vid_fullscreen->changed = NULL;
     vid_modelist->changed = NULL;
  
     R_Shutdown(qtrue);
  
     cls.ref_initialized = qfalse;
  
     // no longer active
     cls.active = ACT_MINIMIZED;
  
     Z_LeakTest(TAG_RENDERER);
 }

Referenced by CL_RestartRefresh(), and CL_Shutdown().

◆ R_ClampScale()

float R_ClampScale ( cvar_t * var )

Definition at line 440 of file refresh.c.

 {
     if (!var)
         return 1.0f;
  
     if (var->value)
         return 1.0f / Cvar_ClampValue(var, 1.0f, 10.0f);
  
     if (r_config.width * r_config.height >= 2560 * 1440)
         return 0.25f;
  
     if (r_config.width * r_config.height >= 1280 * 720)
         return 0.5f;
  
     return 1.0f;
 }

Referenced by Con_CheckResize(), SCR_ModeChanged(), scr_scale_changed(), and UI_Resize().

◆ vid_fullscreen_changed()

static void vid_fullscreen_changed ( cvar_t * self )

static

Definition at line 274 of file refresh.c.

 {
     mode_changed |= MODE_FULLSCREEN;
 }

Referenced by CL_InitRefresh().

◆ vid_geometry_changed()

static void vid_geometry_changed ( cvar_t * self )

static

Definition at line 269 of file refresh.c.

 {
     mode_changed |= MODE_GEOMETRY;
 }

Referenced by CL_InitRefresh().

◆ VID_GetFullscreen()

qboolean VID_GetFullscreen	(	vrect_t *	rc,
		int *	freq_p,
		int *	depth_p
	)

Definition at line 56 of file refresh.c.

 {
     unsigned long w, h, freq, depth;
     char *s;
     int mode;
  
     // fill in default parameters
     rc->x = 0;
     rc->y = 0;
     rc->width = 640;
     rc->height = 480;
  
     if (freq_p)
         *freq_p = 0;
     if (depth_p)
         *depth_p = 0;
  
     if (!vid_modelist || !vid_fullscreen)
         return qfalse;
  
     s = vid_modelist->string;
     while (Q_isspace(*s))
         s++;
     if (!*s)
         return qfalse;
  
     mode = 1;
     while (1) {
         if (!strncmp(s, "desktop", 7)) {
             s += 7;
             if (*s && !Q_isspace(*s)) {
                 Com_DPrintf("Mode %d is malformed\n", mode);
                 return qfalse;
             }
             w = h = freq = depth = 0;
         } else {
             w = strtoul(s, &s, 10);
             if (*s != 'x' && *s != 'X') {
                 Com_DPrintf("Mode %d is malformed\n", mode);
                 return qfalse;
             }
             h = strtoul(s + 1, &s, 10);
             freq = depth = 0;
             if (*s == '@') {
                 freq = strtoul(s + 1, &s, 10);
                 if (*s == ':') {
                     depth = strtoul(s + 1, &s, 10);
                 }
             } else if (*s == ':') {
                 depth = strtoul(s + 1, &s, 10);
                 if (*s == '@') {
                     freq = strtoul(s + 1, &s, 10);
                 }
             }
         }
         if (mode == vid_fullscreen->integer) {
             break;
         }
         while (Q_isspace(*s))
             s++;
         if (!*s) {
             Com_DPrintf("Mode %d not found\n", vid_fullscreen->integer);
             return qfalse;
         }
         mode++;
     }
  
     // sanity check
     if (w < 64 || w > 8192 || h < 64 || h > 8192 || freq > 1000 || depth > 32) {
         Com_DPrintf("Mode %lux%lu@%lu:%lu doesn't look sane\n", w, h, freq, depth);
         return qfalse;
     }
  
     rc->width = w;
     rc->height = h;
  
     if (freq_p)
         *freq_p = freq;
     if (depth_p)
         *depth_p = depth;
  
     return qtrue;
 }

Referenced by set_fullscreen_mode().

◆ VID_GetGeometry()

qboolean VID_GetGeometry ( vrect_t * rc )

Definition at line 144 of file refresh.c.

 {
     unsigned long w, h;
     long x, y;
     char *s;
  
     // fill in default parameters
     rc->x = 100;
     rc->y = 100;
     rc->width = 1280;
     rc->height = 720;
  
     if (!vid_geometry)
         return qfalse;
  
     s = vid_geometry->string;
     if (!*s)
         return qfalse;
  
     w = strtoul(s, &s, 10);
     if (*s != 'x' && *s != 'X') {
         Com_DPrintf("Geometry string is malformed\n");
         return qfalse;
     }
     h = strtoul(s + 1, &s, 10);
     x = rc->x;
     y = rc->y;
     if (*s == '+' || *s == '-') {
         x = strtol(s, &s, 10);
         if (*s == '+' || *s == '-') {
             y = strtol(s, &s, 10);
         }
     }
  
     // sanity check
     if (w < 64 || w > 8192 || h < 64 || h > 8192) {
         Com_DPrintf("Geometry %lux%lu doesn't look sane\n", w, h);
         return qfalse;
     }
  
     rc->x = x;
     rc->y = y;
     rc->width = w;
     rc->height = h;
  
     return qtrue;
 }

Referenced by Win_SetMode().

◆ vid_modelist_changed()

static void vid_modelist_changed ( cvar_t * self )

static

Definition at line 279 of file refresh.c.

 {
     mode_changed |= MODE_MODELIST;
 }

Referenced by CL_InitRefresh().

◆ VID_SetGeometry()

void VID_SetGeometry ( vrect_t * rc )

Definition at line 192 of file refresh.c.

 {
     char buffer[MAX_QPATH];
  
     if (!vid_geometry)
         return;
  
     Q_snprintf(buffer, sizeof(buffer), "%dx%d%+d%+d",
                rc->width, rc->height, rc->x, rc->y);
     Cvar_SetByVar(vid_geometry, buffer, FROM_CODE);
 }

Referenced by VID_PumpEvents(), and Win_SetMode().

◆ VID_ToggleFullscreen()

void VID_ToggleFullscreen ( void )

Definition at line 204 of file refresh.c.

 {
     if (!vid_fullscreen || !_vid_fullscreen)
         return;
  
     if (!vid_fullscreen->integer) {
         if (!_vid_fullscreen->integer) {
             Cvar_Set("_vid_fullscreen", "1");
         }
         Cbuf_AddText(&cmd_buffer, "set vid_fullscreen $_vid_fullscreen\n");
     } else {
         Cbuf_AddText(&cmd_buffer, "set vid_fullscreen 0\n");
     }
 }