fteqw/plugins/ezhud/ezquakeisms.c

751 lines
19 KiB
C
Raw Normal View History

#include "../plugin.h"
#include "ezquakeisms.h"
#include "hud.h"
#include "hud_editor.h"
plug2dfuncs_t *drawfuncs;
plugclientfuncs_t *clientfuncs;
plugfsfuncs_t *filefuncs;
pluginputfuncs_t *inputfuncs;
int sb_lines;
float scr_con_current;
int sb_showteamscores;
int sb_showscores;
int host_screenupdatecount;
float alphamul;
cvar_t *scr_newHud;
static void QDECL EZHud_UpdateVideo(int width, int height)
{
vid.width = width;
vid.height = height;
}
char *Cmd_Argv(int arg)
{
static char buf[4][128];
if (arg >= 4)
return "";
cmdfuncs->Argv(arg, buf[arg], sizeof(buf[arg]));
return buf[arg];
}
float infofloat(char *info, char *findkey, float def);
void Draw_SetOverallAlpha(float a)
{
alphamul = a;
}
void Draw_AlphaFillRGB(float x, float y, float w, float h, qbyte r, qbyte g, qbyte b, qbyte a)
{
drawfuncs->Colour4f(r/255.0, g/255.0, b/255.0, a/255.0 * alphamul);
drawfuncs->Fill(x, y, w, h);
drawfuncs->Colour4f(1, 1, 1, 1);
}
void Draw_Fill(float x, float y, float w, float h, qbyte pal)
{
drawfuncs->Colourpa(pal, alphamul);
drawfuncs->Fill(x, y, w, h);
drawfuncs->Colour4f(1, 1, 1, 1);
}
const char *ColorNameToRGBString (const char *newval)
{
return newval;
}
byte *StringToRGB(const char *str)
{
static byte rgba[4];
int i;
for (i = 0; i < 4; i++)
{
while(*str && *str <= ' ')
str++;
if (!*str)
rgba[i] = 255;
else
rgba[i] = strtoul(str, (char**)&str, 0);
}
return rgba;
}
void Draw_TextBox (int x, int y, int width, int lines)
{
}
char *TP_LocationName (const vec3_t location)
{
static char locname[256];
clientfuncs->GetLocationName(location, locname, sizeof(locname));
return locname;
}
void Draw_SPic(float x, float y, mpic_t *pic, float scale)
{
qhandle_t image = (intptr_t)pic;
float w, h;
drawfuncs->ImageSize(image, &w, &h);
drawfuncs->Image(x, y, w*scale, h*scale, 0, 0, 1, 1, image);
}
void Draw_SSubPic(float x, float y, mpic_t *pic, float s1, float t1, float s2, float t2, float scale)
{
qhandle_t image = (intptr_t)pic;
float w, h;
drawfuncs->ImageSize(image, &w, &h);
drawfuncs->Image(x, y, (s2-s1)*scale, (t2-t1)*scale, s1/w, t1/h, s2/w, t2/h, image);
}
void Draw_EZString(float x, float y, char *str, float scale, qboolean red)
{
unsigned int flags = 0;
if (red)
flags |= 1;
drawfuncs->StringH(x, y, scale, flags, str);
}
#define Draw_STransPic Draw_SPic
void Draw_Character(float x, float y, unsigned int ch)
{
drawfuncs->Character(x, y, 0xe000|ch);
}
void Draw_SCharacter(float x, float y, unsigned int ch, float scale)
{
drawfuncs->CharacterH(x, y, 8*scale, 0, 0xe000|ch);
}
void SCR_DrawWadString(float x, float y, float scale, char *str)
{
drawfuncs->String(x, y, str); //FIXME
}
void Draw_SAlphaSubPic2(float x, float y, mpic_t *pic, float s1, float t1, float s2, float t2, float sw, float sh, float alpha)
{
qhandle_t image = (intptr_t)pic;
float w, h;
drawfuncs->ImageSize(image, &w, &h);
drawfuncs->Colour4f(1, 1, 1, alpha * alphamul);
drawfuncs->Image(x, y, (s2-s1)*sw, (t2-t1)*sh, s1/w, t1/h, s2/w, t2/h, image);
drawfuncs->Colour4f(1, 1, 1, 1);
}
void Draw_AlphaFill(float x, float y, float w, float h, unsigned int pal, float alpha)
{
if (pal >= 256)
drawfuncs->Colour4f(((pal>>16)&0xff)/255.0, ((pal>>8)&0xff)/255.0, ((pal>>0)&0xff)/255.0, alpha * alphamul);
else
drawfuncs->Colourpa(pal, alpha * alphamul);
drawfuncs->Fill(x, y, w, h);
drawfuncs->Colour4f(1, 1, 1, 1);
}
void Draw_AlphaPic(float x, float y, mpic_t *pic, float alpha)
{
qhandle_t image = (intptr_t)pic;
float w, h;
drawfuncs->ImageSize(image, &w, &h);
drawfuncs->Colour4f(1, 1, 1, alpha * alphamul);
drawfuncs->Image(x, y, w, h, 0, 0, 1, 1, image);
drawfuncs->Colour4f(1, 1, 1, 1);
}
void Draw_AlphaSubPic(float x, float y, mpic_t *pic, float s1, float t1, float s2, float t2, float alpha)
{
qhandle_t image = (intptr_t)pic;
float w, h;
drawfuncs->ImageSize(image, &w, &h);
drawfuncs->Colour4f(1, 1, 1, alpha * alphamul);
drawfuncs->Image(x, y, s2-s1, t2-t1, s1/w, t1/h, s2/w, t2/h, image);
drawfuncs->Colour4f(1, 1, 1, 1);
}
void SCR_HUD_DrawBar(int direction, int value, float max_value, float *rgba, int x, int y, int width, int height)
{
int amount;
if(direction >= 2)
// top-down
amount = Q_rint(fabs((height * value) / max_value));
else// left-right
amount = Q_rint(fabs((width * value) / max_value));
drawfuncs->Colour4f(rgba[0]/255.0, rgba[1]/255.0, rgba[2]/255.0, rgba[3]/255.0 * alphamul);
if(direction == 0)
// left->right
drawfuncs->Fill(x, y, amount, height);
else if (direction == 1)
// right->left
drawfuncs->Fill(x + width - amount, y, amount, height);
else if (direction == 2)
// down -> up
drawfuncs->Fill(x, y + height - amount, width, amount);
else
// up -> down
drawfuncs->Fill(x, y, width, amount);
drawfuncs->Colour4f(1, 1, 1, 1);
}
void Draw_Polygon(int x, int y, vec3_t *vertices, int num_vertices, qbool fill, byte r, byte g, byte b, byte a)
{
drawfuncs->Colour4f(r/255.0, g/255.0, b/255.0, a/255.0 * alphamul);
// drawfuncs->Line(x1, y1, x2, y1);
drawfuncs->Colour4f(1, 1, 1, 1);
}
void Draw_ColoredString3(float x, float y, const char *str, clrinfo_t *clr, int huh, int wut)
{
drawfuncs->Colour4f(clr->c[0]/255.0, clr->c[1]/255.0, clr->c[2]/255.0, clr->c[3]/255.0 * alphamul);
drawfuncs->String(x, y, str);
drawfuncs->Colour4f(1, 1, 1, 1);
}
void UI_PrintTextBlock(void)
{
}
void Draw_AlphaRectangleRGB(int x, int y, int w, int h, int foo, int bar, byte r, byte g, byte b, byte a)
{
float x1 = x;
float x2 = x+w;
float y1 = y;
float y2 = y+h;
drawfuncs->Colour4f(r/255.0, g/255.0, b/255.0, a/255.0 * alphamul);
drawfuncs->Line(x1, y1, x2, y1);
drawfuncs->Line(x2, y1, x2, y2);
drawfuncs->Line(x1, y2, x2, y2);
drawfuncs->Line(x1, y1, x1, y2);
drawfuncs->Colour4f(1, 1, 1, 1);
}
void Draw_AlphaLineRGB(float x1, float y1, float x2, float y2, float width, byte r, byte g, byte b, byte a)
{
drawfuncs->Colour4f(r/255.0, g/255.0, b/255.0, a/255.0 * alphamul);
drawfuncs->Line(x1, y1, x2, y2);
drawfuncs->Colour4f(1, 1, 1, 1);
}
mpic_t *Draw_CachePicSafe(const char *name, qbool crash, qbool ignorewad)
{
if (!*name)
return NULL;
return (mpic_t*)(qintptr_t)drawfuncs->LoadImage(name, false);
}
mpic_t *Draw_CacheWadPic(const char *name)
{
return (mpic_t*)(qintptr_t)drawfuncs->LoadImage(name, true);
}
mpic_t *SCR_LoadCursorImage(char *cursorimage)
{
return Draw_CachePicSafe(cursorimage, false, true);
}
unsigned int Sbar_ColorForMap (unsigned int m)
{
if (m >= 16)
return m;
m = (m < 0) ? 0 : ((m > 13) ? 13 : m);
m *= 16;
return m < 128 ? m + 8 : m + 8;
}
int Sbar_TopColor(player_info_t *pi)
{
return Sbar_ColorForMap(pi->topcolour);
}
int Sbar_BottomColor(player_info_t *pi)
{
return Sbar_ColorForMap(pi->bottomcolour);
}
int dehex(char nib)
{
if (nib >= '0' && nib <= '9')
return nib - '0';
if (nib >= 'a' && nib <= 'f')
return nib - 'a' + 10;
if (nib >= 'A' && nib <= 'F')
return nib - 'A' + 10;
return 0;
}
char *TP_ParseFunChars(char *str, qbool chat)
{
static char resultbuf[1024];
char *out = resultbuf, *end = resultbuf+sizeof(resultbuf)-1;
while (out < end)
{
if (str[0] == '$' && str[1] == 'x' && str[2] && str[3])
{
*out++ = (dehex(str[2]) << 4) | dehex(str[3]);
str+=4;
}
else if (str[0] == '$')
{
int c = 0;
switch (str[1])
{
case '\\': c = 0x0D; break;
case ':': c = 0x0A; break;
case '[': c = 0x10; break;
case ']': c = 0x11; break;
case 'G': c = 0x86; break;
case 'R': c = 0x87; break;
case 'Y': c = 0x88; break;
case 'B': c = 0x89; break;
case '(': c = 0x80; break;
case '=': c = 0x81; break;
case ')': c = 0x82; break;
case 'a': c = 0x83; break;
case '<': c = 0x1d; break;
case '-': c = 0x1e; break;
case '>': c = 0x1f; break;
case ',': c = 0x1c; break;
case '.': c = 0x9c; break;
case 'b': c = 0x8b; break;
case 'c':
case 'd': c = 0x8d; break;
case '$': c = '$'; break;
case '^': c = '^'; break;
case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9': c = str[1] -'0' + 0x12;break;
}
if (c)
{
*out++ = c;
str++;
}
str++;
}
else if (*str)
*out++ = *str++;
else
break;
}
*out = 0;
return resultbuf;
}
char *TP_ItemName(unsigned int itbit)
{
return "Dunno";
}
void Replace_In_String(char *src, size_t strsize, char leadchar, int patterns, ...)
{
char orig[1024];
char *out, *outstop;
va_list ap;
int i;
strlcpy(orig, src, sizeof(orig));
out = src;
outstop = out + strsize-1;
src = orig;
while(*src)
{
if (out == outstop)
break;
if (*src != leadchar)
*out++ = *src++;
else if (*++src == leadchar)
*out++ = leadchar;
else
{
va_start(ap, patterns);
for (i = 0; i < patterns; i++)
{
const char *arg = va_arg(ap, const char *);
const char *val = va_arg(ap, const char *);
size_t alen = strlen(arg);
if (!strncmp(src, arg, strlen(arg)))
{
strlcpy(out, val, (outstop-out)+1);
out += strlen(out);
src += alen;
break;
}
}
if (i == patterns)
{
strlcpy(out, "unknown", (outstop-out)+1);
out += strlen(out);
}
va_end(ap);
}
}
*out = 0;
}
int SCR_GetClockStringWidth(const char *s, qbool big, float scale)
{
int w = 0;
if (big)
{
while(*s)
w += ((*s++==':')?16:24);
}
else
w = strlen(s) * 8;
return w * scale;
}
int SCR_GetClockStringHeight(qbool big, float scale)
{
return (big?24:8)*scale;
}
char *SecondsToMinutesString(int print_time, char *buffer, size_t buffersize) {
int tens_minutes, minutes, tens_seconds, seconds;
tens_minutes = fmod (print_time / 600, 6);
minutes = fmod (print_time / 60, 10);
tens_seconds = fmod (print_time / 10, 6);
seconds = fmod (print_time, 10);
snprintf (buffer, buffersize, "%i%i:%i%i", tens_minutes, minutes, tens_seconds, seconds);
return buffer;
}
char *SCR_GetGameTime(int t, char *buffer, size_t buffersize)
{
float timelimit;
timelimit = (t == TIMETYPE_GAMECLOCKINV) ? 60 * infofloat(cl.serverinfo, "timelimit", 0) + 1: 0;
if (cl.countdown || cl.standby)
SecondsToMinutesString(timelimit, buffer, buffersize);
else
SecondsToMinutesString((int) fabs(timelimit - (cl.time - cl.matchstart)), buffer, buffersize);
return buffer;
}
const char* SCR_GetTimeString(int timetype, const char *format)
{
static char buffer[256];
switch(timetype)
{
case TIMETYPE_CLOCK:
{
time_t t;
struct tm *ptm;
time (&t);
ptm = localtime (&t);
if (!ptm) return "-:-";
if (!strftime(buffer, sizeof(buffer)-1, format, ptm)) return "-:-";
return buffer;
}
case TIMETYPE_GAMECLOCK:
case TIMETYPE_GAMECLOCKINV:
return SCR_GetGameTime(timetype, buffer, sizeof(buffer));
case TIMETYPE_DEMOCLOCK:
return SecondsToMinutesString(infofloat(cl.serverinfo, "demotime", 0), buffer, sizeof(buffer));
default:
return "01234";
}
}
void SCR_DrawBigClock(int x, int y, int style, int blink, float scale, const char *t)
{
extern mpic_t *sb_nums[2][11];
extern mpic_t *sb_colon/*, *sb_slash*/;
qbool lblink = (int)(cls.realtime*2) & 1;
if (style > 1) style = 1;
if (style < 0) style = 0;
while (*t)
{
if (*t >= '0' && *t <= '9')
{
Draw_STransPic(x, y, sb_nums[style][*t-'0'], scale);
x += 24*scale;
}
else if (*t == ':')
{
if (lblink || !blink)
Draw_STransPic (x, y, sb_colon, scale);
x += 16*scale;
}
else
{
Draw_SCharacter(x, y, *t+(style?128:0), 3*scale);
x += 24*scale;
}
t++;
}
}
void SCR_DrawSmallClock(int x, int y, int style, int blink, float scale, const char *t)
{
qbool lblink = (int)(cls.realtime*2) & 1;
int c;
if (style > 3) style = 3;
if (style < 0) style = 0;
while (*t)
{
c = (int) *t;
if (c >= '0' && c <= '9')
{
if (style == 1)
c += 128;
else if (style == 2 || style == 3)
c -= 30;
}
else if (c == ':')
{
if (style == 1 || style == 3)
c += 128;
if (lblink || !blink)
;
else
c = ' ';
}
Draw_SCharacter(x, y, c, scale);
x+= 8*scale;
t++;
}
}
#include "builtin_huds.h"
void EZHud_UseNquake_f(void)
{
const char *hudstr = builtin_hud_nquake;
cmdfuncs->AddText(hudstr, true);
}
static struct
{
xcommand_t cmd;
const char *name;
} concmds[128];
static int numconcmds;
qboolean Cmd_AddCommand (const char *funcname, xcommand_t function)
{
if (numconcmds < sizeof(concmds)/sizeof(concmds[0]))
{
concmds[numconcmds].cmd = function;
concmds[numconcmds].name = funcname;
numconcmds++;
cmdfuncs->AddCommand(funcname);
return true;
}
Con_Printf("ezhud: too many console commands\n");
return false;
};
static qboolean QDECL EZHud_ExecuteCommand(qboolean isinsecure)
{
char buffer[128];
int i;
cmdfuncs->Argv(0, buffer, sizeof(buffer));
for (i = 0; i < numconcmds; i++)
{
if (!strcmp(buffer, concmds[i].name))
{
concmds[i].cmd();
return 1;
}
}
return 0;
}
int IN_BestWeapon(void)
{
return 0;
}
qbool VID_VSyncIsOn(void){return false;}
double vid_vsync_lag;
vrect_t scr_vrect;
void EZHud_Tick(double realtime, double gametime)
{
static float lasttime, lasttime_min = 99999;
static int framecount;
//realtime(ms), realtime(secs), servertime
float oldtime = cls.realtime;
cls.realtime = realtime;
cls.frametime = cls.realtime - oldtime;
cl.time = gametime;
if (cls.realtime - lasttime > 1)
{
cls.fps = framecount/(cls.realtime - lasttime);
lasttime = cls.realtime;
framecount = 0;
if (cls.realtime - lasttime_min > 30)
{
cls.min_fps = cls.fps;
lasttime_min = cls.realtime;
}
else if (cls.min_fps > cls.fps)
cls.min_fps = cls.fps;
}
framecount++;
}
char *findinfo(char *info, char *findkey)
{
int kl = strlen(findkey);
char *key, *value;
while(*info)
{
key = strchr(info, '\\');
if (!key)
break;
key++;
value = strchr(key, '\\');
if (!value)
break;
info = value+1;
if (!strncmp(key, findkey, kl) && key[kl] == '\\')
return info;
}
return NULL;
}
char *infostring(char *info, char *findkey, char *buffer, size_t bufsize)
{
char *value = findinfo(info, findkey);
char *end;
if (value)
{
end = strchr(value, '\\');
if (!end)
end = value + strlen(value);
bufsize--;
if (bufsize > (end - value))
bufsize = (end - value);
memcpy(buffer, value, bufsize);
buffer[bufsize] = 0;
return buffer;
}
*buffer = 0;
return buffer;
}
float infofloat(char *info, char *findkey, float def)
{
char *value = findinfo(info, findkey);
if (value)
return atof(value);
return def;
}
int EZHud_Draw(int seat, float viewx, float viewy, float viewwidth, float viewheight, int showscores)
{
char serverinfo[4096];
char val[64];
int i;
cl.splitscreenview = seat;
scr_vrect.x = viewx;
scr_vrect.y = viewy;
scr_vrect.width = viewwidth;
scr_vrect.height = viewheight;
sb_showscores = showscores & 1;
sb_showteamscores = showscores & 2;
clientfuncs->GetStats(0, cl.stats, sizeof(cl.stats)/sizeof(cl.stats[0]));
for (i = 0; i < 32; i++)
clientfuncs->GetPlayerInfo(i, &cl.players[i]);
clientfuncs->GetLocalPlayerNumbers(cl.splitscreenview, 1, &cl.playernum, &cl.tracknum);
clientfuncs->GetServerInfo(cl.serverinfo, sizeof(serverinfo));
cl.deathmatch = infofloat(cl.serverinfo, "deathmatch", 0);
cl.teamplay = infofloat(cl.serverinfo, "teamplay", 0);
cl.intermission = infofloat(cl.serverinfo, "intermission", 0);
cl.spectator = (cl.playernum>=32)||cl.players[cl.playernum].spectator;
infostring(cl.serverinfo, "status", val, sizeof(val));
cl.standby = !strcmp(val, "standby");
cl.countdown = !strcmp(val, "countdown");
cl.matchstart = infofloat(cl.serverinfo, "matchstart", 0);
cls.state = ca_active;
infostring(cl.serverinfo, "demotype", val, sizeof(val));
cls.mvdplayback = !strcmp(val, "mvd");
cls.demoplayback = strcmp(val, "");
{
static cvar_t *pscr_viewsize = NULL;
int size;
if (!pscr_viewsize)
pscr_viewsize = cvarfuncs->GetNVFDG("viewsize", "100", 0, NULL, NULL);
size = cl.intermission ? 120 : pscr_viewsize->value;
if (size >= 120)
sb_lines = 0; // no status bar at all
else if (size >= 110)
sb_lines = 24; // no inventory
else
sb_lines = 24 + 16 + 8;
}
fixed eztv md4 incompatibility. reimplemented qtvreverse command. fixed some stuffcmds being handled by the wrong splitscreen seats (was noticable in TF). rework smartjump to try to be more predictable... rework relighting to try to be more robust (and more self-contained). allow the csqc to actually use VF_PROJECTIONOFFSET. jump now moves upwards instead of trying to lock on to a nearby player when spectating. assume 32 fullbright pixels when running with a palette.lmp yet no colormap.lmp (happens with some total conversions). tweaked scoreboard for fainter backgrounds. rearranged autoid, to be smaller etc. hacked around dodgy conchars.lmp - don't treat 128*128 qpics as qpics to work around workarounds for buggy wad tools (with a warning). fixed missing fullbrights on h2holey models. avoided warning about mod_h2holey_bugged on dedicated servers. added net_ice_exchangeprivateips, for people worried about exposing lan IPs when using ICE. sv_public 2: implemented client support for our webrtc broker in order to use our own ICE implementation without needing to faff around with irc accounts or plugins etc. TODO: ensure at least one ephemerial udp port when using ice or come up with some better sv_port handling fixed multiple tls bugs (one could cause server problems). change net_enable_tls to disabled by default anyway (reenable for the server to be able to respond to https/wss/tls schemes again). don't colourmap when there appears to be a highres diffusemap on q1 models. imgtool now understands exporting from qpics in wads, as well as just mips. implemented speed-o-meter in ezhud. added removeinstant builtin to avoid the half-second rule. git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5614 fc73d0e0-1445-4013-8a0c-d673dee63da5
2020-02-11 18:06:10 +00:00
clientfuncs->GetPredInfo(seat, cl.simvel);
//cl.faceanimtime
//cl.item_gettime
//cls.state;
//cls.min_fps;
//cls.fps;
////cls.realtime;
////cls.trueframetime;
host_screenupdatecount++;
HUD_Draw();
return true;
}
int keydown[K_MAX];
float cursor_x;
float cursor_y;
float mouse_x;
float mouse_y;
mpic_t *scr_cursor_icon = NULL;
qboolean QDECL EZHud_MenuEvent(int eventtype, int keyparam, int unicodeparm, float mousecursor_x, float mousecursor_y, float vidwidth, float vidheight)
{
mouse_x += mousecursor_x - cursor_x; //FIXME: the hud editor should NOT need this sort of thing
mouse_y += mousecursor_y - cursor_y;
cursor_x = mousecursor_x;
cursor_y = mousecursor_y;
HUD_Editor_MouseEvent(cursor_x, cursor_y);
switch(eventtype)
{
case 0: //draw
host_screenupdatecount++;
HUD_Draw();
HUD_Editor_Draw();
mouse_x = 0;
mouse_y = 0;
break;
case 1:
if (keyparam < K_MAX)
keydown[keyparam] = true;
HUD_Editor_Key(keyparam, 0, true);
break;
case 2:
if (keyparam < K_MAX)
keydown[keyparam] = false;
HUD_Editor_Key(keyparam, 0, false);
break;
}
return 1;
}
qboolean Plug_Init(void)
{
drawfuncs = plugfuncs->GetEngineInterface(plug2dfuncs_name, sizeof(*drawfuncs));
clientfuncs = plugfuncs->GetEngineInterface(plugclientfuncs_name, sizeof(*clientfuncs));
filefuncs = plugfuncs->GetEngineInterface(plugfsfuncs_name, sizeof(*filefuncs));
inputfuncs = plugfuncs->GetEngineInterface(pluginputfuncs_name, sizeof(*inputfuncs));
plugfuncs->ExportFunction("UpdateVideo", EZHud_UpdateVideo);
if (cvarfuncs && drawfuncs && clientfuncs && filefuncs && inputfuncs &&
plugfuncs->ExportFunction("SbarBase", EZHud_Draw) &&
plugfuncs->ExportFunction("MenuEvent", EZHud_MenuEvent) &&
plugfuncs->ExportFunction("Tick", EZHud_Tick) &&
plugfuncs->ExportFunction("ExecuteCommand", EZHud_ExecuteCommand))
{
Cmd_AddCommand("ezhud_nquake", EZHud_UseNquake_f);
HUD_Init();
HUD_Editor_Init();
return true;
}
Con_Printf("EZHud: Unable to initiailise\n");
return false;
}