nzp-team/fteqw
0
0
Fork 0
mirror of https://github.com/nzp-team/fteqw.git synced 2024-11-30 15:41:49 +00:00
Code Issues Projects Releases Packages Wiki Activity
fteqw/engine/client/r_2d.c

1371 lines
31 KiB
C
Raw Blame History

#include "quakedef.h"
#ifndef SERVERONLY
#include "shader.h"
#include "gl_draw.h"
qboolean r2d_canhwgamma; //says the video code has successfully activated hardware gamma
texid_t missing_texture;
texid_t missing_texture_gloss;
texid_t missing_texture_normal;
texid_t translate_texture;
shader_t *translate_shader;
texid_t ch_int_texture;
vec3_t ch_color;
shader_t *shader_crosshair;
static mpic_t *conback;
static mpic_t *draw_backtile;
static shader_t *shader_draw_fill, *shader_draw_fill_trans;
mpic_t *draw_disc;
shader_t *shader_contrastup;
shader_t *shader_contrastdown;
shader_t *shader_brightness;
shader_t *shader_gammacb;
shader_t *shader_polyblend;
shader_t *shader_menutint;
static mesh_t draw_mesh;
static vecV_t draw_mesh_xyz[4];
vec2_t draw_mesh_st[4];
static avec4_t draw_mesh_colors[4];
index_t r_quad_indexes[6] = {0, 1, 2, 2, 3, 0};
unsigned int r2d_be_flags;
static struct
{
texid_t id;
int width;
int height;
uploadfmt_t fmt;
} *rendertargets;
static unsigned int numrendertargets;
extern cvar_t scr_conalpha;
extern cvar_t gl_conback;
extern cvar_t gl_font;
extern cvar_t gl_screenangle;
extern cvar_t vid_conautoscale;
extern cvar_t vid_conheight;
extern cvar_t vid_conwidth;
extern cvar_t con_textsize;
void R2D_Font_Callback(struct cvar_s *var, char *oldvalue);
void R2D_Conautoscale_Callback(struct cvar_s *var, char *oldvalue);
void R2D_ScreenAngle_Callback(struct cvar_s *var, char *oldvalue);
void R2D_Conheight_Callback(struct cvar_s *var, char *oldvalue);
void R2D_Conwidth_Callback(struct cvar_s *var, char *oldvalue);
extern cvar_t crosshair;
extern cvar_t crosshaircolor;
extern cvar_t crosshairsize;
extern cvar_t crosshairimage;
extern cvar_t crosshairalpha;
void R2D_Crosshair_Callback(struct cvar_s *var, char *oldvalue);
void R2D_CrosshairImage_Callback(struct cvar_s *var, char *oldvalue);
void R2D_CrosshairColor_Callback(struct cvar_s *var, char *oldvalue);
//We need this for minor things though, so we'll just use the slow accurate method.
//this is unlikly to be called too often.
qbyte GetPaletteIndex(int red, int green, int blue)
{
//slow, horrible method.
{
int i, best=15;
int bestdif=256*256*256, curdif;
extern qbyte *host_basepal;
qbyte *pa;
#define _abs(x) ((x)*(x))
pa = host_basepal;
for (i = 0; i < 256; i++, pa+=3)
{
curdif = _abs(red - pa[0]) + _abs(green - pa[1]) + _abs(blue - pa[2]);
if (curdif < bestdif)
{
if (curdif<1)
return i;
bestdif = curdif;
best = i;
}
}
return best;
}
}
void R2D_Shutdown(void)
{
Cvar_Unhook(&gl_font);
Cvar_Unhook(&vid_conautoscale);
Cvar_Unhook(&gl_screenangle);
Cvar_Unhook(&vid_conheight);
Cvar_Unhook(&vid_conwidth);
Cvar_Unhook(&crosshair);
Cvar_Unhook(&crosshairimage);
Cvar_Unhook(&crosshaircolor);
BZ_Free(cl_stris);
cl_stris = NULL;
BZ_Free(cl_strisvertv);
cl_strisvertv = NULL;
BZ_Free(cl_strisvertc);
cl_strisvertc = NULL;
BZ_Free(cl_strisvertt);
cl_strisvertt = NULL;
BZ_Free(cl_strisidx);
cl_strisidx = NULL;
cl_numstrisidx = 0;
cl_maxstrisidx = 0;
cl_numstrisvert = 0;
cl_maxstrisvert = 0;
cl_numstris = 0;
cl_maxstris = 0;
while (numrendertargets>0)
R_DestroyTexture(rendertargets[--numrendertargets].id);
free(rendertargets);
rendertargets = NULL;
if (font_console == font_default)
font_console = NULL;
if (font_console)
Font_Free(font_console);
font_console = NULL;
if (font_default)
Font_Free(font_default);
font_default = NULL;
if (font_tiny)
Font_Free(font_tiny);
font_tiny = NULL;
}
/*
Iniitalise the 2d rendering functions (including font).
Image loading code must be ready for use at this point.
*/
void R2D_Init(void)
{
unsigned int nonorm[4*4];
unsigned int nogloss[4*4];
int i;
unsigned int glossval;
unsigned int normval;
extern cvar_t gl_specular_fallback;
conback = NULL;
Shader_Init();
BE_Init();
draw_mesh.istrifan = true;
draw_mesh.numvertexes = 4;
draw_mesh.numindexes = 6;
draw_mesh.xyz_array = draw_mesh_xyz;
draw_mesh.st_array = draw_mesh_st;
draw_mesh.colors4f_array[0] = draw_mesh_colors;
draw_mesh.indexes = r_quad_indexes;
Font_Init();
#ifdef warningmsg
#pragma warningmsg("Fixme: move conwidth handling into here")
#endif
glossval = min(gl_specular_fallback.value*255, 255);
glossval *= 0x10101;
glossval |= 0xff000000;
glossval = LittleLong(glossval);
normval = 0xffff8080;
normval = LittleLong(normval);
for (i = 0; i < 4*4; i++)
{
nogloss[i] = glossval;
nonorm[i] = normval;
}
missing_texture = R_LoadHiResTexture("no_texture", NULL, IF_NEAREST);
if (!TEXVALID(missing_texture))
missing_texture = R_LoadTexture8("no_texture", 16, 16, (unsigned char*)r_notexture_mip + r_notexture_mip->offsets[0], IF_NOALPHA|IF_NOGAMMA, 0);
missing_texture_gloss = R_LoadTexture("no_texture_gloss", 4, 4, TF_RGBA32, (unsigned char*)nogloss, IF_NOGAMMA);
missing_texture_normal = R_LoadTexture("no_texture_normal", 4, 4, TF_RGBA32, (unsigned char*)nonorm, IF_NOGAMMA);
translate_texture = r_nulltex;
ch_int_texture = r_nulltex;
draw_backtile = R_RegisterShader("gfx/backtile.lmp", SUF_NONE,
"{\n"
"if $nofixed\n"
"program default2d\n"
"endif\n"
"nomipmaps\n"
"{\n"
"map $diffuse\n"
"}\n"
"}\n");
if (!TEXVALID(draw_backtile->defaulttextures.base))
draw_backtile->defaulttextures.base = R_LoadHiResTexture("gfx/backtile", NULL, IF_UIPIC|IF_NOPICMIP|IF_NOMIPMAP);
if (!TEXVALID(draw_backtile->defaulttextures.base))
draw_backtile->defaulttextures.base = R_LoadHiResTexture("gfx/menu/backtile", NULL, IF_UIPIC|IF_NOPICMIP|IF_NOMIPMAP);
shader_draw_fill = R_RegisterShader("fill_opaque", SUF_NONE,
"{\n"
"program defaultfill\n"
"{\n"
"map $whiteimage\n"
"rgbgen exactvertex\n"
"alphagen vertex\n"
"}\n"
"}\n");
shader_draw_fill_trans = R_RegisterShader("fill_trans", SUF_NONE,
"{\n"
"program defaultfill\n"
"{\n"
"map $whiteimage\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"blendfunc blend\n"
"}\n"
"}\n");
shader_contrastup = R_RegisterShader("constrastupshader", SUF_NONE,
"{\n"
"program defaultfill\n"
"{\n"
"nodepthtest\n"
"map $whiteimage\n"
"blendfunc gl_dst_color gl_one\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"}\n"
"}\n"
);
shader_contrastdown = R_RegisterShader("constrastdownshader", SUF_NONE,
"{\n"
"program defaultfill\n"
"{\n"
"nodepthtest\n"
"map $whiteimage\n"
"blendfunc gl_dst_color gl_zero\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"}\n"
"}\n"
);
shader_brightness = R_RegisterShader("brightnessshader", SUF_NONE,
"{\n"
"program defaultfill\n"
"{\n"
"nodepthtest\n"
"map $whiteimage\n"
"blendfunc gl_one gl_one\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"}\n"
"}\n"
);
shader_gammacb = R_RegisterShader("gammacbshader", SUF_NONE,
"{\n"
"program defaultgammacb\n"
"cull back\n"
"{\n"
"map $currentrender\n"
"nodepthtest\n"
"}\n"
"}\n"
);
shader_polyblend = R_RegisterShader("polyblendshader", SUF_NONE,
"{\n"
"program defaultfill\n"
"{\n"
"map $whiteimage\n"
"blendfunc gl_src_alpha gl_one_minus_src_alpha\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"}\n"
"}\n"
);
shader_menutint = R_RegisterShader("menutint", SUF_NONE,
"{\n"
"if $glsl && gl_menutint_shader != 0\n"
"program menutint\n"
"{\n"
"map $currentrender\n"
"}\n"
"else\n"
"{\n"
"map $whiteimage\n"
"blendfunc gl_dst_color gl_zero\n"
"rgbgen const $r_menutint\n"
"}\n"
"endif\n"
"}\n"
);
shader_crosshair = R_RegisterShader("crosshairshader", SUF_NONE,
"{\n"
"if $nofixed\n"
"program default2d\n"
"endif\n"
"nomipmaps\n"
"{\n"
"map $diffuse\n"
"blendfunc blend\n"
"rgbgen vertex\n"
"alphagen vertex\n"
"}\n"
"}\n"
);
Cvar_Hook(&gl_font, R2D_Font_Callback);
Cvar_Hook(&vid_conautoscale, R2D_Conautoscale_Callback);
Cvar_Hook(&gl_screenangle, R2D_ScreenAngle_Callback);
Cvar_Hook(&vid_conheight, R2D_Conheight_Callback);
Cvar_Hook(&vid_conwidth, R2D_Conwidth_Callback);
Cvar_Hook(&crosshair, R2D_Crosshair_Callback);
Cvar_Hook(&crosshairimage, R2D_CrosshairImage_Callback);
Cvar_Hook(&crosshaircolor, R2D_CrosshairColor_Callback);
Cvar_ForceCallback(&gl_conback);
Cvar_ForceCallback(&vid_conautoscale);
Cvar_ForceCallback(&gl_font);
Cvar_ForceCallback(&crosshair);
Cvar_ForceCallback(&crosshaircolor);
#ifdef PLUGINS
Plug_DrawReloadImages();
#endif
R2D_Font_Changed();
}
mpic_t *R2D_SafeCachePic (char *path)
{
shader_t *s;
if (!qrenderer)
return NULL;
s = R_RegisterPic(path);
if (s->flags & SHADER_NOIMAGE)
return NULL;
return s;
}
mpic_t *R2D_SafePicFromWad (char *name)
{
char newnamewad[32];
char newnamegfx[32];
shader_t *s;
snprintf(newnamewad, sizeof(newnamewad), "wad/%s", name);
snprintf(newnamegfx, sizeof(newnamegfx), "gfx/%s", name);
s = R_RegisterPic(newnamewad);
if (!(s->flags & SHADER_NOIMAGE))
return s;
s = R_RegisterPic(newnamegfx);
if (!(s->flags & SHADER_NOIMAGE))
return s;
return NULL;
}
void R2D_ImageColours(float r, float g, float b, float a)
{
draw_mesh_colors[0][0] = r;
draw_mesh_colors[0][1] = g;
draw_mesh_colors[0][2] = b;
draw_mesh_colors[0][3] = a;
Vector4Copy(draw_mesh_colors[0], draw_mesh_colors[1]);
Vector4Copy(draw_mesh_colors[0], draw_mesh_colors[2]);
Vector4Copy(draw_mesh_colors[0], draw_mesh_colors[3]);
}
void R2D_ImagePaletteColour(unsigned int i, float a)
{
draw_mesh_colors[0][0] = host_basepal[i*3+0]/255.0;
draw_mesh_colors[0][1] = host_basepal[i*3+1]/255.0;
draw_mesh_colors[0][2] = host_basepal[i*3+2]/255.0;
draw_mesh_colors[0][3] = a;
Vector4Copy(draw_mesh_colors[0], draw_mesh_colors[1]);
Vector4Copy(draw_mesh_colors[0], draw_mesh_colors[2]);
Vector4Copy(draw_mesh_colors[0], draw_mesh_colors[3]);
}
//awkward and weird to use
void R2D_Image(float x, float y, float w, float h, float s1, float t1, float s2, float t2, mpic_t *pic)
{
if (!pic)
return;
draw_mesh_xyz[0][0] = x;
draw_mesh_xyz[0][1] = y;
draw_mesh_st[0][0] = s1;
draw_mesh_st[0][1] = t1;
draw_mesh_xyz[1][0] = x+w;
draw_mesh_xyz[1][1] = y;
draw_mesh_st[1][0] = s2;
draw_mesh_st[1][1] = t1;
draw_mesh_xyz[2][0] = x+w;
draw_mesh_xyz[2][1] = y+h;
draw_mesh_st[2][0] = s2;
draw_mesh_st[2][1] = t2;
draw_mesh_xyz[3][0] = x;
draw_mesh_xyz[3][1] = y+h;
draw_mesh_st[3][0] = s1;
draw_mesh_st[3][1] = t2;
BE_DrawMesh_Single(pic, &draw_mesh, NULL, &pic->defaulttextures, r2d_be_flags);
}
/*draws a block of the current colour on the screen*/
void R2D_FillBlock(float x, float y, float w, float h)
{
draw_mesh_xyz[0][0] = x;
draw_mesh_xyz[0][1] = y;
draw_mesh_xyz[1][0] = x+w;
draw_mesh_xyz[1][1] = y;
draw_mesh_xyz[2][0] = x+w;
draw_mesh_xyz[2][1] = y+h;
draw_mesh_xyz[3][0] = x;
draw_mesh_xyz[3][1] = y+h;
if (draw_mesh_colors[0][3] != 1)
BE_DrawMesh_Single(shader_draw_fill_trans, &draw_mesh, NULL, &shader_draw_fill_trans->defaulttextures, r2d_be_flags);
else
BE_DrawMesh_Single(shader_draw_fill, &draw_mesh, NULL, &shader_draw_fill->defaulttextures, r2d_be_flags);
}
void R2D_ScalePic (float x, float y, float width, float height, mpic_t *pic)
{
R2D_Image(x, y, width, height, 0, 0, 1, 1, pic);
}
void R2D_SubPic(float x, float y, float width, float height, mpic_t *pic, float srcx, float srcy, float srcwidth, float srcheight)
{
float newsl, newtl, newsh, newth;
newsl = (srcx)/(float)srcwidth;
newsh = newsl + (width)/(float)srcwidth;
newtl = (srcy)/(float)srcheight;
newth = newtl + (height)/(float)srcheight;
R2D_Image(x, y, width, height, newsl, newtl, newsh, newth, pic);
}
/* this is an ugly special case drawing func that's only used for the player color selection menu */
void R2D_TransPicTranslate (float x, float y, int width, int height, qbyte *pic, qbyte *translation)
{
int v, u;
unsigned trans[64*64], *dest;
qbyte *src;
int p;
dest = trans;
for (v=0 ; v<64 ; v++, dest += 64)
{
src = &pic[ ((v*height)>>6) *width];
for (u=0 ; u<64 ; u++)
{
p = src[(u*width)>>6];
if (p == 255)
dest[u] = 0x0;
else
dest[u] = d_8to24rgbtable[translation[p]];
}
}
if (!TEXVALID(translate_texture))
{
translate_texture = R_AllocNewTexture("***translatedpic***", 64, 64, 0);
translate_shader = R_RegisterShader("translatedpic", SUF_2D,
"{\n"
"if $nofixed\n"
"program default2d\n"
"endif\n"
"nomipmaps\n"
"{\n"
"map $diffuse\n"
"blendfunc blend\n"
"}\n"
"}\n");
translate_shader->defaulttextures.base = translate_texture;
}
/* could avoid reuploading already translated textures but this func really isn't used enough anyway */
R_Upload(translate_texture, NULL, TF_RGBA32, trans, NULL, 64, 64, IF_UIPIC|IF_NOMIPMAP|IF_NOGAMMA);
R2D_ScalePic(x, y, width, height, translate_shader);
}
/*
================
Draw_ConsoleBackground
================
*/
void R2D_ConsoleBackground (int firstline, int lastline, qboolean forceopaque)
{
float a;
int w, h;
w = vid.width;
h = vid.height;
if (forceopaque)
{
a = 1; // console background is necessary
}
else
{
if (!scr_conalpha.value)
return;
a = scr_conalpha.value;
}
if (scr_chatmode == 2)
{
h>>=1;
w>>=1;
}
if (!conback)
{
R2D_ImageColours(0, 0, 0, a);
R2D_FillBlock(0, lastline-(int)vid.height, w, h);
R2D_ImageColours(1, 1, 1, 1);
}
else if (a >= 1)
{
R2D_ImageColours(1, 1, 1, 1);
R2D_ScalePic(0, lastline-(int)vid.height, w, h, conback);
}
else
{
R2D_ImageColours(1, 1, 1, a);
R2D_ScalePic (0, lastline - (int)vid.height, w, h, conback);
R2D_ImageColours(1, 1, 1, 1);
}
}
void R2D_EditorBackground (void)
{
R2D_ImageColours(0, 0, 0, 1);
R2D_FillBlock(0, 0, vid.width, vid.height);
// R2D_ScalePic(0, 0, vid.width, vid.height, conback);
}
/*
=============
Draw_TileClear
This repeats a 64*64 tile graphic to fill the screen around a sized down
refresh window.
=============
*/
void R2D_TileClear (float x, float y, float w, float h)
{
float newsl, newsh, newtl, newth;
newsl = (x)/(float)64;
newsh = newsl + (w)/(float)64;
newtl = (y)/(float)64;
newth = newtl + (h)/(float)64;
R2D_ImageColours(1,1,1,1);
draw_mesh_xyz[0][0] = x;
draw_mesh_xyz[0][1] = y;
draw_mesh_st[0][0] = newsl;
draw_mesh_st[0][1] = newtl;
draw_mesh_xyz[1][0] = x+w;
draw_mesh_xyz[1][1] = y;
draw_mesh_st[1][0] = newsh;
draw_mesh_st[1][1] = newtl;
draw_mesh_xyz[2][0] = x+w;
draw_mesh_xyz[2][1] = y+h;
draw_mesh_st[2][0] = newsh;
draw_mesh_st[2][1] = newth;
draw_mesh_xyz[3][0] = x;
draw_mesh_xyz[3][1] = y+h;
draw_mesh_st[3][0] = newsl;
draw_mesh_st[3][1] = newth;
BE_DrawMesh_Single(draw_backtile, &draw_mesh, NULL, &draw_backtile->defaulttextures, r2d_be_flags);
}
void R2D_Conback_Callback(struct cvar_s *var, char *oldvalue)
{
if (qrenderer == QR_NONE || !strcmp(var->string, "none"))
{
conback = NULL;
return;
}
if (*var->string)
conback = R_RegisterPic(var->string);
if (!conback || conback->flags & SHADER_NOIMAGE)
{
conback = R_RegisterCustom("console", SUF_2D, NULL, NULL);
if (!conback || conback->flags & SHADER_NOIMAGE)
{
if (M_GameType() == MGT_HEXEN2)
conback = R_RegisterPic("gfx/menu/conback.lmp");
else if (M_GameType() == MGT_QUAKE2)
conback = R_RegisterPic("pics/conback.pcx");
else
conback = R_RegisterPic("gfx/conback.lmp");
}
}
}
#if defined(_WIN32) && !defined(FTE_SDL)
#include <windows.h>
qboolean R2D_Font_WasAdded(char *buffer, char *fontfilename)
{
char *match;
if (!fontfilename)
return true;
match = strstr(buffer, fontfilename);
if (!match)
return false;
if (!(match == buffer || match[-1] == ','))
return false;
match += strlen(fontfilename);
if (*match && *match != ',')
return false;
return true;
}
extern qboolean WinNT;
qboolean MyRegGetStringValue(HKEY base, char *keyname, char *valuename, void *data, int datalen);
qboolean MyRegGetStringValueMultiSz(HKEY base, char *keyname, char *valuename, void *data, int datalen);
void R2D_Font_AddFontLink(char *buffer, int buffersize, char *fontname)
{
char link[1024];
char *res, *comma, *othercomma, *nl;
if (fontname)
if (MyRegGetStringValueMultiSz(HKEY_LOCAL_MACHINE, WinNT?"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\FontLink\\SystemLink":"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\FontLink\\SystemLink", fontname, link, sizeof(link)))
{
res = nl = link;
while (*nl)
{
nl += strlen(nl);
nl++;
comma = strchr(res, ',');
if (comma)
{
*comma++ = 0;
othercomma = strchr(comma, ',');
if (othercomma)
*othercomma = 0;
}
else
comma = "";
if (!R2D_Font_WasAdded(buffer, res))
{
Q_strncatz(buffer, ",", buffersize);
Q_strncatz(buffer, res, buffersize);
R2D_Font_AddFontLink(buffer, buffersize, comma);
}
res = nl;
}
}
}
#endif
void R2D_Font_Changed(void)
{
if (!con_textsize.modified)
return;
con_textsize.modified = false;
if (font_console == font_default)
font_console = NULL;
if (font_console)
Font_Free(font_console);
font_console = NULL;
if (font_default)
Font_Free(font_default);
font_default = NULL;
#if defined(MENU_DAT) || defined(CSQC_DAT)
PR_ResetFonts(0);
#endif
if (qrenderer == QR_NONE)
return;
#if defined(_WIN32) && !defined(FTE_SDL)
if (!strcmp(gl_font.string, "?"))
{
BOOL (APIENTRY *pChooseFontA)(LPCHOOSEFONTA) = NULL;
dllfunction_t funcs[] =
{
{(void*)&pChooseFontA, "ChooseFontA"},
{NULL}
};
qboolean MyRegGetStringValue(HKEY base, char *keyname, char *valuename, void *data, int datalen);
LOGFONT lf = {0};
CHOOSEFONTA cf = {sizeof(cf)};
extern HWND mainwindow;
font_default = Font_LoadFont(8, "");
if (con_textsize.ival != 8 && con_textsize.ival >= 1)
font_console = Font_LoadFont(con_textsize.ival, "");
if (!font_console)
font_console = font_default;
cf.hwndOwner = mainwindow;
cf.iPointSize = (8 * vid.rotpixelheight)/vid.height;
cf.Flags = CF_FORCEFONTEXIST | CF_TTONLY;
cf.lpLogFont = &lf;
Sys_LoadLibrary("Comdlg32.dll", funcs);
if (pChooseFontA && pChooseFontA(&cf))
{
char fname[MAX_OSPATH*8];
char *keyname;
*fname = 0;
//FIXME: should enumerate and split & and ignore sizes and () crap.
if (!*fname)
{
keyname = va("%s%s%s (TrueType)", lf.lfFaceName, lf.lfWeight>=FW_BOLD?" Bold":"", lf.lfItalic?" Italic":"");
if (!MyRegGetStringValue(HKEY_LOCAL_MACHINE, WinNT?"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts":"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Fonts", keyname, fname, sizeof(fname)))
*fname = 0;
}
if (!*fname)
{
keyname = va("%s (OpenType)", lf.lfFaceName);
if (!MyRegGetStringValue(HKEY_LOCAL_MACHINE, WinNT?"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts":"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Fonts", keyname, fname, sizeof(fname)))
*fname = 0;
}
R2D_Font_AddFontLink(fname, sizeof(fname), lf.lfFaceName);
Cvar_Set(&gl_font, fname);
}
return;
}
#endif
font_default = Font_LoadFont(8, gl_font.string);
if (!font_default && *gl_font.string)
font_default = Font_LoadFont(8, "");
if (con_textsize.ival != 8 && con_textsize.ival >= 1)
{
font_console = Font_LoadFont(con_textsize.ival, gl_font.string);
if (!font_console)
font_console = Font_LoadFont(con_textsize.ival, "");
}
if (!font_console)
font_console = font_default;
}
void R2D_Font_Callback(struct cvar_s *var, char *oldvalue)
{
con_textsize.modified = true;
}
// console size manipulation callbacks
void R2D_Console_Resize(void)
{
extern cvar_t gl_font;
extern cvar_t vid_conwidth, vid_conheight;
int cwidth, cheight;
float xratio;
float yratio=0;
float ang, rad;
extern cvar_t gl_screenangle;
ang = (gl_screenangle.value>0?(gl_screenangle.value+45):(gl_screenangle.value-45))/90;
ang = (int)ang * 90;
if (ang)
{
rad = (ang * M_PI) / 180;
vid.rotpixelwidth = fabs(cos(rad)) * (vid.pixelwidth) + fabs(sin(rad)) * (vid.pixelheight);
vid.rotpixelheight = fabs(sin(rad)) * (vid.pixelwidth) + fabs(cos(rad)) * (vid.pixelheight);
}
else
{
vid.rotpixelwidth = vid.pixelwidth;
vid.rotpixelheight = vid.pixelheight;
}
cwidth = vid_conwidth.value;
cheight = vid_conheight.value;
xratio = vid_conautoscale.value;
if (xratio > 0)
{
char *s = strchr(vid_conautoscale.string, ' ');
if (s)
yratio = atof(s + 1);
if (yratio <= 0)
yratio = xratio;
xratio = 1 / xratio;
yratio = 1 / yratio;
//autoscale overrides conwidth/height (without actually changing them)
cwidth = vid.rotpixelwidth;
cheight = vid.rotpixelheight;
}
else
{
xratio = 1;
yratio = 1;
}
if (!cwidth && !cheight)
cheight = 480;
if (cheight && !cwidth)
cwidth = (cheight*vid.rotpixelwidth)/vid.rotpixelheight;
if (cwidth && !cheight)
cheight = (cwidth*vid.rotpixelheight)/vid.rotpixelwidth;
if (!cwidth)
cwidth = vid.rotpixelwidth;
if (!cheight)
cheight = vid.rotpixelheight;
cwidth*=xratio;
cheight*=yratio;
if (cwidth < 320)
cwidth = 320;
if (cheight < 200)
cheight = 200;
vid.width = cwidth;
vid.height = cheight;
Cvar_ForceCallback(&gl_font);
#ifdef PLUGINS
Plug_ResChanged();
#endif
}
void R2D_Conheight_Callback(struct cvar_s *var, char *oldvalue)
{
if (var->value > 1536) //anything higher is unreadable.
{
Cvar_ForceSet(var, "1536");
return;
}
if (var->value < 200 && var->value) //lower would be wrong
{
Cvar_ForceSet(var, "200");
return;
}
R2D_Console_Resize();
}
void R2D_Conwidth_Callback(struct cvar_s *var, char *oldvalue)
{
//let let the user be too crazy
if (var->value > 2048) //anything higher is unreadable.
{
Cvar_ForceSet(var, "2048");
return;
}
if (var->value < 320 && var->value) //lower would be wrong
{
Cvar_ForceSet(var, "320");
return;
}
R2D_Console_Resize();
}
void R2D_Conautoscale_Callback(struct cvar_s *var, char *oldvalue)
{
R2D_Console_Resize();
}
void R2D_ScreenAngle_Callback(struct cvar_s *var, char *oldvalue)
{
R2D_Console_Resize();
}
/*
============
R_PolyBlend
============
*/
//bright flashes and stuff, game only, doesn't touch sbar
void R2D_PolyBlend (void)
{
if (!sw_blend[3])
return;
if (r_refdef.flags & Q2RDF_NOWORLDMODEL)
return;
R2D_ImageColours (sw_blend[0], sw_blend[1], sw_blend[2], sw_blend[3]);
R2D_ScalePic(r_refdef.vrect.x, r_refdef.vrect.y, r_refdef.vrect.width, r_refdef.vrect.height, shader_polyblend);
R2D_ImageColours (1, 1, 1, 1);
}
//for lack of hardware gamma
void R2D_BrightenScreen (void)
{
float f;
RSpeedMark();
if (fabs(v_contrast.value - 1.0) < 0.05 && fabs(v_brightness.value - 0) < 0.05 && fabs(v_gamma.value - 1) < 0.05)
return;
//don't go crazy with brightness. that makes it unusable and is thus unsafe - and worse, lots of people assume its based around 1 (like gamma and contrast are). cap to 0.5
if (v_brightness.value > 0.5)
v_brightness.value = 0.5;
if (r2d_canhwgamma)
return;
if (v_gamma.value != 1 && shader_gammacb->prog)
{
//this should really be done properly, with render-to-texture
R2D_ImageColours (v_gamma.value, v_contrast.value, v_brightness.value, 1);
R2D_ScalePic(0, vid.height, vid.width, -(int)vid.height, shader_gammacb);
}
else
{
f = v_contrast.value;
f = min (f, 3);
while (f > 1)
{
if (f >= 2)
{
R2D_ImageColours (1, 1, 1, 1);
f *= 0.5;
}
else
{
R2D_ImageColours (f - 1, f - 1, f - 1, 1);
f = 1;
}
R2D_ScalePic(0, 0, vid.width, vid.height, shader_contrastup);
}
if (f < 1)
{
R2D_ImageColours (f, f, f, 1);
R2D_ScalePic(0, 0, vid.width, vid.height, shader_contrastdown);
}
if (v_brightness.value)
{
R2D_ImageColours (v_brightness.value, v_brightness.value, v_brightness.value, 1);
R2D_ScalePic(0, 0, vid.width, vid.height, shader_brightness);
}
}
R2D_ImageColours (1, 1, 1, 1);
/*make sure the hud is redrawn after if needed*/
Sbar_Changed();
RSpeedEnd(RSPEED_PALETTEFLASHES);
}
//for menus
void R2D_FadeScreen (void)
{
R2D_ScalePic(0, 0, vid.width, vid.height, shader_menutint);
Sbar_Changed();
}
//crosshairs
#define CS_HEIGHT 8
#define CS_WIDTH 8
unsigned char crosshair_pixels[] =
{
// 2 + (spaced)
0x08,
0x00,
0x08,
0x55,
0x08,
0x00,
0x08,
0x00,
// 3 +
0x00,
0x08,
0x08,
0x36,
0x08,
0x08,
0x00,
0x00,
// 4 X
0x00,
0x22,
0x14,
0x00,
0x14,
0x22,
0x00,
0x00,
// 5 X (spaced)
0x41,
0x00,
0x14,
0x00,
0x14,
0x00,
0x41,
0x00,
// 6 diamond (unconnected)
0x00,
0x14,
0x22,
0x00,
0x22,
0x14,
0x00,
0x00,
// 7 diamond
0x00,
0x08,
0x14,
0x22,
0x14,
0x08,
0x00,
0x00,
// 8 four points
0x00,
0x08,
0x00,
0x22,
0x00,
0x08,
0x00,
0x00,
// 9 three points
0x00,
0x00,
0x08,
0x00,
0x22,
0x00,
0x00,
0x00,
// 10
0x08,
0x2a,
0x00,
0x63,
0x00,
0x2a,
0x08,
0x00,
// 11
0x49,
0x2a,
0x00,
0x63,
0x00,
0x2a,
0x49,
0x00,
// 12 horizontal line
0x00,
0x00,
0x00,
0x77,
0x00,
0x00,
0x00,
0x00,
// 13 vertical line
0x08,
0x08,
0x08,
0x00,
0x08,
0x08,
0x08,
0x00,
// 14 larger +
0x08,
0x08,
0x08,
0x77,
0x08,
0x08,
0x08,
0x00,
// 15 angle
0x00,
0x00,
0x00,
0x70,
0x08,
0x08,
0x08,
0x00,
// 16 dot
0x00,
0x00,
0x00,
0x08,
0x00,
0x00,
0x00,
0x00,
// 17 weird angle thing
0x00,
0x00,
0x00,
0x38,
0x48,
0x08,
0x10,
0x00,
// 18 circle w/ dot
0x00,
0x00,
0x00,
0x6b,
0x41,
0x63,
0x3e,
0x08,
// 19 tripoint
0x08,
0x08,
0x08,
0x00,
0x14,
0x22,
0x41,
0x00,
};
void R2D_Crosshair_Update(void)
{
int crossdata[CS_WIDTH*CS_HEIGHT];
int c;
int w, h;
unsigned char *x;
c = crosshair.ival;
if (!crosshairimage.string)
return;
else if (crosshairimage.string[0] && c == 1)
{
shader_crosshair->defaulttextures.base = R_LoadHiResTexture (crosshairimage.string, "crosshairs", IF_UIPIC|IF_NOMIPMAP|IF_NOGAMMA);
if (TEXVALID(shader_crosshair->defaulttextures.base))
return;
}
else if (c <= 1)
return;
c -= 2;
c = c % (sizeof(crosshair_pixels) / (CS_HEIGHT*sizeof(*crosshair_pixels)));
if (!TEXVALID(ch_int_texture))
ch_int_texture = R_AllocNewTexture("***crosshair***", CS_WIDTH, CS_HEIGHT, IF_UIPIC|IF_NOMIPMAP);
shader_crosshair->defaulttextures.base = ch_int_texture;
Q_memset(crossdata, 0, sizeof(crossdata));
x = crosshair_pixels + (CS_HEIGHT * c);
for (h = 0; h < CS_HEIGHT; h++)
{
int pix = x[h];
for (w = 0; w < CS_WIDTH; w++)
{
if (pix & 0x1)
crossdata[CS_WIDTH * h + w] = 0xffffffff;
pix >>= 1;
}
}
R_Upload(ch_int_texture, NULL, TF_RGBA32, crossdata, NULL, CS_WIDTH, CS_HEIGHT, IF_UIPIC|IF_NOMIPMAP|IF_NOGAMMA);
}
void R2D_CrosshairImage_Callback(struct cvar_s *var, char *oldvalue)
{
R2D_Crosshair_Update();
}
void R2D_Crosshair_Callback(struct cvar_s *var, char *oldvalue)
{
R2D_Crosshair_Update();
}
void R2D_CrosshairColor_Callback(struct cvar_s *var, char *oldvalue)
{
SCR_StringToRGB(var->string, ch_color, 255);
ch_color[0] = bound(0, ch_color[0], 1);
ch_color[1] = bound(0, ch_color[1], 1);
ch_color[2] = bound(0, ch_color[2], 1);
}
void R2D_DrawCrosshair(void)
{
int x, y;
int sc;
float sx, sy, sizex, sizey;
float size;
if (crosshair.ival < 1)
return;
// old style
if (crosshair.ival == 1 && !crosshairimage.string[0])
{
// adjust console crosshair scale to match default
size = crosshairsize.value;
if (size == 0)
size = 8;
else if (size < 0)
size = -size;
for (sc = 0; sc < cl.splitclients; sc++)
{
SCR_CrosshairPosition(&cl.playerview[sc], &sx, &sy);
Font_BeginScaledString(font_default, sx, sy, size, size, &sx, &sy);
sx -= Font_CharScaleWidth('+' | 0xe000 | CON_WHITEMASK)/2;
sy -= Font_CharScaleHeight()/2;
Font_ForceColour(ch_color[0], ch_color[1], ch_color[2], crosshairalpha.value);
Font_DrawScaleChar(sx, sy, '+' | 0xe000 | CON_WHITEMASK);
Font_InvalidateColour();
Font_EndString(font_default);
}
return;
}
size = crosshairsize.value;
if (size < 0)
{
size = -size;
sizex = size;
sizey = size;
}
else
{
sizex = (size*vid.rotpixelwidth) / (float)vid.width;
sizey = (size*vid.rotpixelheight) / (float)vid.height;
}
sizex = (int)sizex;
sizex = ((sizex)*(int)vid.width) / (float)vid.rotpixelwidth;
sizey = (int)sizey;
sizey = ((sizey)*(int)vid.height) / (float)vid.rotpixelheight;
R2D_ImageColours(ch_color[0], ch_color[1], ch_color[2], crosshairalpha.value);
for (sc = 0; sc < cl.splitclients; sc++)
{
SCR_CrosshairPosition(&cl.playerview[sc], &sx, &sy);
//translate to pixel coord, for rounding
x = ((sx-sizex+(sizex/CS_WIDTH))*vid.rotpixelwidth) / (float)vid.width;
y = ((sy-sizey+(sizey/CS_HEIGHT))*vid.rotpixelheight) / (float)vid.height;
//translate to screen coords
sx = ((x)*(int)vid.width) / (float)vid.rotpixelwidth;
sy = ((y)*(int)vid.height) / (float)vid.rotpixelheight;
R2D_Image(sx, sy, sizex*2, sizey*2, 0, 0, 1, 1, shader_crosshair);
}
R2D_ImageColours(1, 1, 1, 1);
}
//resize a texture for a render target and specify the format of it.
//pass TF_INVALID and sizes=0 to get without configuring (shaders that hardcode an $rt1 etc).
texid_t R2D_RT_Configure(unsigned int id, int width, int height, uploadfmt_t rtfmt)
{
id--; //0 is invalid.
if (id < 0 || id > 255) //sanity limit
return r_nulltex;
//extend the array if needed. these should be fairly light.
if (id >= numrendertargets)
{
rendertargets = realloc(rendertargets, (id+1) * sizeof(*rendertargets));
while(numrendertargets <= id)
{
rendertargets[numrendertargets].id = r_nulltex;
rendertargets[numrendertargets].width = 0;
rendertargets[numrendertargets].height = 0;
rendertargets[numrendertargets].fmt = TF_INVALID;
numrendertargets++;
}
}
if (!TEXVALID(rendertargets[id].id))
rendertargets[id].id = R_AllocNewTexture(va("", id+1), 0, 0, IF_NOMIPMAP);
if (rtfmt)
{
switch(rtfmt)
{
case 1: rtfmt = TF_RGBA32; break;
case 2: rtfmt = TF_RGBA16F; break;
case 3: rtfmt = TF_RGBA32F; break;
case 4: rtfmt = TF_DEPTH16; break;
case 5: rtfmt = TF_DEPTH24; break;
case 6: rtfmt = TF_DEPTH32; break;
default:rtfmt = TF_INVALID; break;
}
// if (rendertargets[id].fmt != rtfmt || rendertargets[id].width != width || rendertargets[id].height != height)
{
rendertargets[id].fmt = rtfmt;
rendertargets[id].width = width;
rendertargets[id].height = height;
R_Upload(rendertargets[id].id, "", rtfmt, NULL, NULL, width, height, IF_NOMIPMAP);
}
}
return rendertargets[id].id;
}
texid_t R2D_RT_GetTexture(unsigned int id, unsigned int *width, unsigned int *height)
{
if (!id)
{
*width = 0;
*height = 0;
return r_nulltex;
}
id--;
if (id >= numrendertargets)
{
Con_Printf("Render target %u is not configured\n", id);
R2D_RT_Configure(id, 0, 0, TF_INVALID);
if (id >= numrendertargets)
{
*width = 0;
*height = 0;
return r_nulltex;
}
}
*width = rendertargets[id].width;
*height = rendertargets[id].height;
return rendertargets[id].id;
}
#endif
Reference in a new issue View git blame Copy permalink