mirror of
https://github.com/nzp-team/fteqw.git
synced 2024-11-22 12:01:25 +00:00
3622 lines
109 KiB
C
3622 lines
109 KiB
C
#include "quakedef.h"
|
|
|
|
#include "pr_common.h"
|
|
#include "shader.h"
|
|
|
|
#ifdef GLQUAKE
|
|
#include "glquake.h"
|
|
#endif
|
|
|
|
#if defined(MENU_DAT) || defined(CSQC_DAT)
|
|
#include "cl_master.h"
|
|
|
|
//MP_MouseMove(mx, my, mouse->qdeviceid)
|
|
|
|
static qbyte mpkeysdown[K_MAX/8];
|
|
extern qboolean csqc_dp_lastwas3d;
|
|
|
|
void M_Init_Internal (void);
|
|
void M_DeInit_Internal (void);
|
|
|
|
extern unsigned int r2d_be_flags;
|
|
static unsigned int PF_SelectDPDrawFlag(pubprogfuncs_t *prinst, int flag)
|
|
{
|
|
if (r_refdef.warndraw)
|
|
{
|
|
if (!*r_refdef.rt_destcolour[0].texname)
|
|
{
|
|
r_refdef.warndraw = false; //don't spam too much
|
|
PR_RunWarning(prinst, "Detected attempt to draw to framebuffer where framebuffer is not valid\n");
|
|
}
|
|
}
|
|
#ifdef CSQC_DAT
|
|
csqc_dp_lastwas3d = false; //for compat with dp's stupid beginpolygon
|
|
#endif
|
|
|
|
//flags:
|
|
//0 = blend
|
|
//1 = add
|
|
//2 = modulate
|
|
//3 = modulate*2
|
|
flag &= 3;
|
|
if (flag == DRAWFLAG_ADD)
|
|
return BEF_FORCEADDITIVE;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
//float drawfill(vector position, vector size, vector rgb, float alpha, float flag) = #457;
|
|
void QCBUILTIN PF_CL_drawfill (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pos = G_VECTOR(OFS_PARM0);
|
|
float *size = G_VECTOR(OFS_PARM1);
|
|
float *rgb = G_VECTOR(OFS_PARM2);
|
|
float alpha = G_FLOAT(OFS_PARM3);
|
|
int flag = prinst->callargc >= 5?G_FLOAT(OFS_PARM4):0;
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flag);
|
|
R2D_ImageColours(rgb[0], rgb[1], rgb[2], alpha);
|
|
R2D_FillBlock(pos[0], pos[1], size[0], size[1]);
|
|
r2d_be_flags = 0;
|
|
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
}
|
|
//void drawsetcliparea(float x, float y, float width, float height) = #458;
|
|
void QCBUILTIN PF_CL_drawsetcliparea (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
srect_t srect;
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
|
|
#ifdef CSQC_DAT
|
|
csqc_dp_lastwas3d = false;
|
|
#endif
|
|
|
|
srect.x = G_FLOAT(OFS_PARM0) / (float)vid.fbvwidth;
|
|
srect.y = G_FLOAT(OFS_PARM1) / (float)vid.fbvheight;
|
|
srect.width = G_FLOAT(OFS_PARM2) / (float)vid.fbvwidth;
|
|
srect.height = G_FLOAT(OFS_PARM3) / (float)vid.fbvheight;
|
|
srect.dmin = -99999;
|
|
srect.dmax = 99999;
|
|
srect.y = (1-srect.y) - srect.height;
|
|
BE_Scissor(&srect);
|
|
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
}
|
|
//void drawresetcliparea(void) = #459;
|
|
void QCBUILTIN PF_CL_drawresetcliparea (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
|
|
#ifdef CSQC_DAT
|
|
csqc_dp_lastwas3d = false;
|
|
#endif
|
|
|
|
BE_Scissor(NULL);
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
}
|
|
|
|
#define FONT_SLOTS 32
|
|
#define FONT_SIZES 16
|
|
struct {
|
|
unsigned int owner; //kdm_foo. whoever has an interest in this font. font is purged when this becomes 0.
|
|
char slotname[16];
|
|
char facename[MAX_OSPATH];
|
|
float scale; //poop
|
|
int outline; //argh
|
|
unsigned int fontflags; //erk
|
|
int sizes;
|
|
int size[FONT_SIZES];
|
|
struct font_s *font[FONT_SIZES];
|
|
} fontslot[FONT_SLOTS];
|
|
|
|
static struct font_s *PR_CL_ChooseFont(float *fontsel, int szx, int szy)
|
|
{
|
|
int fontidx = 0; //default by default...
|
|
struct font_s *font = font_default;
|
|
|
|
if (fontsel)
|
|
{
|
|
fontidx = *fontsel;
|
|
}
|
|
|
|
if (fontidx >= 0 && fontidx < FONT_SLOTS)
|
|
{
|
|
int i, j;
|
|
int fontdiff = 10000;
|
|
for (i = 0; i < fontslot[fontidx].sizes; i++)
|
|
{
|
|
j = abs(szy - fontslot[fontidx].size[i]);
|
|
if (j < fontdiff && fontslot[fontidx].font[i])
|
|
{
|
|
fontdiff = j;
|
|
font = fontslot[fontidx].font[i];
|
|
}
|
|
}
|
|
}
|
|
return font;
|
|
}
|
|
void PR_CL_BeginString(pubprogfuncs_t *prinst, float vx, float vy, float szx, float szy, float *px, float *py)
|
|
{
|
|
world_t *world = prinst->parms->user;
|
|
struct font_s *font;
|
|
if (world->g.drawfontscale && (world->g.drawfontscale[0] || world->g.drawfontscale[1]))
|
|
{
|
|
szx *= world->g.drawfontscale[0];
|
|
szy *= world->g.drawfontscale[1];
|
|
}
|
|
font = PR_CL_ChooseFont(world->g.drawfont, szx, szy);
|
|
Font_BeginScaledString(font, vx, vy, szx, szy, px, py);
|
|
}
|
|
int PR_findnamedfont(const char *name, qboolean isslotname)
|
|
{
|
|
int i;
|
|
if (isslotname)
|
|
{
|
|
for (i = 0; i < FONT_SLOTS; i++)
|
|
{
|
|
if (!stricmp(fontslot[i].slotname, name))
|
|
return i;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (i = 0; i < FONT_SLOTS; i++)
|
|
{
|
|
if (!stricmp(fontslot[i].facename, name))
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
int PR_findunusedfont(void)
|
|
{
|
|
int i;
|
|
//don't find slot 0.
|
|
for (i = FONT_SLOTS; i-- > 1; )
|
|
{
|
|
if (!*fontslot[i].slotname && !*fontslot[i].facename)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
//purgeowner is the bitmask of owners that are getting freed.
|
|
//if purgeowner is 0, fonts will get purged
|
|
void PR_ReleaseFonts(unsigned int purgeowner)
|
|
{
|
|
int i, j;
|
|
|
|
for (i = 0; i < FONT_SLOTS; i++)
|
|
{
|
|
if (fontslot[i].owner)
|
|
continue; //already free
|
|
fontslot[i].owner &= ~purgeowner;
|
|
if (fontslot[i].owner)
|
|
continue; //still owned by someone
|
|
|
|
for (j = 0; j < fontslot[i].sizes; j++)
|
|
{
|
|
if (fontslot[i].font[j])
|
|
Font_Free(fontslot[i].font[j]);
|
|
fontslot[i].font[j] = NULL;
|
|
}
|
|
|
|
fontslot[i].sizes = 0;
|
|
fontslot[i].slotname[0] = '\0';
|
|
fontslot[i].facename[0] = '\0';
|
|
fontslot[i].scale = 1;
|
|
fontslot[i].outline = 0;
|
|
}
|
|
}
|
|
void PR_ReloadFonts(qboolean reload)
|
|
{
|
|
int i, j;
|
|
|
|
if (qrenderer == QR_NONE)
|
|
reload = false;
|
|
|
|
for (i = 0; i < FONT_SLOTS; i++)
|
|
{
|
|
//already not loaded
|
|
if (!fontslot[i].owner)
|
|
continue;
|
|
|
|
//flush it (if loaded)
|
|
for (j = 0; j < fontslot[i].sizes; j++)
|
|
{
|
|
if (fontslot[i].font[j])
|
|
Font_Free(fontslot[i].font[j]);
|
|
fontslot[i].font[j] = NULL;
|
|
}
|
|
//and reload if needed
|
|
if (reload)
|
|
{ //otherwise load it.
|
|
for (j = 0; j < fontslot[i].sizes; j++)
|
|
{
|
|
fontslot[i].font[j] = Font_LoadFont(fontslot[i].facename, fontslot[i].size[j], fontslot[i].scale, fontslot[i].outline, fontslot[i].fontflags);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void QCBUILTIN PF_CL_findfont (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *slotname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
G_FLOAT(OFS_RETURN) = PR_findnamedfont(slotname, true) + 1; //return default on failure.
|
|
}
|
|
void QCBUILTIN PF_CL_loadfont (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
extern cvar_t r_font_postprocess_outline;
|
|
const char *slotname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
const char *facename = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
const char *sizestr = PR_GetStringOfs(prinst, OFS_PARM2);
|
|
int slotnum = (prinst->callargc>3)?G_FLOAT(OFS_PARM3):-1;
|
|
//float fix_scale = (prinst->callargc>4)?G_FLOAT(OFS_PARM4):0;
|
|
//float fix_voffset = (prinst->callargc>5)G_FLOAT(OFS_PARM5):0;
|
|
int i, sz;
|
|
world_t *world = prinst->parms->user;
|
|
|
|
G_FLOAT(OFS_RETURN) = 0; //return default on failure.
|
|
|
|
if (slotnum < 0 && *slotname)
|
|
slotnum = PR_findnamedfont(slotname, true);
|
|
else if (slotnum < 0)
|
|
slotnum = PR_findnamedfont(facename, false);
|
|
if (slotnum < 0)
|
|
slotnum = PR_findunusedfont();
|
|
if (slotnum < 0)
|
|
return; //eep.
|
|
|
|
if ((unsigned)slotnum >= FONT_SLOTS)
|
|
return;
|
|
|
|
//if its changed, purge it.
|
|
if (stricmp(fontslot[slotnum].slotname, slotname) || stricmp(fontslot[slotnum].facename, facename) || !fontslot[slotnum].sizes)
|
|
{
|
|
Q_strncpyz(fontslot[slotnum].slotname, slotname, sizeof(fontslot[slotnum].slotname));
|
|
Q_strncpyz(fontslot[slotnum].facename, facename, sizeof(fontslot[slotnum].facename));
|
|
for (i = 0; i < fontslot[slotnum].sizes; i++)
|
|
{
|
|
if (fontslot[slotnum].font[i])
|
|
Font_Free(fontslot[slotnum].font[i]);
|
|
fontslot[slotnum].font[i] = NULL;
|
|
}
|
|
fontslot[slotnum].sizes = 0;
|
|
fontslot[slotnum].owner = 0;
|
|
fontslot[slotnum].scale = 1;
|
|
fontslot[slotnum].outline = r_font_postprocess_outline.ival;
|
|
}
|
|
fontslot[slotnum].owner |= world->keydestmask;
|
|
|
|
while(*sizestr)
|
|
{
|
|
sizestr = COM_Parse(sizestr);
|
|
if (!strncmp(com_token, "scale=", 6))
|
|
{
|
|
fontslot[slotnum].scale = atof(com_token+6);
|
|
continue;
|
|
}
|
|
if (!strncmp(com_token, "outline=", 8))
|
|
{
|
|
fontslot[slotnum].outline = atoi(com_token+8);
|
|
continue;
|
|
}
|
|
if (!strncmp(com_token, "blur=", 5))
|
|
{
|
|
//fontslot[slotnum].blur = atoi(com_token+5);
|
|
continue;
|
|
}
|
|
if (!strncmp(com_token, "voffset=", 8))
|
|
{
|
|
//com_token+8 unused.
|
|
continue;
|
|
}
|
|
|
|
sz = atoi(com_token);
|
|
if (!sz)
|
|
continue; //o.O
|
|
|
|
for (i = 0; i < fontslot[slotnum].sizes; i++)
|
|
{
|
|
if (fontslot[slotnum].size[i] == sz)
|
|
break;
|
|
}
|
|
if (i == fontslot[slotnum].sizes)
|
|
{
|
|
if (i >= FONT_SIZES)
|
|
break;
|
|
fontslot[slotnum].size[i] = sz;
|
|
fontslot[slotnum].font[i] = NULL;
|
|
fontslot[slotnum].sizes++;
|
|
}
|
|
}
|
|
|
|
if (qrenderer > QR_NONE)
|
|
{
|
|
for (i = 0; i < fontslot[slotnum].sizes; i++)
|
|
fontslot[slotnum].font[i] = Font_LoadFont(facename, fontslot[slotnum].size[i], fontslot[slotnum].scale, fontslot[slotnum].outline, fontslot[slotnum].fontflags);
|
|
}
|
|
|
|
G_FLOAT(OFS_RETURN) = slotnum;
|
|
}
|
|
|
|
#ifdef HAVE_LEGACY
|
|
void CL_LoadFont_f(void)
|
|
{
|
|
extern cvar_t r_font_postprocess_outline, r_font_postprocess_mono;
|
|
//console command for compat with dp/debug.
|
|
if (Cmd_Argc() == 1)
|
|
{
|
|
int i, j;
|
|
int th;
|
|
for (i = 0; i < FONT_SLOTS; i++)
|
|
{
|
|
if (fontslot[i].sizes)
|
|
{
|
|
Con_Printf("%s[%i]: %s (", fontslot[i].slotname, i, fontslot[i].facename);
|
|
for (j = 0; j < fontslot[i].sizes; j++)
|
|
{
|
|
if (j)
|
|
Con_Printf(", ");
|
|
Con_Printf("%i", fontslot[i].size[j]);
|
|
if (fontslot[i].font[j])
|
|
{
|
|
th = Font_GetTrueHeight(fontslot[i].font[j]);
|
|
if (th != Font_CharPHeight(fontslot[i].font[j]))
|
|
Con_Printf("[%g]", ((float)th*vid.height)/vid.pixelheight);
|
|
}
|
|
}
|
|
Con_Printf(")\n");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int i;
|
|
int slotnum = 0;
|
|
char *slotname = Cmd_Argv(1);
|
|
char *facename = Cmd_Argv(2);
|
|
int sizenum = 3;
|
|
extern cvar_t dpcompat_console, gl_font, con_textfont;
|
|
|
|
//loadfont slot face size1 size2...
|
|
|
|
slotnum = PR_findnamedfont(slotname, true);
|
|
if (slotnum < 0)
|
|
{
|
|
char *dpnames[] = {"default", "console", "sbar", "notify", "chat", "centerprint", "infobar", "menu", "user0", "user1", "user2", "user3", "user4", "user5", "user6", "user7", NULL};
|
|
for (i = 0; dpnames[i]; i++)
|
|
{
|
|
if (!strcmp(dpnames[i], slotname))
|
|
{
|
|
//assign it to this slot only if this slot does not already have a face. avoids corrupting already-loaded fonts.
|
|
if (!*fontslot[i].facename)
|
|
slotnum = i;
|
|
break;
|
|
}
|
|
}
|
|
if (slotnum < 0)
|
|
slotnum = PR_findnamedfont("", true); //whatever is still free
|
|
}
|
|
if (slotnum < 0)
|
|
{
|
|
Con_Printf("out of font slots\n");
|
|
return;
|
|
}
|
|
|
|
//if there's a new font in this slot, purge the old and change the name+face strings
|
|
if (stricmp(fontslot[slotnum].slotname, slotname) || stricmp(fontslot[slotnum].facename, facename))
|
|
{
|
|
Q_strncpyz(fontslot[slotnum].slotname, slotname, sizeof(fontslot[slotnum].slotname));
|
|
Q_strncpyz(fontslot[slotnum].facename, facename, sizeof(fontslot[slotnum].facename));
|
|
for (i = 0; i < fontslot[slotnum].sizes; i++)
|
|
{
|
|
if (fontslot[slotnum].font[i])
|
|
Font_Free(fontslot[slotnum].font[i]);
|
|
fontslot[slotnum].font[i] = NULL;
|
|
}
|
|
fontslot[slotnum].owner = 0;
|
|
fontslot[slotnum].scale = 1;
|
|
fontslot[slotnum].sizes = 0;
|
|
fontslot[slotnum].outline = r_font_postprocess_outline.ival; //locked in at definition, so different fonts can have different settings even with vid_reload going on.
|
|
fontslot[slotnum].fontflags = 0 |
|
|
(r_font_postprocess_mono.ival?FONT_MONO:0);
|
|
}
|
|
if (!*facename)
|
|
return;
|
|
fontslot[slotnum].owner |= kdm_console; //fonts owned by the console are never forgotten.
|
|
|
|
while(sizenum < Cmd_Argc())
|
|
{
|
|
const char *a = Cmd_Argv(sizenum++);
|
|
int sz;
|
|
if (!strcmp(a, "scale"))
|
|
{
|
|
fontslot[slotnum].scale = atof(Cmd_Argv(sizenum++));
|
|
continue;
|
|
}
|
|
if (!strcmp(a, "outline"))
|
|
{
|
|
fontslot[slotnum].outline = atoi(Cmd_Argv(sizenum++));
|
|
continue;
|
|
}
|
|
if (!strcmp(a, "mono"))
|
|
{
|
|
if (atoi(Cmd_Argv(sizenum++)))
|
|
fontslot[slotnum].fontflags |= FONT_MONO;
|
|
else
|
|
fontslot[slotnum].fontflags &= ~FONT_MONO;
|
|
continue;
|
|
}
|
|
if (!strcmp(a, "blur"))
|
|
{
|
|
//fontslot[slotnum].blur = atoi(Cmd_Argv(sizenum++));
|
|
sizenum++;
|
|
continue;
|
|
}
|
|
if (!strcmp(a, "voffset"))
|
|
{
|
|
// fontslot[slotnum].voffset = atof(Cmd_Argv(sizenum++));
|
|
sizenum++;
|
|
continue;
|
|
}
|
|
sz = atoi(a);
|
|
if (sz <= 0)
|
|
sz = 8;
|
|
|
|
for (i = 0; i < fontslot[slotnum].sizes; i++)
|
|
{
|
|
if (fontslot[slotnum].size[i] == sz)
|
|
break;
|
|
}
|
|
if (i == fontslot[slotnum].sizes)
|
|
{
|
|
if (i >= FONT_SIZES)
|
|
break;
|
|
fontslot[slotnum].size[i] = sz;
|
|
fontslot[slotnum].font[i] = NULL;
|
|
fontslot[slotnum].sizes++;
|
|
}
|
|
}
|
|
|
|
if (qrenderer > QR_NONE)
|
|
{
|
|
for (i = 0; i < fontslot[slotnum].sizes; i++)
|
|
fontslot[slotnum].font[i] = Font_LoadFont(facename, fontslot[slotnum].size[i], fontslot[slotnum].scale, fontslot[slotnum].outline, fontslot[slotnum].fontflags);
|
|
}
|
|
|
|
//FIXME: slotnum0==default is problematic.
|
|
if (dpcompat_console.ival && slotnum == 1)
|
|
Cvar_Set(&con_textfont, facename);
|
|
if (dpcompat_console.ival && slotnum == 0)
|
|
Cvar_Set(&gl_font, facename);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//scrolling could be done with scissoring.
|
|
//selection could be done with some substrings
|
|
void QCBUILTIN PF_CL_DrawTextField (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pos = G_VECTOR(OFS_PARM0);
|
|
float *size = G_VECTOR(OFS_PARM1);
|
|
unsigned int flags = G_FLOAT(OFS_PARM2);
|
|
const char *text = PR_GetStringOfs(prinst, OFS_PARM3);
|
|
|
|
world_t *world = prinst->parms->user;
|
|
vec2_t scale = {8, 8};
|
|
struct font_s *font;
|
|
if (world->g.drawfontscale && (world->g.drawfontscale[0] || world->g.drawfontscale[1]))
|
|
{
|
|
scale[0] *= world->g.drawfontscale[0];
|
|
scale[1] *= world->g.drawfontscale[1];
|
|
}
|
|
font = PR_CL_ChooseFont(world->g.drawfont, scale[0], scale[1]);
|
|
|
|
// Oversight ~eukara
|
|
R2D_ImageColours(1.0f, 1.0f, 1.0f, 1.0f);
|
|
|
|
G_FLOAT(OFS_RETURN) = R_DrawTextField(pos[0], pos[1], size[0], size[1], text, CON_WHITEMASK, flags, font, scale);
|
|
}
|
|
|
|
//float drawstring(vector position, string text, vector scale, float alpha, float flag) = #455;
|
|
void QCBUILTIN PF_CL_drawcolouredstring (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pos = G_VECTOR(OFS_PARM0);
|
|
const char *text = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
float *size = G_VECTOR(OFS_PARM2);
|
|
float alpha = 0;
|
|
float flag = 0;
|
|
float r, g, b;
|
|
float px, py, ipx;
|
|
unsigned int codeflags, codepoint;
|
|
|
|
conchar_t buffer[2048], *str;
|
|
|
|
if (prinst->callargc >= 6)
|
|
{
|
|
r = G_FLOAT(OFS_PARM3 + 0);
|
|
g = G_FLOAT(OFS_PARM3 + 1);
|
|
b = G_FLOAT(OFS_PARM3 + 2);
|
|
alpha = G_FLOAT(OFS_PARM4);
|
|
flag = G_FLOAT(OFS_PARM5); //flag is mandatory to distinguish it.
|
|
}
|
|
else
|
|
{
|
|
r = 1;
|
|
g = 1;
|
|
b = 1;
|
|
alpha = G_FLOAT(OFS_PARM3);
|
|
flag = prinst->callargc >= 5?G_FLOAT(OFS_PARM4):0;
|
|
}
|
|
|
|
if (!text)
|
|
{
|
|
G_FLOAT(OFS_RETURN) = -1; //was null..
|
|
return;
|
|
}
|
|
|
|
COM_ParseFunString(CON_WHITEMASK, text, buffer, sizeof(buffer), false);
|
|
str = buffer;
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flag);
|
|
PR_CL_BeginString(prinst, pos[0], pos[1], size[0], size[1], &px, &py);
|
|
ipx = px;
|
|
R2D_ImageColours(r, g, b, alpha);
|
|
while(*str)
|
|
{
|
|
str = Font_Decode(str, &codeflags, &codepoint);
|
|
if (codeflags & CON_HIDDEN)
|
|
continue;
|
|
if (codepoint == '\n')
|
|
py += Font_CharHeight();
|
|
else if (codepoint == '\r')
|
|
px = ipx;
|
|
else
|
|
px = Font_DrawScaleChar(px, py, codeflags, codepoint);
|
|
}
|
|
R2D_ImageColours(1,1,1,1);
|
|
Font_EndString(NULL);
|
|
r2d_be_flags = 0;
|
|
}
|
|
|
|
void QCBUILTIN PF_CL_stringwidth(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
conchar_t buffer[2048], *end;
|
|
float px, py;
|
|
const char *text = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
int usecolours = G_FLOAT(OFS_PARM1);
|
|
float *size = (prinst->callargc > 2)?G_VECTOR(OFS_PARM2):NULL;
|
|
|
|
if (!qrenderer)
|
|
{
|
|
G_FLOAT(OFS_RETURN) = 0;
|
|
return;
|
|
}
|
|
|
|
end = COM_ParseFunString(CON_WHITEMASK, text, buffer, sizeof(buffer), !usecolours);
|
|
|
|
PR_CL_BeginString(prinst, 0, 0, size?size[0]:8, size?size[1]:8, &px, &py);
|
|
px = Font_LineScaleWidth(buffer, end);
|
|
Font_EndString(NULL);
|
|
|
|
if (!size) //for compat with dp, divide by 8 after... because weird.
|
|
px /= 8;
|
|
|
|
G_FLOAT(OFS_RETURN) = (px * vid.width) / vid.rotpixelwidth;
|
|
}
|
|
|
|
//float drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag) = #456;
|
|
void QCBUILTIN PF_CL_drawpic (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pos = G_VECTOR(OFS_PARM0);
|
|
const char *picname = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
float *size = G_VECTOR(OFS_PARM2);
|
|
float *rgb = G_VECTOR(OFS_PARM3);
|
|
float alpha = G_FLOAT(OFS_PARM4);
|
|
int flag = prinst->callargc >= 6?(int)G_FLOAT(OFS_PARM5):0;
|
|
|
|
mpic_t *p;
|
|
|
|
p = R2D_SafeCachePic(picname);
|
|
if (!p || !R_GetShaderSizes(p, NULL, NULL, false))
|
|
p = R2D_SafePicFromWad(picname);
|
|
|
|
if (!p)
|
|
{
|
|
if (!CL_IsDownloading(picname))
|
|
p = R2D_SafeCachePic("no_texture");
|
|
G_FLOAT(OFS_RETURN) = 0;
|
|
}
|
|
else
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flag);
|
|
R2D_ImageColours(rgb[0], rgb[1], rgb[2], alpha);
|
|
if ((size[0] < 0) ^ (size[1] < 0))
|
|
R2D_Image(pos[0]+size[0], pos[1]+size[1], -size[0], -size[1], 1, 1, 0, 0, p);
|
|
else
|
|
R2D_Image(pos[0], pos[1], size[0], size[1], 0, 0, 1, 1, p);
|
|
r2d_be_flags = 0;
|
|
}
|
|
|
|
void QCBUILTIN PF_CL_drawrotpic (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pivot = G_VECTOR(OFS_PARM0);
|
|
float *mins = G_VECTOR(OFS_PARM1);
|
|
float *maxs = G_VECTOR(OFS_PARM2);
|
|
const char *picname = PR_GetStringOfs(prinst, OFS_PARM3);
|
|
float *rgb = G_VECTOR(OFS_PARM4);
|
|
float alpha = G_FLOAT(OFS_PARM5);
|
|
float angle = (G_FLOAT(OFS_PARM6) * M_PI)/180;
|
|
int flag = prinst->callargc >= 8?(int) G_FLOAT(OFS_PARM7):0;
|
|
|
|
vec2_t points[4];
|
|
vec2_t tcoords[4];
|
|
vec2_t saxis;
|
|
vec2_t taxis;
|
|
|
|
mpic_t *p;
|
|
|
|
p = R2D_SafeCachePic(picname);
|
|
if (!p)
|
|
p = R2D_SafePicFromWad(picname);
|
|
|
|
saxis[0] = cos(angle);
|
|
saxis[1] = sin(angle);
|
|
taxis[0] = -sin(angle);
|
|
taxis[1] = cos(angle);
|
|
|
|
Vector2MA(pivot, mins[0], saxis, points[0]); Vector2MA(points[0], mins[1], taxis, points[0]);
|
|
Vector2MA(pivot, maxs[0], saxis, points[1]); Vector2MA(points[1], mins[1], taxis, points[1]);
|
|
Vector2MA(pivot, maxs[0], saxis, points[2]); Vector2MA(points[2], maxs[1], taxis, points[2]);
|
|
Vector2MA(pivot, mins[0], saxis, points[3]); Vector2MA(points[3], maxs[1], taxis, points[3]);
|
|
|
|
Vector2Set(tcoords[0], 0, 0);
|
|
Vector2Set(tcoords[1], 1, 0);
|
|
Vector2Set(tcoords[2], 1, 1);
|
|
Vector2Set(tcoords[3], 0, 1);
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flag);
|
|
R2D_ImageColours(rgb[0], rgb[1], rgb[2], alpha);
|
|
R2D_Image2dQuad((const vec2_t*)points, (const vec2_t*)tcoords, NULL, p);
|
|
r2d_be_flags = 0;
|
|
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
}
|
|
|
|
void QCBUILTIN PF_CL_drawsubpic (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pos = G_VECTOR(OFS_PARM0);
|
|
float *size = G_VECTOR(OFS_PARM1);
|
|
const char *picname = PR_GetStringOfs(prinst, OFS_PARM2);
|
|
float *srcPos = G_VECTOR(OFS_PARM3);
|
|
float *srcSize = G_VECTOR(OFS_PARM4);
|
|
float *rgb = G_VECTOR(OFS_PARM5);
|
|
float alpha = G_FLOAT(OFS_PARM6);
|
|
int flag = prinst->callargc >= 8?(int) G_FLOAT(OFS_PARM7):0;
|
|
|
|
mpic_t *p;
|
|
|
|
p = R2D_SafeCachePic(picname);
|
|
if (!p || !R_GetShaderSizes(p, NULL, NULL, false))
|
|
p = R2D_SafePicFromWad(picname);
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flag);
|
|
R2D_ImageColours(rgb[0], rgb[1], rgb[2], alpha);
|
|
if ((size[0] < 0) ^ (size[1] < 0))
|
|
R2D_Image(pos[0]+size[0], pos[1]+size[1], -size[0], -size[1], srcPos[0]+srcSize[0], srcPos[1]+srcSize[1], srcPos[0], srcPos[1], p);
|
|
else
|
|
R2D_Image(pos[0], pos[1], size[0], size[1], srcPos[0], srcPos[1], srcPos[0]+srcSize[0], srcPos[1]+srcSize[1], p);
|
|
r2d_be_flags = 0;
|
|
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
}
|
|
void QCBUILTIN PF_CL_drawrotsubpic (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pivot = G_VECTOR(OFS_PARM0);
|
|
float *mins = G_VECTOR(OFS_PARM1);
|
|
float *maxs = G_VECTOR(OFS_PARM2);
|
|
const char *picname = PR_GetStringOfs(prinst, OFS_PARM3);
|
|
float *srcPos = G_VECTOR(OFS_PARM4);
|
|
float *srcSize = G_VECTOR(OFS_PARM5);
|
|
float *rgb = G_VECTOR(OFS_PARM6);
|
|
float alpha = G_FLOAT(OFS_PARM7+0);
|
|
float angle = (G_FLOAT(OFS_PARM7+1) * M_PI) / 180;
|
|
int flag = prinst->callargc >= 8?(int) G_FLOAT(OFS_PARM7+2):0;
|
|
vec2_t points[4], tcoords[4];
|
|
vec2_t saxis;
|
|
vec2_t taxis;
|
|
|
|
mpic_t *p;
|
|
|
|
saxis[0] = cos(angle);
|
|
saxis[1] = sin(angle);
|
|
taxis[0] = -sin(angle);
|
|
taxis[1] = cos(angle);
|
|
|
|
p = R2D_SafeCachePic(picname);
|
|
if (!p)
|
|
p = R2D_SafePicFromWad(picname);
|
|
|
|
Vector2MA(pivot, mins[0], saxis, points[0]); Vector2MA(points[0], mins[1], taxis, points[0]);
|
|
Vector2MA(pivot, maxs[0], saxis, points[1]); Vector2MA(points[1], mins[1], taxis, points[1]);
|
|
Vector2MA(pivot, maxs[0], saxis, points[2]); Vector2MA(points[2], maxs[1], taxis, points[2]);
|
|
Vector2MA(pivot, mins[0], saxis, points[3]); Vector2MA(points[3], maxs[1], taxis, points[3]);
|
|
|
|
Vector2Set(tcoords[0], srcPos[0] , srcPos[1] );
|
|
Vector2Set(tcoords[1], srcPos[0]+srcSize[0] , srcPos[1] );
|
|
Vector2Set(tcoords[2], srcPos[0]+srcSize[0] , srcPos[1]+srcSize[1] );
|
|
Vector2Set(tcoords[3], srcPos[0] , srcPos[1]+srcSize[1] );
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flag);
|
|
R2D_ImageColours(rgb[0], rgb[1], rgb[2], alpha);
|
|
R2D_Image2dQuad((const vec2_t*)points, (const vec2_t*)tcoords, NULL, p);
|
|
r2d_be_flags = 0;
|
|
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
}
|
|
|
|
#ifdef HAVE_LEGACY
|
|
/*fuck sake, why does no one give a shit about existing extension?!? seriously this stuff is pissing me off*/
|
|
void QCBUILTIN PF_CL_drawrotpic_dp (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pivot = G_VECTOR(OFS_PARM0);
|
|
const char *picname = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
float *size = G_VECTOR(OFS_PARM2);
|
|
float *mins = G_VECTOR(OFS_PARM3);
|
|
float angle = (G_FLOAT(OFS_PARM4) * M_PI)/180;
|
|
float *rgb = G_VECTOR(OFS_PARM5);
|
|
float alpha = G_FLOAT(OFS_PARM6);
|
|
int flag = prinst->callargc >= 8?(int) G_FLOAT(OFS_PARM7):0;
|
|
|
|
vec3_t maxs;
|
|
|
|
vec2_t points[4];
|
|
vec2_t tcoords[4];
|
|
vec2_t saxis;
|
|
vec2_t taxis;
|
|
|
|
mpic_t *p;
|
|
|
|
VectorSubtract(size, mins, maxs);
|
|
|
|
p = R2D_SafeCachePic(picname);
|
|
if (!p)
|
|
p = R2D_SafePicFromWad(picname);
|
|
|
|
saxis[0] = cos(angle);
|
|
saxis[1] = sin(angle);
|
|
taxis[0] = -sin(angle);
|
|
taxis[1] = cos(angle);
|
|
|
|
Vector2MA(pivot, mins[0], saxis, points[0]); Vector2MA(points[0], mins[1], taxis, points[0]);
|
|
Vector2MA(pivot, maxs[0], saxis, points[1]); Vector2MA(points[1], mins[1], taxis, points[1]);
|
|
Vector2MA(pivot, maxs[0], saxis, points[2]); Vector2MA(points[2], maxs[1], taxis, points[2]);
|
|
Vector2MA(pivot, mins[0], saxis, points[3]); Vector2MA(points[3], maxs[1], taxis, points[3]);
|
|
|
|
Vector2Set(tcoords[0], 0, 0);
|
|
Vector2Set(tcoords[1], 1, 0);
|
|
Vector2Set(tcoords[2], 1, 1);
|
|
Vector2Set(tcoords[3], 0, 1);
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flag);
|
|
R2D_ImageColours(rgb[0], rgb[1], rgb[2], alpha);
|
|
R2D_Image2dQuad((const vec2_t*)points, (const vec2_t*)tcoords, NULL, p);
|
|
r2d_be_flags = 0;
|
|
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
}
|
|
#endif
|
|
|
|
|
|
void QCBUILTIN PF_CL_is_cached_pic (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *str;
|
|
str = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
G_FLOAT(OFS_RETURN) = !!R_RegisterCustom(NULL, str, SUF_2D, NULL, NULL);
|
|
}
|
|
|
|
void QCBUILTIN PF_CL_precache_pic (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
extern cvar_t pr_precachepic_slow;
|
|
const char *str;
|
|
mpic_t *pic;
|
|
unsigned int flags;
|
|
#define PIC_FROMWAD 1 /*obsolete, probably better to just use gfx/foo.lmp instead*/
|
|
//#define PIC_TEMPORARY 2 /*DP, not meaningful here*/
|
|
//#define PIC_NOCLAMP 4 /*DP, not useful here - use a shader instead*/
|
|
//#define PIC_MIPMAP 8 /*DP, not useful here - use a shader instead*/
|
|
#define PRECACHE_PIC_DOWNLOAD 256 /*block until loaded, downloading if missing*/
|
|
#define PRECACHE_PIC_TEST 512 /*block until loaded*/
|
|
|
|
G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
|
|
str = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
if (prinst->callargc > 1)
|
|
flags = G_FLOAT(OFS_PARM1);
|
|
else
|
|
flags = 0;
|
|
|
|
if (pr_precachepic_slow.ival)
|
|
flags |= PRECACHE_PIC_DOWNLOAD|PRECACHE_PIC_TEST;
|
|
|
|
if (flags & PIC_FROMWAD)
|
|
pic = R2D_SafePicFromWad(str);
|
|
else
|
|
{
|
|
pic = R2D_SafeCachePic(str);
|
|
|
|
if ((flags & PRECACHE_PIC_DOWNLOAD) && cls.state //if we're allowed to download it...
|
|
&& strchr(str, '.') //only try to download it if it looks as though it contains a path.
|
|
#ifndef CLIENTONLY
|
|
&& !sv.active //not if we're already the server...
|
|
#endif
|
|
&& (!pic || !R_GetShaderSizes(pic, NULL, NULL, true))) //and it wasn't loaded...
|
|
CL_CheckOrEnqueDownloadFile(str, str, 0);
|
|
}
|
|
|
|
if (flags & PRECACHE_PIC_TEST)
|
|
if (!pic || !R_GetShaderSizes(pic, NULL, NULL, true))
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
|
|
#ifdef CSQC_DAT
|
|
//warning: not threaded.
|
|
void QCBUILTIN PF_CL_uploadimage (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *imagename = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
int width = G_INT(OFS_PARM1);
|
|
int height = G_INT(OFS_PARM2);
|
|
int src = G_INT(OFS_PARM3); //ptr
|
|
int size = (prinst->callargc > 4)?G_INT(OFS_PARM4):(width * height * 4);
|
|
uploadfmt_t format = (prinst->callargc > 5)?PR_TranslateTextureFormat(G_INT(OFS_PARM5)):TF_RGBA32;
|
|
void *imgptr;
|
|
texid_t tid;
|
|
|
|
G_INT(OFS_RETURN) = 0; //assume the worst
|
|
|
|
if (width < 0 || height < 0 || width > 16384 || height > 16384)
|
|
{ //this is actually kinda likely when everyone assumes everything is a float.
|
|
PR_BIError(prinst, "PF_CL_uploadimage: dimensions are out of range\n");
|
|
return;
|
|
}
|
|
//FIXME: this should use a proper qclib function to validate more reliably / reusably
|
|
if (src <= 0 || src+size >= prinst->stringtablesize)
|
|
{
|
|
PR_BIError(prinst, "PF_CL_uploadimage: invalid source\n");
|
|
return;
|
|
}
|
|
imgptr = prinst->stringtable + src;
|
|
|
|
|
|
tid = Image_FindTexture(imagename, NULL, RT_IMAGEFLAGS);
|
|
if (!TEXVALID(tid))
|
|
tid = Image_CreateTexture(imagename, NULL, RT_IMAGEFLAGS);
|
|
|
|
if (!format)
|
|
{
|
|
void *data = BZ_Malloc(size);
|
|
memcpy(data, imgptr, size);
|
|
G_INT(OFS_RETURN) = Image_LoadTextureFromMemory(tid, tid->flags, tid->ident, imagename, data, size);
|
|
}
|
|
else
|
|
{
|
|
unsigned int blockbytes, blockwidth, blockheight, blockdepth;
|
|
//get format info
|
|
Image_BlockSizeForEncoding(format, &blockbytes, &blockwidth, &blockheight, &blockdepth);
|
|
//round up as appropriate
|
|
blockwidth = ((width+blockwidth-1)/blockwidth)*blockwidth;
|
|
blockheight = ((height+blockheight-1)/blockheight)*blockheight;
|
|
if (size != blockwidth*blockheight*blockbytes)
|
|
G_INT(OFS_RETURN) = 0; //size isn't right. which means the pointer might be invalid too.
|
|
else
|
|
{
|
|
Image_Upload(tid, format, imgptr, NULL, width, height, 1, RT_IMAGEFLAGS);
|
|
tid->width = width;
|
|
tid->height = height;
|
|
G_INT(OFS_RETURN) = 1;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//warning: not threadable. hopefully noone abuses it.
|
|
void QCBUILTIN PF_CL_readimage (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
size_t filesize;
|
|
const char *filename = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
|
|
int imagewidth, imageheight;
|
|
uploadfmt_t format;
|
|
void *filedata;
|
|
|
|
G_INT(OFS_RETURN) = 0; //assume the worst
|
|
G_INT(OFS_PARM1) = 0; //out width
|
|
G_INT(OFS_PARM2) = 0; //out height
|
|
G_INT(OFS_PARM3) = 0; //out format
|
|
|
|
filedata = FS_LoadMallocFile(filename, &filesize);
|
|
|
|
if (filedata)
|
|
{
|
|
qbyte *imagedata = ReadRawImageFile(filedata, filesize, &imagewidth, &imageheight, &format, true, filename);
|
|
Z_Free(filedata);
|
|
|
|
if (imagedata)
|
|
{
|
|
void *ptr = prinst->AddressableAlloc(prinst, imagewidth*imageheight*4);
|
|
if (ptr)
|
|
{
|
|
memcpy(ptr, imagedata, imagewidth*imageheight*4);
|
|
G_INT(OFS_RETURN) = (char*)ptr - prinst->stringtable;
|
|
G_INT(OFS_PARM1) = imagewidth; //out width
|
|
G_INT(OFS_PARM2) = imageheight; //out height
|
|
G_INT(OFS_PARM3) = PR_UnTranslateTextureFormat(format); //out format...
|
|
}
|
|
BZ_Free(imagedata);
|
|
}
|
|
}
|
|
}
|
|
|
|
void QCBUILTIN PF_CL_free_pic (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//we don't support this, as the shader could be used elsewhere also, and we have pointers to things.
|
|
/*
|
|
char *str;
|
|
str = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
R_UnloadShader(R_RegisterCustom(str, NULL, NULL));
|
|
*/
|
|
}
|
|
|
|
//float drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag) = #454;
|
|
void QCBUILTIN PF_CL_drawcharacter (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pos = G_VECTOR(OFS_PARM0);
|
|
int chara = G_FLOAT(OFS_PARM1);
|
|
float *size = G_VECTOR(OFS_PARM2);
|
|
float *rgb = G_VECTOR(OFS_PARM3);
|
|
float alpha = G_FLOAT(OFS_PARM4);
|
|
int flag = prinst->callargc >= 6?G_FLOAT(OFS_PARM5):0;
|
|
|
|
float x, y;
|
|
|
|
if (!chara)
|
|
{
|
|
G_FLOAT(OFS_RETURN) = -1; //was null..
|
|
return;
|
|
}
|
|
|
|
//no control chars. use quake ones if so
|
|
if (!(flag & 4) && !com_parseutf8.ival)
|
|
{
|
|
//ugly quake chars...
|
|
if (chara >= 32 && chara < 128)
|
|
; //ascii-comptaible range
|
|
else
|
|
chara |= 0xe000; //use quake glyphs (including for red text, unfortunately)
|
|
}
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flag);
|
|
PR_CL_BeginString(prinst, pos[0], pos[1], size[0], size[1], &x, &y);
|
|
R2D_ImageColours(rgb[0], rgb[1], rgb[2], alpha);
|
|
Font_DrawScaleChar(x, y, CON_WHITEMASK, chara);
|
|
R2D_ImageColours(1,1,1,1);
|
|
Font_EndString(NULL);
|
|
r2d_be_flags = 0;
|
|
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
}
|
|
|
|
//float drawrawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag) = #455;
|
|
void QCBUILTIN PF_CL_drawrawstring (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *pos = G_VECTOR(OFS_PARM0);
|
|
const char *text = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
float *size = G_VECTOR(OFS_PARM2);
|
|
float *rgb = G_VECTOR(OFS_PARM3);
|
|
float alpha = G_FLOAT(OFS_PARM4);
|
|
int flag = prinst->callargc >= 6?G_FLOAT(OFS_PARM5):0;
|
|
float x, y;
|
|
unsigned int c;
|
|
int error;
|
|
|
|
if (!text)
|
|
{
|
|
G_FLOAT(OFS_RETURN) = -1; //was null..
|
|
return;
|
|
}
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flag);
|
|
PR_CL_BeginString(prinst, pos[0], pos[1], size[0], size[1], &x, &y);
|
|
R2D_ImageColours(rgb[0], rgb[1], rgb[2], alpha);
|
|
|
|
while(*text)
|
|
{
|
|
if (1)//VMUTF8)
|
|
c = unicode_decode(&error, text, &text, false);
|
|
else
|
|
{
|
|
//FIXME: which charset is this meant to be using?
|
|
//quakes? 8859-1? utf8? some weird hacky mixture?
|
|
c = *text++&0xff;
|
|
if ((c&0x7f) < 32)
|
|
c |= 0xe000; //if its a control char, just use the quake range instead.
|
|
else if (c & 0x80)
|
|
c |= 0xe000; //if its a high char, just use the quake range instead. we could colour it, but why bother
|
|
}
|
|
x = Font_DrawScaleChar(x, y, CON_WHITEMASK, c);
|
|
}
|
|
R2D_ImageColours(1,1,1,1);
|
|
Font_EndString(NULL);
|
|
r2d_be_flags = 0;
|
|
}
|
|
|
|
//void (float width, vector pos1, vector pos2, vector rgb, float alpha, optional float flags) drawline;
|
|
void QCBUILTIN PF_CL_drawline (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//float width = G_FLOAT(OFS_PARM0);
|
|
float *point1 = G_VECTOR(OFS_PARM1);
|
|
float *point2 = G_VECTOR(OFS_PARM2);
|
|
float *rgb = G_VECTOR(OFS_PARM3);
|
|
float alpha = G_FLOAT(OFS_PARM4);
|
|
int flags = prinst->callargc >= 6?G_FLOAT(OFS_PARM5):0;
|
|
shader_t *shader_draw_line;
|
|
|
|
//this shader lookup might get pricy.
|
|
shader_draw_line = R_RegisterShader("shader_draw_line", SUF_NONE,
|
|
"{\n"
|
|
"program defaultfill\n"
|
|
"{\n"
|
|
"map $whiteimage\n"
|
|
"rgbgen exactvertex\n"
|
|
"alphagen vertex\n"
|
|
"blendfunc blend\n"
|
|
"}\n"
|
|
"}\n");
|
|
|
|
r2d_be_flags = PF_SelectDPDrawFlag(prinst, flags);
|
|
R2D_ImageColours(rgb[0], rgb[1], rgb[2], alpha);
|
|
R2D_Line(point1[0], point1[1], point2[0], point2[1], shader_draw_line);
|
|
R2D_ImageColours(1,1,1,1);
|
|
r2d_be_flags = 0;
|
|
}
|
|
|
|
//vector drawgetimagesize(string pic) = #460;
|
|
void QCBUILTIN PF_CL_drawgetimagesize (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *picname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
mpic_t *p = R2D_SafeCachePic(picname);
|
|
|
|
float *ret = G_VECTOR(OFS_RETURN);
|
|
int iw, ih;
|
|
|
|
if (R_GetShaderSizes(p, &iw, &ih, true) > 0)
|
|
{
|
|
ret[0] = iw;
|
|
ret[1] = ih;
|
|
ret[2] = 0;
|
|
}
|
|
else
|
|
{
|
|
ret[0] = 0;
|
|
ret[1] = 0;
|
|
ret[2] = 0;
|
|
}
|
|
}
|
|
|
|
//vector getmousepos(void) = #66;
|
|
void QCBUILTIN PF_cl_getmousepos (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
float *ret = G_VECTOR(OFS_RETURN);
|
|
world_t *world = prinst->parms->user;
|
|
unsigned int target = world->keydestmask;
|
|
|
|
if (key_dest_absolutemouse & target)
|
|
{
|
|
ret[0] = mousecursor_x;
|
|
ret[1] = mousecursor_y;
|
|
}
|
|
else
|
|
{
|
|
ret[0] = mousemove_x;
|
|
ret[1] = mousemove_y;
|
|
}
|
|
|
|
mousemove_x=0;
|
|
mousemove_y=0;
|
|
|
|
// extern int mousecursor_x, mousecursor_y;
|
|
// ret[0] = mousecursor_x;
|
|
// ret[1] = mousecursor_y;
|
|
ret[2] = 0;
|
|
}
|
|
|
|
|
|
void QCBUILTIN PF_SubConGetSet (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *conname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
const char *field = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
const char *value = (prinst->callargc>2)?PR_GetStringOfs(prinst, OFS_PARM2):NULL;
|
|
console_t *con = Con_FindConsole(conname);
|
|
G_INT(OFS_RETURN) = 0;
|
|
if (!con)
|
|
{
|
|
//null if it doesn't exist
|
|
return;
|
|
}
|
|
if (!strcmp(field, "title"))
|
|
{
|
|
RETURN_TSTRING(con->title);
|
|
if (value)
|
|
Q_strncpyz(con->title, value, sizeof(con->title));
|
|
}
|
|
else if (!strcmp(field, "name"))
|
|
{
|
|
RETURN_TSTRING(con->name);
|
|
if (value && *value && *con->name)
|
|
Q_strncpyz(con->name, value, sizeof(con->name));
|
|
}
|
|
else if (!strcmp(field, "next"))
|
|
{
|
|
con = con->next;
|
|
if (con)
|
|
RETURN_TSTRING(con->name);
|
|
}
|
|
else if (!strcmp(field, "unseen"))
|
|
{
|
|
RETURN_TSTRING(va("%i", con->unseentext));
|
|
if (value)
|
|
con->unseentext = atoi(value);
|
|
}
|
|
else if (!strcmp(field, "markup"))
|
|
{
|
|
int cur;
|
|
if (con->parseflags & PFS_NOMARKUP)
|
|
cur = 0;
|
|
else if (con->parseflags & PFS_KEEPMARKUP)
|
|
cur = 2;
|
|
else
|
|
cur = 1;
|
|
RETURN_TSTRING(va("%i", cur));
|
|
if (value)
|
|
{
|
|
cur = atoi(value);
|
|
con->parseflags &= ~(PFS_NOMARKUP|PFS_KEEPMARKUP);
|
|
if (cur == 0)
|
|
con->parseflags |= PFS_NOMARKUP;
|
|
else if (cur == 2)
|
|
con->parseflags |= PFS_KEEPMARKUP;
|
|
}
|
|
}
|
|
else if (!strcmp(field, "forceutf8"))
|
|
{
|
|
RETURN_TSTRING((con->parseflags&PFS_FORCEUTF8)?"1":"0");
|
|
if (value)
|
|
{
|
|
con->parseflags &= ~PFS_FORCEUTF8;
|
|
if (atoi(value))
|
|
con->parseflags |= PFS_FORCEUTF8;
|
|
}
|
|
}
|
|
else if (!strcmp(field, "close"))
|
|
{
|
|
RETURN_TSTRING("0"); //meant to return the old state...
|
|
if (value && atoi(value))
|
|
{
|
|
if (con->close && atoi(value) != 2 && !con->close(con, true))
|
|
return;
|
|
Con_Destroy(con);
|
|
}
|
|
}
|
|
else if (!strcmp(field, "clear"))
|
|
{
|
|
RETURN_TSTRING(con->linecount?"0":"1");
|
|
if (value && atoi(value))
|
|
Con_ClearCon(con);
|
|
}
|
|
else if (!strcmp(field, "hidden"))
|
|
{
|
|
RETURN_TSTRING((con->flags & CONF_HIDDEN)?"1":"0");
|
|
if (value)
|
|
con->flags = (con->flags & ~CONF_HIDDEN) | (atoi(value)?CONF_HIDDEN:0);
|
|
}
|
|
else if (!strcmp(field, "linecount"))
|
|
{
|
|
RETURN_TSTRING(va("%i", con->linecount));
|
|
if (value)
|
|
con->unseentext = atoi(value);
|
|
}
|
|
else if (!strcmp(field, "backimage"))
|
|
{
|
|
RETURN_TSTRING(con->backshader?con->backshader->name:con->backimage);
|
|
if (value)
|
|
{
|
|
Q_strncpyz(con->backimage, value, sizeof(con->backimage));
|
|
if (con->backshader)
|
|
R_UnloadShader(con->backshader);
|
|
}
|
|
}
|
|
else if (!strcmp(field, "backvideomap"))
|
|
{
|
|
RETURN_TSTRING(con->backshader?con->backshader->name:con->backimage);
|
|
if (value)
|
|
{
|
|
Q_strncpyz(con->backimage, "", sizeof(con->backimage));
|
|
if (con->backshader)
|
|
R_UnloadShader(con->backshader);
|
|
con->backshader = R_RegisterCustom(NULL, va("consolevid_%s", con->name), SUF_NONE, Shader_DefaultCinematic, value);
|
|
}
|
|
}
|
|
}
|
|
void QCBUILTIN PF_SubConPrintf (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
char outbuf[4096];
|
|
const char *conname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
const char *fmt = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
console_t *con = Con_FindConsole(conname);
|
|
if (!con)
|
|
{
|
|
con = Con_Create(conname, 0);
|
|
if (!con)
|
|
return;
|
|
}
|
|
PF_sprintf_internal(prinst, pr_globals, fmt, 2, outbuf, sizeof(outbuf));
|
|
Con_PrintCon(con, outbuf, con->parseflags);
|
|
}
|
|
void QCBUILTIN PF_SubConDraw (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *conname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
float *pos = G_VECTOR(OFS_PARM1);
|
|
float *size = G_VECTOR(OFS_PARM2);
|
|
float fontsize = G_FLOAT(OFS_PARM3);
|
|
console_t *con = Con_FindConsole(conname);
|
|
world_t *world = prinst->parms->user;
|
|
if (!con)
|
|
return;
|
|
|
|
if (world->g.drawfontscale)
|
|
{
|
|
// szx *= world->g.drawfontscale[0];
|
|
fontsize *= world->g.drawfontscale[1];
|
|
}
|
|
|
|
Con_DrawOneConsole(con, con->flags & CONF_KEYFOCUSED, PR_CL_ChooseFont(world->g.drawfont, fontsize, fontsize), pos[0], pos[1], size[0], size[1], 0);
|
|
}
|
|
void QCBUILTIN PF_SubConInput (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *conname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
int ie = G_FLOAT(OFS_PARM1);
|
|
float pa = G_FLOAT(OFS_PARM2);
|
|
float pb = G_FLOAT(OFS_PARM3);
|
|
// float pc = G_FLOAT(OFS_PARM4);
|
|
console_t *con = Con_FindConsole(conname);
|
|
G_FLOAT(OFS_RETURN) = 0;
|
|
if (!con)
|
|
return;
|
|
switch(ie)
|
|
{
|
|
case CSIE_KEYDOWN:
|
|
//scan, char
|
|
if ((pa && qcinput_scan != pa) || (pb && pb != qcinput_unicode))
|
|
G_FLOAT(OFS_RETURN) = 0;
|
|
else
|
|
G_FLOAT(OFS_RETURN) = Key_Console(con, MP_TranslateQCtoFTECodes(pa), pb);
|
|
break;
|
|
case CSIE_KEYUP:
|
|
//scan, char
|
|
Key_ConsoleRelease(con, MP_TranslateQCtoFTECodes(pa), pb);
|
|
G_FLOAT(OFS_RETURN) = 0; //does not inhibit
|
|
break;
|
|
case CSIE_MOUSEABS:
|
|
//x, y
|
|
if (con == con_current && (key_dest_mask & kdm_console))
|
|
break; //no interfering with the main console!
|
|
con->mousecursor[0] = pa;
|
|
con->mousecursor[1] = pb;
|
|
G_FLOAT(OFS_RETURN) = true;
|
|
break;
|
|
case CSIE_FOCUS:
|
|
//mouse, key
|
|
if (pb >= 0)
|
|
{
|
|
con->flags = (con->flags & ~CONF_KEYFOCUSED) | (pb?CONF_KEYFOCUSED:0);
|
|
G_FLOAT(OFS_RETURN) = true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef MENU_DAT
|
|
|
|
typedef struct menuedict_s
|
|
{
|
|
enum ereftype_e ereftype;
|
|
float freetime; // sv.time when the object was freed
|
|
int entnum;
|
|
unsigned int fieldsize;
|
|
pbool readonly; //world
|
|
|
|
void *fields;
|
|
} menuedict_t;
|
|
|
|
|
|
|
|
static struct
|
|
{
|
|
evalc_t chain;
|
|
evalc_t model;
|
|
evalc_t modelindex;
|
|
evalc_t mins;
|
|
evalc_t maxs;
|
|
evalc_t origin;
|
|
evalc_t angles;
|
|
evalc_t skin;
|
|
evalc_t colormap;
|
|
evalc_t frame1;
|
|
evalc_t frame2;
|
|
evalc_t lerpfrac;
|
|
evalc_t frame1time;
|
|
evalc_t frame2time;
|
|
evalc_t renderflags;
|
|
evalc_t skinobject;
|
|
evalc_t skelobject;
|
|
evalc_t colourmod;
|
|
evalc_t alpha;
|
|
} menuc_eval;
|
|
static playerview_t menuview;
|
|
|
|
|
|
static menu_t menuqc; //this is how the client forwards events etc.
|
|
static int inmenuprogs;
|
|
static progparms_t menuprogparms;
|
|
static menuedict_t *menu_edicts;
|
|
static int num_menu_edicts;
|
|
world_t menu_world;
|
|
static int menuentsize;
|
|
double menutime;
|
|
static struct
|
|
{
|
|
func_t init;
|
|
func_t shutdown;
|
|
func_t draw; qboolean fuckeddrawsizes;
|
|
func_t drawloading;
|
|
func_t keydown;
|
|
func_t keyup;
|
|
func_t inputevent;
|
|
func_t toggle;
|
|
func_t consolecommand;
|
|
func_t gethostcachecategory;
|
|
func_t rendererrestarted;
|
|
} mpfuncs;
|
|
jmp_buf mp_abort;
|
|
|
|
|
|
// cvars
|
|
#define MENUPROGSGROUP "Menu progs control"
|
|
cvar_t forceqmenu = CVAR("forceqmenu", "0");
|
|
cvar_t pr_menu_coreonerror = CVAR("pr_menu_coreonerror", "1");
|
|
cvar_t pr_menu_memsize = CVAR("pr_menu_memsize", "64m");
|
|
|
|
|
|
//new generic functions.
|
|
|
|
const char *RemapCvarNameFromDPToFTE(const char *name)
|
|
{
|
|
if (!stricmp(name, "vid_bitsperpixel"))
|
|
return "vid_bpp";
|
|
if (!stricmp(name, "_cl_playermodel"))
|
|
return "model";
|
|
if (!stricmp(name, "_cl_playerskin"))
|
|
return "skin";
|
|
if (!stricmp(name, "_cl_color"))
|
|
return "topcolor";
|
|
if (!stricmp(name, "_cl_name"))
|
|
return "name";
|
|
|
|
if (!stricmp(name, "v_contrast"))
|
|
return "v_contrast";
|
|
if (!stricmp(name, "v_hwgamma"))
|
|
return "vid_hardwaregamma";
|
|
if (!stricmp(name, "showfps"))
|
|
return "show_fps";
|
|
if (!stricmp(name, "sv_progs"))
|
|
return "progs";
|
|
|
|
return name;
|
|
}
|
|
|
|
static void QCBUILTIN PF_menu_cvar (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
cvar_t *var;
|
|
const char *str;
|
|
|
|
str = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
|
|
if (!strcmp(str, "vid_conwidth"))
|
|
G_FLOAT(OFS_RETURN) = vid.width;
|
|
else if (!strcmp(str, "vid_conheight"))
|
|
G_FLOAT(OFS_RETURN) = vid.height;
|
|
else if (!strcmp(str, "vid_pixwidth"))
|
|
G_FLOAT(OFS_RETURN) = vid.pixelwidth;
|
|
else if (!strcmp(str, "vid_pixheight"))
|
|
G_FLOAT(OFS_RETURN) = vid.pixelheight;
|
|
else
|
|
{
|
|
str = RemapCvarNameFromDPToFTE(str);
|
|
var = PF_Cvar_FindOrGet(str);
|
|
if (var && !(var->flags & CVAR_NOUNSAFEEXPAND))
|
|
{
|
|
//menuqc sees desired settings, not latched settings.
|
|
if (var->latched_string)
|
|
G_FLOAT(OFS_RETURN) = atof(var->latched_string);
|
|
else
|
|
G_FLOAT(OFS_RETURN) = var->value;
|
|
}
|
|
else
|
|
G_FLOAT(OFS_RETURN) = 0;
|
|
}
|
|
}
|
|
static void QCBUILTIN PF_menu_cvar_set (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *var_name, *val;
|
|
cvar_t *var;
|
|
|
|
var_name = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
var_name = RemapCvarNameFromDPToFTE(var_name);
|
|
val = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
|
|
var = PF_Cvar_FindOrGet(var_name);
|
|
if (var && var->flags & CVAR_NOTFROMSERVER)
|
|
{
|
|
//fixme: menuqc needs some way to display a prompt to allow it anyway.
|
|
return;
|
|
}
|
|
Cvar_Set (var, val);
|
|
}
|
|
static void QCBUILTIN PF_menu_cvar_string (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *str = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
cvar_t *cv = PF_Cvar_FindOrGet(RemapCvarNameFromDPToFTE(str));
|
|
if (!cv)
|
|
G_INT(OFS_RETURN) = 0;
|
|
else if (cv->flags & CVAR_NOUNSAFEEXPAND)
|
|
G_INT(OFS_RETURN) = 0;
|
|
else if (cv->latched_string)
|
|
G_INT(OFS_RETURN) = (int)PR_TempString(prinst, cv->latched_string);
|
|
else
|
|
G_INT(OFS_RETURN) = (int)PR_TempString(prinst, cv->string);
|
|
}
|
|
|
|
|
|
|
|
|
|
void QCBUILTIN PF_nonfatalobjerror (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *s;
|
|
struct edict_s *ed;
|
|
eval_t *selfp;
|
|
|
|
s = PF_VarString(prinst, 0, pr_globals);
|
|
|
|
PR_StackTrace(prinst, true);
|
|
|
|
selfp = PR_FindGlobal(prinst, "self", PR_CURRENT, NULL);
|
|
if (selfp && selfp->_int)
|
|
{
|
|
ed = PROG_TO_EDICT(prinst, selfp->_int);
|
|
|
|
PR_PrintEdict(prinst, ed);
|
|
|
|
|
|
if (developer.value)
|
|
{ //enable tracing.
|
|
PR_RunWarning(prinst, "======OBJECT ERROR======\n%s\n", s);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
ED_Free (prinst, ed);
|
|
}
|
|
}
|
|
|
|
Con_Printf ("======OBJECT ERROR======\n%s\n", s);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//float isserver(void) = #60;
|
|
void QCBUILTIN PF_isserver (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
#ifdef CLIENTONLY
|
|
G_FLOAT(OFS_RETURN) = false;
|
|
#else
|
|
if (sv.state == ss_dead)
|
|
G_FLOAT(OFS_RETURN) = false;
|
|
else if (sv.allocated_client_slots == 1)
|
|
G_FLOAT(OFS_RETURN) = 0.5;
|
|
else
|
|
G_FLOAT(OFS_RETURN) = true;
|
|
#endif
|
|
}
|
|
void QCBUILTIN PF_isdemo (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
G_FLOAT(OFS_RETURN) = !!cls.demoplayback;
|
|
}
|
|
|
|
//float clientstate(void) = #62;
|
|
void QCBUILTIN PF_clientstate (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//menuqc was originally implemented in DP, so these return values follow NQ norms.
|
|
if (isDedicated) //unreachable
|
|
G_FLOAT(OFS_RETURN) = 0/*nq ca_dedicated*/;
|
|
else if ( cls.state >= ca_connected //we're on a server
|
|
|| CL_TryingToConnect() //or we're trying to connect (avoids bugs with certain menuqc mods)
|
|
#ifndef CLIENTONLY
|
|
|| sv.state>=ss_loading
|
|
#endif
|
|
) //or we're going to connect to ourselves once we get our act together
|
|
G_FLOAT(OFS_RETURN) = 2/*nq ca_connected*/;
|
|
else
|
|
G_FLOAT(OFS_RETURN) = 1/*nq ca_disconnected*/;
|
|
}
|
|
|
|
static void QCBUILTIN PF_Ignore (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
//too specific to the prinst's builtins.
|
|
static void QCBUILTIN PF_Fixme (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
int binum;
|
|
char fname[MAX_QPATH];
|
|
if (!prinst->GetBuiltinCallInfo(prinst, &binum, fname, sizeof(fname)))
|
|
{
|
|
binum = 0;
|
|
strcpy(fname, "?unknown?");
|
|
}
|
|
|
|
Con_Printf("\n");
|
|
prinst->RunError(prinst, "\nBuiltin %i:%s not implemented.\nMenu is not compatible.", binum, fname);
|
|
PR_BIError (prinst, "bulitin not implemented");
|
|
}
|
|
static void QCBUILTIN PF_checkbuiltin (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
func_t funcref = G_INT(OFS_PARM0);
|
|
char *funcname = NULL;
|
|
int args;
|
|
int builtinno;
|
|
if (prinst->GetFunctionInfo(prinst, funcref, &args, NULL, &builtinno, funcname, sizeof(funcname)))
|
|
{ //qc defines the function at least. nothing weird there...
|
|
if (builtinno > 0 && builtinno < prinst->parms->numglobalbuiltins)
|
|
{
|
|
if (!prinst->parms->globalbuiltins[builtinno] || prinst->parms->globalbuiltins[builtinno] == PF_Fixme || prinst->parms->globalbuiltins[builtinno] == PF_Ignore)
|
|
G_FLOAT(OFS_RETURN) = false; //the builtin with that number isn't defined.
|
|
else
|
|
{
|
|
G_FLOAT(OFS_RETURN) = true; //its defined, within the sane range, mapped, everything. all looks good.
|
|
//we should probably go through the available builtins and validate that the qc's name matches what would be expected
|
|
//this is really intended more for builtins defined as #0 though, in such cases, mismatched assumptions are impossible.
|
|
}
|
|
}
|
|
else
|
|
G_FLOAT(OFS_RETURN) = false; //not a valid builtin (#0 builtins get remapped according to the function name)
|
|
}
|
|
else
|
|
{ //not valid somehow.
|
|
G_FLOAT(OFS_RETURN) = false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void QCBUILTIN PF_CL_precache_sound (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *str;
|
|
|
|
str = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
|
|
if (S_PrecacheSound(str))
|
|
G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
|
|
else
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
|
|
//void setkeydest(float dest) = #601;
|
|
void QCBUILTIN PF_cl_setkeydest (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//these arguments are stupid
|
|
switch((int)G_FLOAT(OFS_PARM0))
|
|
{
|
|
case 0:
|
|
// key_game
|
|
if (Key_Dest_Has(kdm_menu))
|
|
{
|
|
Menu_Unlink(&menuqc, false);
|
|
Key_Dest_Remove(kdm_menu);
|
|
// Key_Dest_Remove(kdm_message);
|
|
// if (cls.state == ca_disconnected)
|
|
// Key_Dest_Add(kdm_console);
|
|
}
|
|
break;
|
|
case 2:
|
|
// key_menu
|
|
Key_Dest_Remove(kdm_message);
|
|
if (!Key_Dest_Has(kdm_menu))
|
|
Key_Dest_Remove(kdm_console);
|
|
Menu_Push(&menuqc, false);
|
|
break;
|
|
case 1:
|
|
// key_message
|
|
//Key_Dest_Remove(kdm_menu);
|
|
//Key_Dest_Add(kdm_message);
|
|
// break;
|
|
default:
|
|
PR_BIError (prinst, "PF_setkeydest: wrong destination %i !\n",(int)G_FLOAT(OFS_PARM0));
|
|
}
|
|
}
|
|
//float getkeydest(void) = #602;
|
|
void QCBUILTIN PF_cl_getkeydest (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
if (Key_Dest_Has(kdm_menu))
|
|
G_FLOAT(OFS_RETURN) = 2;
|
|
// else if (Key_Dest_Has(kdm_message))
|
|
// G_FLOAT(OFS_RETURN) = 1;
|
|
else
|
|
G_FLOAT(OFS_RETURN) = 0;
|
|
}
|
|
|
|
static void QCBUILTIN PF_Remove_ (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
menuedict_t *ed;
|
|
|
|
ed = (void*)G_EDICT(prinst, OFS_PARM0);
|
|
|
|
if (ed->ereftype == ER_FREE)
|
|
{
|
|
Con_DPrintf("Tried removing free entity\n");
|
|
PR_StackTrace(prinst, false);
|
|
return;
|
|
}
|
|
|
|
ED_Free (prinst, (void*)ed);
|
|
}
|
|
static void QCBUILTIN PF_RemoveInstant (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
menuedict_t *ed;
|
|
|
|
ed = (void*)G_EDICT(prinst, OFS_PARM0);
|
|
|
|
if (ed->ereftype == ER_FREE)
|
|
{
|
|
Con_DPrintf("Tried removing free entity\n");
|
|
PR_StackTrace(prinst, false);
|
|
return;
|
|
}
|
|
|
|
prinst->EntFree(prinst, (void*)ed, true);
|
|
}
|
|
|
|
static void QCBUILTIN PF_CopyEntity (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
menuedict_t *in, *out;
|
|
|
|
in = (menuedict_t*)G_EDICT(prinst, OFS_PARM0);
|
|
out = (menuedict_t*)G_EDICT(prinst, OFS_PARM1);
|
|
|
|
memcpy(out->fields, in->fields, menuentsize);
|
|
}
|
|
|
|
void QCBUILTIN PF_menu_checkextension (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *extname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
int i;
|
|
G_FLOAT(OFS_RETURN) = 0;
|
|
|
|
for (i = 0; i < QSG_Extensions_count; i++)
|
|
{
|
|
if (!QSG_Extensions[i].name)
|
|
continue;
|
|
if (!stricmp(extname, QSG_Extensions[i].name))
|
|
{
|
|
G_FLOAT(OFS_RETURN) = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void QCBUILTIN PF_CL_precache_file (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
G_INT(OFS_RETURN) = G_INT(OFS_PARM0);
|
|
}
|
|
|
|
//entity findchainstring(.string _field, string match) = #26;
|
|
void QCBUILTIN PF_menu_findchain (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
int i, f;
|
|
const char *s;
|
|
string_t t;
|
|
menuedict_t *ent, *chain; //note, all edicts share the common header, but don't use it's fields!
|
|
eval_t *val;
|
|
|
|
chain = (menuedict_t *) *prinst->parms->edicts;
|
|
|
|
f = G_INT(OFS_PARM0)+prinst->fieldadjust;
|
|
s = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
|
|
for (i = 1; i < *prinst->parms->num_edicts; i++)
|
|
{
|
|
ent = (menuedict_t *)EDICT_NUM_PB(prinst, i);
|
|
if (ent->ereftype == ER_FREE)
|
|
continue;
|
|
t = *(string_t *)&((float*)ent->fields)[f];
|
|
if (!t)
|
|
continue;
|
|
if (strcmp(PR_GetString(prinst, t), s))
|
|
continue;
|
|
|
|
val = prinst->GetEdictFieldValue(prinst, (void*)ent, "chain", ev_entity, &menuc_eval.chain);
|
|
if (val)
|
|
val->edict = EDICT_TO_PROG(prinst, (void*)chain);
|
|
chain = ent;
|
|
}
|
|
|
|
RETURN_EDICT(prinst, (void*)chain);
|
|
}
|
|
//entity findchainfloat(.float _field, float match) = #27;
|
|
void QCBUILTIN PF_menu_findchainfloat (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
int i, f;
|
|
float s;
|
|
menuedict_t *ent, *chain; //note, all edicts share the common header, but don't use it's fields!
|
|
eval_t *val;
|
|
|
|
chain = (menuedict_t *) *prinst->parms->edicts;
|
|
|
|
f = G_INT(OFS_PARM0)+prinst->fieldadjust;
|
|
s = G_FLOAT(OFS_PARM1);
|
|
|
|
for (i = 1; i < *prinst->parms->num_edicts; i++)
|
|
{
|
|
ent = (menuedict_t*)EDICT_NUM_PB(prinst, i);
|
|
if (ent->ereftype == ER_FREE)
|
|
continue;
|
|
if (((float *)ent->fields)[f] != s)
|
|
continue;
|
|
|
|
val = prinst->GetEdictFieldValue(prinst, (void*)ent, "chain", ev_entity, &menuc_eval.chain);
|
|
if (val)
|
|
val->edict = EDICT_TO_PROG(prinst, (void*)chain);
|
|
chain = ent;
|
|
}
|
|
|
|
RETURN_EDICT(prinst, (void*)chain);
|
|
}
|
|
//entity findchainflags(.float _field, float match);
|
|
void QCBUILTIN PF_menu_findchainflags (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
int i, f;
|
|
int s;
|
|
menuedict_t *ent, *chain; //note, all edicts share the common header, but don't use it's fields!
|
|
eval_t *val;
|
|
|
|
chain = (menuedict_t *) *prinst->parms->edicts;
|
|
|
|
f = G_INT(OFS_PARM0)+prinst->fieldadjust;
|
|
s = G_FLOAT(OFS_PARM1);
|
|
|
|
for (i = 1; i < *prinst->parms->num_edicts; i++)
|
|
{
|
|
ent = (menuedict_t*)EDICT_NUM_PB(prinst, i);
|
|
if (ent->ereftype == ER_FREE)
|
|
continue;
|
|
if ((int)((float *)ent->fields)[f] & s)
|
|
continue;
|
|
|
|
val = prinst->GetEdictFieldValue(prinst, (void*)ent, "chain", ev_entity, &menuc_eval.chain);
|
|
if (val)
|
|
val->edict = EDICT_TO_PROG(prinst, (void*)chain);
|
|
chain = ent;
|
|
}
|
|
|
|
RETURN_EDICT(prinst, (void*)chain);
|
|
}
|
|
|
|
void QCBUILTIN PF_etof(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
G_FLOAT(OFS_RETURN) = G_EDICTNUM(prinst, OFS_PARM0);
|
|
}
|
|
void QCBUILTIN PF_ftoe(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
int entnum = G_FLOAT(OFS_PARM0);
|
|
|
|
RETURN_EDICT(prinst, EDICT_NUM_UB(prinst, entnum));
|
|
}
|
|
|
|
void QCBUILTIN PF_IsNotNull(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
int str = G_INT(OFS_PARM0);
|
|
G_FLOAT(OFS_RETURN) = !!str;
|
|
}
|
|
|
|
//float altstr_count(string str) = #82;
|
|
//returns number of single quoted strings in the string.
|
|
void QCBUILTIN PF_altstr_count(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *s;
|
|
int count = 0;
|
|
s = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
for (;*s;s++)
|
|
{
|
|
if (*s == '\\')
|
|
{
|
|
if (!*++s)
|
|
break;
|
|
}
|
|
else if (*s == '\'')
|
|
count++;
|
|
}
|
|
G_FLOAT(OFS_RETURN) = count/2;
|
|
}
|
|
//string altstr_prepare(string str) = #83;
|
|
void QCBUILTIN PF_altstr_prepare(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
char outstr[8192], *out;
|
|
const char *instr, *in;
|
|
int size;
|
|
|
|
// VM_SAFEPARMCOUNT( 1, VM_altstr_prepare );
|
|
|
|
instr = PR_GetStringOfs(prinst, OFS_PARM0 );
|
|
//VM_CheckEmptyString( instr );
|
|
|
|
for( out = outstr, in = instr, size = sizeof(outstr) - 1 ; size && *in ; size--, in++, out++ )
|
|
{
|
|
if( *in == '\'' )
|
|
{
|
|
*out++ = '\\';
|
|
*out = '\'';
|
|
size--;
|
|
}
|
|
else
|
|
*out = *in;
|
|
}
|
|
*out = 0;
|
|
|
|
G_INT( OFS_RETURN ) = (int)PR_TempString( prinst, outstr );
|
|
}
|
|
//string altstr_get(string str, float num) = #84;
|
|
void QCBUILTIN PF_altstr_get(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *altstr, *pos;
|
|
char outstr[8192], *out;
|
|
int count, size;
|
|
|
|
// VM_SAFEPARMCOUNT( 2, VM_altstr_get );
|
|
|
|
altstr = PR_GetStringOfs(prinst, OFS_PARM0 );
|
|
//VM_CheckEmptyString( altstr );
|
|
|
|
count = G_FLOAT( OFS_PARM1 );
|
|
count = count * 2 + 1;
|
|
|
|
for( pos = altstr ; *pos && count ; pos++ )
|
|
{
|
|
if( *pos == '\\' && !*++pos )
|
|
break;
|
|
else if( *pos == '\'' )
|
|
count--;
|
|
}
|
|
|
|
if( !*pos )
|
|
{
|
|
G_INT( OFS_RETURN ) = (int)PR_SetString( prinst, "" );
|
|
return;
|
|
}
|
|
|
|
for( out = outstr, size = sizeof(outstr) - 1 ; size && *pos ; size--, pos++, out++ )
|
|
{
|
|
if( *pos == '\\' )
|
|
{
|
|
if( !*++pos )
|
|
break;
|
|
*out = *pos;
|
|
size--;
|
|
}
|
|
else if( *pos == '\'' )
|
|
break;
|
|
else
|
|
*out = *pos;
|
|
}
|
|
|
|
*out = 0;
|
|
G_INT( OFS_RETURN ) = (int)PR_TempString( prinst, outstr );
|
|
}
|
|
//string altstr_set(string str, float num, string set) = #85
|
|
void QCBUILTIN PF_altstr_set(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
int num;
|
|
const char *altstr, *str;
|
|
const char *in;
|
|
char outstr[8192], *out;
|
|
|
|
// VM_SAFEPARMCOUNT( 3, VM_altstr_set );
|
|
|
|
altstr = PR_GetStringOfs(prinst, OFS_PARM0 );
|
|
//VM_CheckEmptyString( altstr );
|
|
|
|
num = G_FLOAT( OFS_PARM1 );
|
|
|
|
str = PR_GetStringOfs(prinst, OFS_PARM2 );
|
|
//VM_CheckEmptyString( str );
|
|
|
|
out = outstr;
|
|
for( num = num * 2 + 1, in = altstr; *in && num; *out++ = *in++ )
|
|
{
|
|
if( *in == '\\' && !*++in )
|
|
break;
|
|
else if( *in == '\'' )
|
|
num--;
|
|
}
|
|
|
|
if( !in )
|
|
{
|
|
G_INT( OFS_RETURN ) = (int)PR_SetString( prinst, "" );
|
|
return;
|
|
}
|
|
// copy set in
|
|
for( ; *str; *out++ = *str++ )
|
|
;
|
|
// now jump over the old contents
|
|
for( ; *in ; in++ )
|
|
{
|
|
if( *in == '\'' || (*in == '\\' && !*++in) )
|
|
break;
|
|
}
|
|
|
|
if( !in ) {
|
|
G_INT( OFS_RETURN ) = (int)PR_SetString( prinst, "" );
|
|
return;
|
|
}
|
|
|
|
strcpy( out, in );
|
|
G_INT( OFS_RETURN ) = (int)PR_TempString( prinst, outstr );
|
|
|
|
}
|
|
|
|
//string(string serveraddress) crypto_getkeyfp
|
|
void QCBUILTIN PF_crypto_getkeyfp(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//not supported.
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
//string(string serveraddress) crypto_getidfp
|
|
void QCBUILTIN PF_crypto_getidfp(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//not supported.
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
//float(string serveraddress) crypto_getidstatus
|
|
void QCBUILTIN PF_crypto_getidstatus(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//not supported.
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
//string(string serveraddress) crypto_getencryptlevel
|
|
void QCBUILTIN PF_crypto_getencryptlevel(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//not supported.
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
//string(float i) crypto_getmykeyfp
|
|
void QCBUILTIN PF_crypto_getmykeyfp(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//not supported.
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
//string(float i) crypto_getmyidfp
|
|
void QCBUILTIN PF_crypto_getmyidfp(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//not supported.
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
//float(float i) PF_crypto_getmyidstatus
|
|
void QCBUILTIN PF_crypto_getmyidstatus(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
//not supported.
|
|
G_INT(OFS_RETURN) = 0;
|
|
}
|
|
|
|
static void QCBUILTIN PF_m_precache_model(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *modelname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
Mod_ForName(modelname, MLV_WARN);
|
|
}
|
|
static model_t *QDECL MP_GetCModel(struct world_s *w, int modelindex)
|
|
{
|
|
extern int mod_numknown;
|
|
modelindex--;
|
|
if (modelindex < 0 || modelindex >= mod_numknown)
|
|
return NULL;
|
|
return &mod_known[modelindex];
|
|
}
|
|
static void QCBUILTIN PF_m_getmodelindex(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *modelname = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
model_t *m = Mod_ForName(modelname, MLV_WARN);
|
|
if (m)
|
|
G_FLOAT(OFS_RETURN) = (m-mod_known)+1;
|
|
else
|
|
G_FLOAT(OFS_RETURN) = 0;
|
|
}
|
|
static void QCBUILTIN PF_m_setmodel(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
menuedict_t *ent = (void*)G_EDICT(prinst, OFS_PARM0);
|
|
const char *modelname = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
eval_t *modelval = prinst->GetEdictFieldValue(prinst, (void*)ent, "model", ev_string, &menuc_eval.model);
|
|
eval_t *minsval = prinst->GetEdictFieldValue(prinst, (void*)ent, "mins", ev_vector, &menuc_eval.mins);
|
|
eval_t *maxsval = prinst->GetEdictFieldValue(prinst, (void*)ent, "maxs", ev_vector, &menuc_eval.maxs);
|
|
eval_t *modelidxval = prinst->GetEdictFieldValue(prinst, (void*)ent, "modelindex", ev_float, &menuc_eval.modelindex);
|
|
model_t *mod = Mod_ForName(modelname, MLV_WARN);
|
|
if (modelval)
|
|
modelval->string = G_INT(OFS_PARM1); //lets hope garbage collection is enough.
|
|
else
|
|
Con_Printf("PF_m_setmodel: no model field!\n");
|
|
|
|
if (mod)
|
|
while(mod->loadstate == MLS_LOADING)
|
|
COM_WorkerPartialSync(mod, &mod->loadstate, MLS_LOADING);
|
|
if (modelidxval)
|
|
modelidxval->_float = mod?(mod-mod_known)+1:0;
|
|
|
|
if (mod && minsval)
|
|
VectorCopy(mod->mins, minsval->_vector);
|
|
if (mod && maxsval)
|
|
VectorCopy(mod->maxs, maxsval->_vector);
|
|
}
|
|
static void QCBUILTIN PF_m_setcustomskin(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
menuedict_t *ent = (void*)G_EDICT(prinst, OFS_PARM0);
|
|
const char *fname = PR_GetStringOfs(prinst, OFS_PARM1);
|
|
const char *skindata = PF_VarString(prinst, 2, pr_globals);
|
|
eval_t *val = prinst->GetEdictFieldValue(prinst, (void*)ent, "skinobject", ev_string, &menuc_eval.skinobject);
|
|
if (!val)
|
|
{
|
|
Con_Printf("PF_m_setcustomskin: no skinobject field!\n");
|
|
return;
|
|
}
|
|
|
|
if (val->_float > 0)
|
|
{
|
|
Mod_WipeSkin(val->_float, false);
|
|
val->_float = 0;
|
|
}
|
|
|
|
if (*fname || *skindata)
|
|
{
|
|
if (*skindata)
|
|
val->_float = Mod_ReadSkinFile(fname, skindata);
|
|
else
|
|
val->_float = -(int)Mod_RegisterSkinFile(fname);
|
|
}
|
|
}
|
|
//trivially basic
|
|
static void QCBUILTIN PF_m_setorigin(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
menuedict_t *ent = (void*)G_EDICT(prinst, OFS_PARM0);
|
|
float *org = G_VECTOR(OFS_PARM1);
|
|
eval_t *val = prinst->GetEdictFieldValue(prinst, (void*)ent, "origin", ev_vector, &menuc_eval.origin);
|
|
if (val)
|
|
VectorCopy(org, val->_vector);
|
|
else
|
|
Con_Printf("PF_m_setorigin: no origin field!\n");
|
|
}
|
|
static void QCBUILTIN PF_m_clearscene(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
// CL_DecayLights ();
|
|
|
|
#if defined(SKELETALOBJECTS) || defined(RAGDOLLS)
|
|
world_t *world = prinst->parms->user;
|
|
if (world)
|
|
skel_dodelete(world);
|
|
#endif
|
|
CL_ClearEntityLists();
|
|
|
|
V_ClearRefdef(&menuview);
|
|
r_refdef.drawsbar = false;
|
|
r_refdef.drawcrosshair = false;
|
|
V_CalcRefdef(&menuview); //set up the defaults
|
|
r_refdef.flags |= RDF_NOWORLDMODEL;
|
|
}
|
|
static void QDECL MP_Read_FrameState(pubprogfuncs_t *prinst, wedict_t *ent, framestate_t *fstate)
|
|
{
|
|
eval_t *frame1val = prinst->GetEdictFieldValue(prinst, (void*)ent, "frame", ev_float, &menuc_eval.frame1);
|
|
eval_t *frame2val = prinst->GetEdictFieldValue(prinst, (void*)ent, "frame2", ev_float, &menuc_eval.frame2);
|
|
eval_t *lerpfracval = prinst->GetEdictFieldValue(prinst, (void*)ent, "lerpfrac", ev_float, &menuc_eval.lerpfrac);
|
|
eval_t *frame1timeval = prinst->GetEdictFieldValue(prinst, (void*)ent, "frame1time", ev_float, &menuc_eval.frame1time);
|
|
eval_t *frame2timeval = prinst->GetEdictFieldValue(prinst, (void*)ent, "frame2time", ev_float, &menuc_eval.frame2time);
|
|
eval_t *skelobjectval = prinst->GetEdictFieldValue(prinst, (void*)ent, "skeletonindex", ev_float, &menuc_eval.skelobject);
|
|
|
|
fstate->g[FST_BASE].endbone = 0;
|
|
fstate->g[FS_REG].endbone = 0x7fffffff;
|
|
fstate->g[FS_REG].frame[0] = frame1val?frame1val->_float:0;
|
|
fstate->g[FS_REG].frame[1] = frame2val?frame2val->_float:0;
|
|
fstate->g[FS_REG].lerpweight[1] = lerpfracval?lerpfracval->_float:0;
|
|
fstate->g[FS_REG].frametime[0] = frame1timeval?frame1timeval->_float:0;
|
|
fstate->g[FS_REG].frametime[1] = frame2timeval?frame2timeval->_float:0;
|
|
|
|
#if FRAME_BLENDS >= 4
|
|
fstate->g[FS_REG].frame[2] = fstate->g[FS_REG].frame[0];
|
|
fstate->g[FS_REG].lerpweight[2] = 0;
|
|
fstate->g[FS_REG].frame[3] = fstate->g[FS_REG].frame[0];
|
|
fstate->g[FS_REG].lerpweight[3] = 0;
|
|
fstate->g[FS_REG].lerpweight[0] = 1-(fstate->g[FS_REG].lerpweight[1]+fstate->g[FS_REG].lerpweight[2]+fstate->g[FS_REG].lerpweight[3]);
|
|
#else
|
|
fstate->g[FS_REG].lerpweight[0] = 1-fstate->g[FS_REG].lerpweight[1];
|
|
#endif
|
|
|
|
#if defined(SKELETALOBJECTS) || defined(RAGDOLL)
|
|
fstate->bonecount = 0;
|
|
fstate->bonestate = NULL;
|
|
if (skelobjectval && skelobjectval->_float)
|
|
skel_lookup(&menu_world, skelobjectval->_float, fstate);
|
|
#endif
|
|
}
|
|
static void QDECL MP_Get_FrameState(struct world_s *w, wedict_t *ent, framestate_t *fstate)
|
|
{
|
|
MP_Read_FrameState(w->progs, ent, fstate);
|
|
}
|
|
static qboolean CopyMenuEdictToEntity(pubprogfuncs_t *prinst, menuedict_t *in, entity_t *out)
|
|
{
|
|
eval_t *modelval = prinst->GetEdictFieldValue(prinst, (void*)in, "model", ev_string, &menuc_eval.model);
|
|
eval_t *originval = prinst->GetEdictFieldValue(prinst, (void*)in, "origin", ev_vector, &menuc_eval.origin);
|
|
eval_t *anglesval = prinst->GetEdictFieldValue(prinst, (void*)in, "angles", ev_vector, &menuc_eval.angles);
|
|
eval_t *skinval = prinst->GetEdictFieldValue(prinst, (void*)in, "skin", ev_float, &menuc_eval.skin);
|
|
eval_t *frame1val = prinst->GetEdictFieldValue(prinst, (void*)in, "frame", ev_float, &menuc_eval.frame1);
|
|
eval_t *frame2val = prinst->GetEdictFieldValue(prinst, (void*)in, "frame2", ev_float, &menuc_eval.frame2);
|
|
eval_t *lerpfracval = prinst->GetEdictFieldValue(prinst, (void*)in, "lerpfrac", ev_float, &menuc_eval.lerpfrac);
|
|
eval_t *frame1timeval = prinst->GetEdictFieldValue(prinst, (void*)in, "frame1time", ev_float, &menuc_eval.frame1time);
|
|
eval_t *frame2timeval = prinst->GetEdictFieldValue(prinst, (void*)in, "frame2time", ev_float, &menuc_eval.frame2time);
|
|
eval_t *skelobjectval = prinst->GetEdictFieldValue(prinst, (void*)in, "skeletonindex", ev_float, &menuc_eval.skelobject);
|
|
eval_t *colormapval = prinst->GetEdictFieldValue(prinst, (void*)in, "colormap", ev_float, &menuc_eval.colormap);
|
|
eval_t *renderflagsval = prinst->GetEdictFieldValue(prinst, (void*)in, "renderflags", ev_float, &menuc_eval.renderflags);
|
|
eval_t *skinobjectval = prinst->GetEdictFieldValue(prinst, (void*)in, "skinobject", ev_float, &menuc_eval.skinobject);
|
|
eval_t *colourmodval = prinst->GetEdictFieldValue(prinst, (void*)in, "colormod", ev_vector, &menuc_eval.colourmod);
|
|
eval_t *alphaval = prinst->GetEdictFieldValue(prinst, (void*)in, "alpha", ev_float, &menuc_eval.alpha);
|
|
int ival;
|
|
int rflags;
|
|
|
|
rflags = renderflagsval?renderflagsval->_float:0;
|
|
|
|
memset(out, 0, sizeof(*out));
|
|
if (modelval)
|
|
out->model = Mod_ForName(prinst->StringToNative(prinst, modelval->_int), MLV_WARN);
|
|
if (originval)
|
|
VectorCopy(originval->_vector, out->origin);
|
|
if (!anglesval)anglesval = (eval_t*)vec3_origin;
|
|
AngleVectors(anglesval->_vector, out->axis[0], out->axis[1], out->axis[2]);
|
|
VectorInverse(out->axis[1]);
|
|
|
|
out->scale = 1;
|
|
out->skinnum = skinval?skinval->_float:0;
|
|
out->framestate.g[FS_REG].frame[0] = frame1val?frame1val->_float:0;
|
|
out->framestate.g[FS_REG].frame[1] = frame2val?frame2val->_float:0;
|
|
out->framestate.g[FS_REG].lerpweight[1] = lerpfracval?lerpfracval->_float:0;
|
|
out->framestate.g[FS_REG].lerpweight[0] = 1-out->framestate.g[FS_REG].lerpweight[1];
|
|
out->framestate.g[FS_REG].frametime[0] = frame1timeval?frame1timeval->_float:0;
|
|
out->framestate.g[FS_REG].frametime[1] = frame2timeval?frame2timeval->_float:0;
|
|
|
|
#if defined(SKELETALOBJECTS) || defined(RAGDOLL)
|
|
out->framestate.bonecount = 0;
|
|
out->framestate.bonestate = NULL;
|
|
if (skelobjectval && skelobjectval->_float)
|
|
skel_lookup(&menu_world, skelobjectval->_float, &out->framestate);
|
|
#endif
|
|
|
|
out->customskin = skinobjectval?skinobjectval->_float:0;
|
|
|
|
//FIXME: colourmap
|
|
ival = colormapval?colormapval->_float:0;
|
|
out->playerindex = -1;
|
|
if (ival >= 1024)
|
|
{
|
|
//DP COLORMAP extension
|
|
out->topcolour = (ival>>4) & 0x0f;
|
|
out->bottomcolour = ival & 0xf;
|
|
}
|
|
/* else if (ival > 0 && ival <= MAX_CLIENTS)
|
|
{ //FIXME: tie to the current skin/topcolor/bottomcolor cvars somehow?
|
|
out->playerindex = ival - 1;
|
|
out->topcolour = cl.players[ival-1].ttopcolor;
|
|
out->bottomcolour = cl.players[ival-1].tbottomcolor;
|
|
}*/
|
|
else
|
|
{
|
|
out->topcolour = TOP_DEFAULT;
|
|
out->bottomcolour = BOTTOM_DEFAULT;
|
|
}
|
|
|
|
VectorSet(out->glowmod, 1,1,1);
|
|
if (!colourmodval || (!colourmodval->_vector[0] && !colourmodval->_vector[1] && !colourmodval->_vector[2]))
|
|
VectorSet(out->shaderRGBAf, 1, 1, 1);
|
|
else
|
|
{
|
|
out->flags |= RF_FORCECOLOURMOD;
|
|
VectorCopy(colourmodval->_vector, out->shaderRGBAf);
|
|
}
|
|
if (!alphaval || !alphaval->_float || alphaval->_float == 1)
|
|
out->shaderRGBAf[3] = 1.0f;
|
|
else
|
|
{
|
|
out->flags |= RF_TRANSLUCENT;
|
|
out->shaderRGBAf[3] = alphaval->_float;
|
|
}
|
|
|
|
if (rflags & CSQCRF_ADDITIVE)
|
|
out->flags |= RF_ADDITIVE;
|
|
if (rflags & CSQCRF_DEPTHHACK)
|
|
out->flags |= RF_DEPTHHACK;
|
|
|
|
if (out->model)
|
|
return true;
|
|
return false;
|
|
}
|
|
static void QCBUILTIN PF_m_addentity(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
menuedict_t *in = (void*)G_EDICT(prinst, OFS_PARM0);
|
|
entity_t ent;
|
|
if (in->ereftype == ER_FREE || in->entnum == 0)
|
|
{
|
|
Con_Printf("Tried drawing a free/removed/world entity\n");
|
|
return;
|
|
}
|
|
|
|
if (CopyMenuEdictToEntity(prinst, in, &ent))
|
|
V_AddAxisEntity(&ent);
|
|
}
|
|
static void QCBUILTIN PF_m_addentity_lighting(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
menuedict_t *in = (void*)G_EDICT(prinst, OFS_PARM0);
|
|
entity_t ent;
|
|
if (in->ereftype == ER_FREE || in->entnum == 0)
|
|
{
|
|
Con_Printf("Tried drawing a free/removed/world entity\n");
|
|
return;
|
|
}
|
|
|
|
if (CopyMenuEdictToEntity(prinst, in, &ent))
|
|
{
|
|
ent.light_known = true;
|
|
VectorCopy(G_VECTOR(OFS_PARM1), ent.light_dir);
|
|
VectorCopy(G_VECTOR(OFS_PARM2), ent.light_avg);
|
|
VectorCopy(G_VECTOR(OFS_PARM3), ent.light_range);
|
|
|
|
V_AddAxisEntity(&ent);
|
|
}
|
|
}
|
|
static void QCBUILTIN PF_m_renderscene(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
V_ApplyRefdef();
|
|
R_RenderView();
|
|
}
|
|
void QCBUILTIN PF_R_SetViewFlag(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals);
|
|
void QCBUILTIN PF_R_GetViewFlag(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals);
|
|
|
|
|
|
static void QCBUILTIN PF_menu_cprint (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *str = PF_VarString(prinst, 0, pr_globals);
|
|
SCR_CenterPrint(0, str, true);
|
|
}
|
|
static void QCBUILTIN PF_cl_changelevel (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
#ifndef CLIENTONLY
|
|
const char *nextmap = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
if (sv.active || !cls.state)
|
|
{
|
|
char buf[1024];
|
|
Cbuf_AddText(va("changelevel %s\n", COM_QuotedString(nextmap, buf, sizeof(buf), false)), RESTRICT_INSECURE);
|
|
}
|
|
#endif
|
|
}
|
|
static void QCBUILTIN PF_crash (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
int binum;
|
|
char fname[MAX_QPATH];
|
|
//allow people to rename it or whatever
|
|
if (!prinst->GetBuiltinCallInfo(prinst, &binum, fname, sizeof(fname)))
|
|
{
|
|
binum = 0;
|
|
strcpy(fname, "?unknown?");
|
|
}
|
|
|
|
prinst->RunError(prinst, "\n%s called", fname);
|
|
}
|
|
static void QCBUILTIN PF_stackdump (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
prinst->StackTrace(prinst, true);
|
|
}
|
|
#define PF_cl_clientcommand PF_Fixme
|
|
#define PF_altstr_ins PF_Fixme //insert after, apparently
|
|
|
|
static void MP_ConsoleCommand_f(void)
|
|
{
|
|
char cmd[2048];
|
|
Q_snprintfz(cmd, sizeof(cmd), "%s %s", Cmd_Argv(0), Cmd_Args());
|
|
MP_ConsoleCommand(cmd);
|
|
}
|
|
static void QCBUILTIN PF_menu_registercommand (pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
const char *str = PR_GetStringOfs(prinst, OFS_PARM0);
|
|
const char *desc = (prinst->callargc>1)?PR_GetStringOfs(prinst, OFS_PARM1):NULL;
|
|
if (desc && !*desc)
|
|
desc = NULL;
|
|
if (!Cmd_Exists(str))
|
|
Cmd_AddCommandD(str, MP_ConsoleCommand_f, desc);
|
|
}
|
|
|
|
static void PF_m_clipboard_got(void *ctx, const char *utf8)
|
|
{
|
|
void *pr_globals;
|
|
unsigned int unicode;
|
|
int error;
|
|
|
|
while (*utf8)
|
|
{
|
|
unicode = utf8_decode(&error, utf8, &utf8);
|
|
if (error)
|
|
unicode = 0xfffdu;
|
|
|
|
if (!menu_world.progs || !mpfuncs.inputevent)
|
|
return;
|
|
#ifdef TEXTEDITOR
|
|
if (editormodal)
|
|
return;
|
|
#endif
|
|
|
|
pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
G_FLOAT(OFS_PARM0) = CSIE_PASTE;
|
|
G_FLOAT(OFS_PARM1) = 0;
|
|
G_FLOAT(OFS_PARM2) = unicode;
|
|
G_FLOAT(OFS_PARM3) = 0;
|
|
|
|
qcinput_scan = G_FLOAT(OFS_PARM1);
|
|
qcinput_unicode = G_FLOAT(OFS_PARM2);
|
|
PR_ExecuteProgram (menu_world.progs, mpfuncs.inputevent);
|
|
qcinput_scan = 0; //and stop replay attacks
|
|
qcinput_unicode = 0;
|
|
}
|
|
}
|
|
static void QCBUILTIN PF_m_clipboard_get(pubprogfuncs_t *prinst, struct globalvars_s *pr_globals)
|
|
{
|
|
clipboardtype_t cliptype = G_FLOAT(OFS_PARM0);
|
|
Sys_Clipboard_PasteText(cliptype, PF_m_clipboard_got, prinst);
|
|
}
|
|
|
|
static struct {
|
|
char *name;
|
|
builtin_t bifunc;
|
|
int ebfsnum;
|
|
} BuiltinList[] = {
|
|
{"checkextension", PF_menu_checkextension, 1},
|
|
{"checkbuiltin", PF_checkbuiltin, 0},
|
|
{"error", PF_error, 2},
|
|
{"objerror", PF_nonfatalobjerror, 3},
|
|
{"print", PF_print, 4},
|
|
{"bprint", PF_cl_bprint, 5},
|
|
{"msprint", PF_cl_sprint, 6},
|
|
{"cprint", PF_menu_cprint, 7},
|
|
{"normalize", PF_normalize, 8},
|
|
{"vlen", PF_vlen, 9},
|
|
{"vectoyaw", PF_vectoyaw, 10},
|
|
{"vectoangles", PF_vectoangles, 11},
|
|
{"crossproduct", PF_crossproduct, 0},
|
|
{"random", PF_random, 12},
|
|
{"localcmd", PF_localcmd, 13},
|
|
{"cvar", PF_menu_cvar, 14},
|
|
{"cvar_set", PF_menu_cvar_set, 15},
|
|
{"dprint", PF_dprint, 16},
|
|
{"ftos", PF_ftos, 17},
|
|
{"fabs", PF_fabs, 18},
|
|
{"vtos", PF_vtos, 19},
|
|
{"etos", PF_etos, 20},
|
|
{"stof", PF_stof, 21},
|
|
|
|
{"json_parse", PF_json_parse, 0},
|
|
{"json_free", PF_memfree, 0},
|
|
{"json_get_value_type", PF_json_get_value_type, 0},
|
|
{"json_get_integer", PF_json_get_integer, 0},
|
|
{"json_get_float", PF_json_get_float, 0},
|
|
{"json_get_string", PF_json_get_string, 0},
|
|
{"json_find_object_child", PF_json_find_object_child, 0},
|
|
{"json_get_length", PF_json_get_length, 0},
|
|
{"json_get_child_at_index", PF_json_get_child_at_index, 0},
|
|
{"json_get_name", PF_json_get_name, 0},
|
|
|
|
{"js_run_script", PF_js_run_script, 0},
|
|
|
|
{"stoi", PF_stoi, 0},
|
|
{"itos", PF_itos, 0},
|
|
{"stoh", PF_stoh, 0},
|
|
{"htos", PF_htos, 0},
|
|
{"ftoi", PF_ftoi, 0},
|
|
{"itof", PF_itof, 0},
|
|
|
|
{"spawn", PF_Spawn, 22},
|
|
{"remove", PF_Remove_, 23},
|
|
{"removeinstant", PF_RemoveInstant, 0},
|
|
{"find", PF_FindString, 24},
|
|
{"findfloat", PF_FindFloat, 25},
|
|
{"findentity", PF_FindFloat, 25},
|
|
{"findchain", PF_menu_findchain, 26},
|
|
{"findchainfloat", PF_menu_findchainfloat, 27},
|
|
#ifdef QCGC
|
|
{"find_list", PF_FindList, 0},
|
|
#endif
|
|
{"precache_file", PF_CL_precache_file, 28},
|
|
{"precache_sound", PF_CL_precache_sound, 29},
|
|
{"coredump", PF_coredump, 30},
|
|
{"traceon", PF_traceon, 31},
|
|
{"traceoff", PF_traceoff, 32},
|
|
{"eprint", PF_eprint, 33},
|
|
{"rint", PF_rint, 34},
|
|
{"floor", PF_floor, 35},
|
|
{"ceil", PF_ceil, 36},
|
|
{"nextent", PF_nextent, 37},
|
|
{"sin", PF_Sin, 38},
|
|
{"cos", PF_Cos, 39},
|
|
{"sqrt", PF_Sqrt, 40},
|
|
{"randomvector", PF_randomvector, 41},
|
|
{"registercvar", PF_registercvar, 42},
|
|
{"min", PF_min, 43},
|
|
{"max", PF_max, 44},
|
|
{"bound", PF_bound, 45},
|
|
{"pow", PF_pow, 46},
|
|
{"logarithm", PF_Logarithm, 0},
|
|
{"entityprotection", PF_entityprotection, 0},
|
|
{"copyentity", PF_CopyEntity, 47},
|
|
{"fopen", PF_fopen, 48},
|
|
{"fclose", PF_fclose, 49},
|
|
{"fgets", PF_fgets, 50},
|
|
{"fputs", PF_fputs, 51},
|
|
{"fread", PF_fread, 0},
|
|
{"fwrite", PF_fwrite, 0},
|
|
{"fseek", PF_fseek, 0},
|
|
{"fsize", PF_fsize, 0},
|
|
{"strlen", PF_strlen, 52},
|
|
{"strcat", PF_strcat, 53},
|
|
{"substring", PF_substring, 54},
|
|
{"stov", PF_stov, 55},
|
|
{"strzone", PF_strzone, 56},
|
|
{"strunzone", PF_strunzone, 57},
|
|
#ifdef QCGC
|
|
{"createbuffer", PF_createbuffer, 0},
|
|
#endif
|
|
{"tokenize", PF_Tokenize, 58},
|
|
{"argv", PF_ArgV, 59},
|
|
{"isserver", PF_isserver, 60},
|
|
{"clientcount", PF_cl_clientcount, 61}, //float clientcount(void) = #61;
|
|
{"clientstate", PF_clientstate, 62},
|
|
{"clientcommand", PF_cl_clientcommand, 63}, //void clientcommand(float client, string s) = #63;
|
|
{"changelevel", PF_cl_changelevel, 64}, //void changelevel(string map) = #64;
|
|
{"localsound", PF_cl_localsound, 65},
|
|
{"getmousepos", PF_cl_getmousepos, 66},
|
|
{"gettime", PF_gettime, 67},
|
|
{"loadfromdata", PF_loadfromdata, 68},
|
|
{"loadfromfile", PF_loadfromfile, 69},
|
|
{"mod", PF_mod, 70},
|
|
{"cvar_string", PF_menu_cvar_string, 71},
|
|
{"crash", PF_crash, 72}, //void crash(void) = #72;
|
|
{"stackdump", PF_stackdump, 73}, //void stackdump(void) = #73;
|
|
{"search_begin", PF_search_begin, 74},
|
|
{"search_end", PF_search_end, 75},
|
|
{"search_getsize", PF_search_getsize, 76},
|
|
{"search_getfilename", PF_search_getfilename, 77},
|
|
{"search_getfilesize", PF_search_getfilesize, 0},
|
|
{"search_getfilemtime", PF_search_getfilemtime, 0},
|
|
{"search_getpackagename", PF_search_getpackagename, 0},
|
|
{"search_fopen", PF_search_fopen, 0},
|
|
{"chr2str", PF_chr2str, 78},
|
|
{"etof", PF_etof, 79},
|
|
{"ftoe", PF_ftoe, 80},
|
|
{"validstring", PF_IsNotNull, 81},
|
|
{"altstr_count", PF_altstr_count, 82},
|
|
{"altstr_prepare", PF_altstr_prepare, 83},
|
|
{"altstr_get", PF_altstr_get, 84},
|
|
{"altstr_set", PF_altstr_set, 85},
|
|
{"altstr_ins", PF_altstr_ins, 86},
|
|
{"findflags", PF_FindFlags, 87},
|
|
{"findchainflags", PF_menu_findchainflags, 88},
|
|
{"cvar_defstring", PF_cvar_defstring, 89},
|
|
{"setmodel", PF_m_setmodel, 90},
|
|
{"precache_model", PF_m_precache_model, 91},
|
|
{"setorigin", PF_m_setorigin, 92},
|
|
//gap
|
|
{"getmodelindex", PF_m_getmodelindex, 200},
|
|
//gap
|
|
{"abort", PF_Abort, 211},
|
|
//gap
|
|
{"strstrofs", PF_strstrofs, 221},
|
|
{"str2chr", PF_str2chr, 222},
|
|
{"chr2str", PF_chr2str, 223},
|
|
{"strconv", PF_strconv, 224},
|
|
{"strpad", PF_strpad, 225},
|
|
{"infoadd", PF_infoadd, 226},
|
|
{"infoget", PF_infoget, 227},
|
|
{"strcmp", PF_strncmp, 228},
|
|
{"strncmp", PF_strncmp, 228},
|
|
{"strcasecmp", PF_strncasecmp, 229},
|
|
{"strncasecmp", PF_strncasecmp, 230},
|
|
{"strtrim", PF_strtrim, 0},
|
|
//gap
|
|
{"shaderforname", PF_shaderforname, 238},
|
|
{"sendpacket", PF_cl_SendPacket, 242},
|
|
//gap
|
|
{"skel_create", PF_skel_create, 263},//float(float modlindex) skel_create = #263; // (FTE_CSQC_SKELETONOBJECTS)
|
|
{"skel_build", PF_skel_build, 264},//float(float skel, entity ent, float modelindex, float retainfrac, float firstbone, float lastbone, optional float addition) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS)
|
|
{"skel_build_ptr", PF_skel_build_ptr, 0},//float(float skel, int numblends, __variant *blends, int blendsize) skel_build_ptr = #0;
|
|
{"skel_get_numbones", PF_skel_get_numbones, 265},//float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS)
|
|
{"skel_get_bonename", PF_skel_get_bonename, 266},//string(float skel, float bonenum) skel_get_bonename = #266; // (FTE_CSQC_SKELETONOBJECTS) (returns tempstring)
|
|
{"skel_get_boneparent", PF_skel_get_boneparent, 267},//float(float skel, float bonenum) skel_get_boneparent = #267; // (FTE_CSQC_SKELETONOBJECTS)
|
|
{"skel_find_bone", PF_skel_find_bone, 268},//float(float skel, string tagname) skel_get_boneidx = #268; // (FTE_CSQC_SKELETONOBJECTS)
|
|
{"skel_get_bonerel", PF_skel_get_bonerel, 269},//vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) (sets v_forward etc)
|
|
{"skel_get_boneabs", PF_skel_get_boneabs, 270},//vector(float skel, float bonenum) skel_get_boneabs = #270; // (FTE_CSQC_SKELETONOBJECTS) (sets v_forward etc)
|
|
{"skel_set_bone", PF_skel_set_bone, 271},//void(float skel, float bonenum, vector org) skel_set_bone = #271; // (FTE_CSQC_SKELETONOBJECTS) (reads v_forward etc)
|
|
{"skel_premul_bone", PF_skel_premul_bone, 272},//void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) (reads v_forward etc)
|
|
{"skel_premul_bones", PF_skel_premul_bones, 273},//void(float skel, float startbone, float endbone, vector org) skel_mul_bone = #273; // (FTE_CSQC_SKELETONOBJECTS) (reads v_forward etc)
|
|
{"skel_postmul_bone", PF_skel_postmul_bone, 0},//void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) (reads v_forward etc)
|
|
// {"skel_postmul_bones", PF_skel_postmul_bones, 0},//void(float skel, float startbone, float endbone, vector org) skel_mul_bone = #273; // (FTE_CSQC_SKELETONOBJECTS) (reads v_forward etc)
|
|
{"skel_copybones", PF_skel_copybones, 274},//void(float skeldst, float skelsrc, float startbone, float entbone) skel_copybones = #274; // (FTE_CSQC_SKELETONOBJECTS)
|
|
{"skel_delete", PF_skel_delete, 275},//void(float skel) skel_delete = #275; // (FTE_CSQC_SKELETONOBJECTS)
|
|
{"frameforname", PF_frameforname, 276},//float(float modidx, string framename) frameforname = #276 (FTE_CSQC_SKELETONOBJECTS)
|
|
{"frameduration", PF_frameduration, 277},//float(float modidx, float framenum) frameduration = #277 (FTE_CSQC_SKELETONOBJECTS)
|
|
{"frameforaction", PF_frameforaction, 0},//float(float modidx, int actionid) frameforaction = #0
|
|
{"processmodelevents", PF_processmodelevents, 0},
|
|
{"getnextmodelevent", PF_getnextmodelevent, 0},
|
|
{"getmodeleventidx", PF_getmodeleventidx, 0},
|
|
//gap
|
|
{"hash_createtab", PF_hash_createtab, 287},
|
|
{"hash_destroytab", PF_hash_destroytab, 288},
|
|
{"hash_add", PF_hash_add, 289},
|
|
{"hash_get", PF_hash_get, 290},
|
|
{"hash_delete", PF_hash_delete, 291},
|
|
{"hash_getkey", PF_hash_getkey, 292},
|
|
{"hash_getcb", PF_hash_getcb, 293},
|
|
{"checkcommand", PF_checkcommand, 294},
|
|
{"argescape", PF_argescape, 295},
|
|
//gap
|
|
{"clearscene", PF_m_clearscene, 300},
|
|
// {"addentities", PF_Fixme, 301},
|
|
{"addentity", PF_m_addentity, 302},//FIXME: needs setmodel, origin, angles, colormap(eep), frame etc, skin,
|
|
{"addentity_lighting", PF_m_addentity_lighting, 0},
|
|
#ifdef CSQC_DAT
|
|
{"setproperty", PF_R_SetViewFlag, 303},//should be okay to share
|
|
#endif
|
|
{"renderscene", PF_m_renderscene, 304},//too module-specific
|
|
// {"dynamiclight_add", PF_R_DynamicLight_Add, 305},//should be okay to share
|
|
{"R_BeginPolygon", PF_R_PolygonBegin, 306},//useful for 2d stuff
|
|
{"R_PolygonVertex", PF_R_PolygonVertex, 307},
|
|
{"R_EndPolygon", PF_R_PolygonEnd, 308},
|
|
#ifdef CSQC_DAT
|
|
{"getproperty", PF_R_GetViewFlag, 309},//should be okay to share
|
|
#endif
|
|
//unproject 310
|
|
//project 311
|
|
|
|
#ifdef CSQC_DAT
|
|
{"r_uploadimage", PF_CL_uploadimage, 0},
|
|
#endif
|
|
{"r_readimage", PF_CL_readimage, 0},
|
|
|
|
|
|
{"print_csqc", PF_print, 339},
|
|
{"keynumtostring_csqc", PF_cl_keynumtostring, 340},
|
|
{"stringtokeynum_csqc", PF_cl_stringtokeynum, 341},
|
|
{"getkeybind", PF_cl_getkeybind, 342},
|
|
{"setcursormode", PF_cl_setcursormode, 343},
|
|
{"getcursormode", PF_cl_getcursormode, 0},
|
|
{"setmousepos", PF_cl_setmousepos, 0},
|
|
|
|
|
|
{"clipboard_get", PF_m_clipboard_get, 0},
|
|
{"clipboard_set", PF_cl_clipboard_set, 0},
|
|
|
|
// {NULL, PF_Fixme, 344},
|
|
// {NULL, PF_Fixme, 345},
|
|
// {NULL, PF_Fixme, 346},
|
|
// {NULL, PF_Fixme, 347},
|
|
// {NULL, PF_Fixme, 348},
|
|
{"setlocaluserinfo", PF_cl_setlocaluserinfo, 0},
|
|
{"getlocaluserinfo", PF_cl_getlocaluserinfostring, 0},
|
|
{"setlocaluserinfoblob", PF_cl_setlocaluserinfo, 0},
|
|
{"getlocaluserinfoblob", PF_cl_getlocaluserinfoblob, 0},
|
|
{"isdemo", PF_isdemo, 349},
|
|
// {NULL, PF_Fixme, 350},
|
|
// {NULL, PF_Fixme, 351},
|
|
{"registercommand", PF_menu_registercommand, 352},
|
|
{"wasfreed", PF_WasFreed, 353},
|
|
{"serverkey", PF_cl_serverkey, 354}, // #354 string(string key) serverkey;
|
|
{"serverkeyfloat", PF_cl_serverkeyfloat, 0}, // #0 float(string key) serverkeyfloat;
|
|
{"serverkeyblob", PF_cl_serverkeyblob, 0},
|
|
#ifdef HAVE_MEDIA_DECODER
|
|
{"videoplaying", PF_cs_media_getstate, 355},
|
|
#endif
|
|
{"findfont", PF_CL_findfont, 356},
|
|
{"loadfont", PF_CL_loadfont, 357},
|
|
//gap
|
|
// {"dynamiclight_get", PF_R_DynamicLight_Get, 372},
|
|
// {"dynamiclight_set", PF_R_DynamicLight_Set, 373},
|
|
// {NULL, PF_Fixme, 374},
|
|
// {NULL, PF_Fixme, 375},
|
|
{"setcustomskin", PF_m_setcustomskin, 376},
|
|
//gap
|
|
{"memalloc", PF_memalloc, 384},
|
|
{"memfree", PF_memfree, 385},
|
|
{"memcmp", PF_memcmp, 0},
|
|
{"memcpy", PF_memcpy, 386},
|
|
{"memfill8", PF_memfill8, 387},
|
|
{"memgetval", PF_memgetval, 388},
|
|
{"memsetval", PF_memsetval, 389},
|
|
{"memptradd", PF_memptradd, 390},
|
|
{"memstrsize", PF_memstrsize, 0},
|
|
{"con_getset", PF_SubConGetSet, 391},
|
|
{"con_printf", PF_SubConPrintf, 392},
|
|
{"con_draw", PF_SubConDraw, 393},
|
|
{"con_input", PF_SubConInput, 394},
|
|
{"setwindowcaption", PF_cl_setwindowcaption, 0},
|
|
{"cvars_haveunsaved", PF_cvars_haveunsaved, 0},
|
|
//gap
|
|
// {"writebyte, PF_Fixme, 401},
|
|
// {"writechar, PF_Fixme, 402},
|
|
// {"writeshort, PF_Fixme, 403},
|
|
// {"writelong, PF_Fixme, 404},
|
|
// {"writeangle, PF_Fixme, 405},
|
|
// {"writecoord, PF_Fixme, 406},
|
|
// {"writestring, PF_Fixme, 407},
|
|
// {"writeentity, PF_Fixme, 408},
|
|
//gap
|
|
{"buf_create", PF_buf_create, 440},
|
|
{"buf_del", PF_buf_del, 441},
|
|
{"buf_getsize", PF_buf_getsize, 442},
|
|
{"buf_copy", PF_buf_copy, 443},
|
|
{"buf_sort", PF_buf_sort, 444},
|
|
{"buf_implode", PF_buf_implode, 445},
|
|
{"bufstr_get", PF_bufstr_get, 446},
|
|
{"bufstr_set", PF_bufstr_set, 447},
|
|
{"bufstr_add", PF_bufstr_add, 448},
|
|
{"bufstr_free", PF_bufstr_free, 449},
|
|
// {NULL, PF_Fixme, 450},
|
|
{"iscachedpic", PF_CL_is_cached_pic, 451},
|
|
{"precache_pic", PF_CL_precache_pic, 452},
|
|
{"free_pic", PF_CL_free_pic, 453},
|
|
{"drawcharacter", PF_CL_drawcharacter, 454},
|
|
{"drawrawstring", PF_CL_drawrawstring, 455},
|
|
{"drawpic", PF_CL_drawpic, 456},
|
|
{"drawrotpic", PF_CL_drawrotpic, 0},
|
|
{"drawfill", PF_CL_drawfill, 457},
|
|
{"drawsetcliparea", PF_CL_drawsetcliparea, 458},
|
|
{"drawresetcliparea", PF_CL_drawresetcliparea, 459},
|
|
{"drawgetimagesize", PF_CL_drawgetimagesize, 460},
|
|
#ifdef HAVE_MEDIA_DECODER
|
|
{"cin_open", PF_cs_media_create, 461},
|
|
{"cin_close", PF_cs_media_destroy, 462},
|
|
{"cin_setstate", PF_cs_media_setstate, 463},
|
|
{"cin_getstate", PF_cs_media_getstate, 464},
|
|
{"cin_restart", PF_cs_media_restart, 465},
|
|
#endif
|
|
{"drawline", PF_CL_drawline, 466},
|
|
{"drawstring", PF_CL_drawcolouredstring, 467},
|
|
{"stringwidth", PF_CL_stringwidth, 468},
|
|
{"drawsubpic", PF_CL_drawsubpic, 469},
|
|
{"drawrotsubpic", PF_CL_drawrotsubpic, 0},
|
|
{"drawtextfield", PF_CL_DrawTextField, 0},
|
|
|
|
#ifdef HAVE_LEGACY
|
|
{"drawrotpic_dp", PF_CL_drawrotpic_dp, 470},
|
|
#endif
|
|
//MERGES WITH CLIENT+SERVER BUILTIN MAPPINGS BELOW
|
|
{"asin", PF_asin, 471},
|
|
{"acos", PF_acos, 472},
|
|
{"atan", PF_atan, 473},
|
|
{"atan2", PF_atan2, 474},
|
|
{"tan", PF_tan, 475},
|
|
{"strlennocol", PF_strlennocol, 476},
|
|
{"strdecolorize", PF_strdecolorize, 477},
|
|
{"strftime", PF_strftime, 478},
|
|
{"tokenizebyseparator", PF_tokenizebyseparator, 479},
|
|
{"strtolower", PF_strtolower, 480},
|
|
{"strtoupper", PF_strtoupper, 481},
|
|
{"csqc_cvar_defstring", PF_cvar_defstring, 482},
|
|
// {NULL, PF_Fixme, 483},
|
|
{"strreplace", PF_strreplace, 484},
|
|
{"strireplace", PF_strireplace, 485},
|
|
// {NULL, PF_Fixme, 486},
|
|
#ifdef HAVE_MEDIA_DECODER
|
|
{"gecko_create", PF_cs_media_create, 487},
|
|
{"gecko_destroy", PF_cs_media_destroy, 488},
|
|
{"gecko_navigate", PF_cs_media_command, 489},
|
|
{"gecko_keyevent", PF_cs_media_keyevent, 490},
|
|
{"gecko_mousemove", PF_cs_media_mousemove, 491},
|
|
{"gecko_resize", PF_cs_media_resize, 492},
|
|
{"gecko_get_texture_extent",PF_cs_media_get_texture_extent,493},
|
|
{"gecko_getproperty", PF_cs_media_getproperty, 0},
|
|
#endif
|
|
{"crc16", PF_crc16, 494},
|
|
{"cvar_type", PF_cvar_type, 495},
|
|
{"numentityfields", PF_numentityfields, 496},
|
|
{"findentityfield", PF_findentityfield, 0},
|
|
{"entityfieldref", PF_entityfieldref, 0},
|
|
{"entityfieldname", PF_entityfieldname, 497},
|
|
{"entityfieldtype", PF_entityfieldtype, 498},
|
|
{"getentityfieldstring", PF_getentityfieldstring, 499},
|
|
{"putentityfieldstring", PF_putentityfieldstring, 500},
|
|
// {NULL, PF_Fixme, 501},
|
|
// {NULL, PF_Fixme, 502},
|
|
{"whichpack", PF_whichpack, 503},
|
|
//gap
|
|
{"uri_escape", PF_uri_escape, 510},
|
|
{"uri_unescape", PF_uri_unescape, 511},
|
|
{"base64encode", PF_base64encode, 0},
|
|
{"base64decode", PF_base64decode, 0},
|
|
{"num_for_edict", PF_etof, 512},
|
|
{"uri_get", PF_uri_get, 513},
|
|
{"uri_post", PF_uri_get, 513},
|
|
{"tokenize_console", PF_tokenize_console, 514},
|
|
{"argv_start_index", PF_argv_start_index, 515},
|
|
{"argv_end_index", PF_argv_end_index, 516},
|
|
{"buf_cvarlist", PF_buf_cvarlist, 517},
|
|
{"cvar_description", PF_cvar_description, 518},
|
|
//gap
|
|
{"log", PF_Logarithm, 532},
|
|
// {"getsoundtime", PF_Fixme, 533},
|
|
{"soundlength", PF_soundlength, 534},
|
|
{"buf_loadfile", PF_buf_loadfile, 535},
|
|
{"buf_writefile", PF_buf_writefile, 536},
|
|
{"bufstr_find", PF_bufstr_find, 537},
|
|
// {"matchpattern", PF_Fixme, 538},
|
|
//gap
|
|
{"setkeydest", PF_cl_setkeydest, 601},
|
|
{"getkeydest", PF_cl_getkeydest, 602},
|
|
{"setmousetarget", PF_cl_setmousetarget, 603},
|
|
{"getmousetarget", PF_cl_getmousetarget, 604},
|
|
{"callfunction", PF_callfunction, 605},
|
|
{"writetofile", PF_writetofile, 606},
|
|
{"isfunction", PF_isfunction, 607},
|
|
{"getresolution", PF_cl_getresolution, 608},
|
|
{"keynumtostring", PF_cl_keynumtostring, 609},
|
|
{"findkeysforcommand", PF_cl_findkeysforcommand, 610},
|
|
{"findkeysforcommandex", PF_cl_findkeysforcommandex, 0},
|
|
{"gethostcachevalue", PF_cl_gethostcachevalue, 611},
|
|
{"gethostcachestring", PF_cl_gethostcachestring, 612},
|
|
{"parseentitydata", PF_parseentitydata, 613},
|
|
{"generateentitydata", PF_generateentitydata, 0},
|
|
|
|
{"stringtokeynum", PF_cl_stringtokeynum, 614},
|
|
|
|
{"resethostcachemasks", PF_cl_resethostcachemasks, 615},
|
|
{"sethostcachemaskstring", PF_cl_sethostcachemaskstring,616},
|
|
{"sethostcachemasknumber", PF_cl_sethostcachemasknumber,617},
|
|
{"resorthostcache", PF_cl_resorthostcache, 618},
|
|
{"sethostcachesort", PF_cl_sethostcachesort, 619},
|
|
{"refreshhostcache", PF_cl_refreshhostcache, 620},
|
|
{"gethostcachenumber", PF_cl_gethostcachenumber, 621},
|
|
{"gethostcacheindexforkey", PF_cl_gethostcacheindexforkey,622},
|
|
{"addwantedhostcachekey", PF_cl_addwantedhostcachekey,623},
|
|
#ifdef CL_MASTER
|
|
{"getextresponse", PF_cl_getextresponse, 624},
|
|
#endif
|
|
{"netaddress_resolve", PF_netaddress_resolve, 625},
|
|
{"getgamedirinfo", PF_cl_getgamedirinfo, 626},
|
|
#ifdef PACKAGEMANAGER
|
|
{"getpackagemanagerinfo", PF_cl_getpackagemanagerinfo,0},
|
|
#endif
|
|
{"sprintf", PF_sprintf, 627},
|
|
// {NULL, PF_Fixme, 628},
|
|
// {NULL, PF_Fixme, 629},
|
|
{"setkeybind", PF_cl_setkeybind, 630},
|
|
{"getbindmaps", PF_cl_GetBindMap, 631},
|
|
{"setbindmaps", PF_cl_SetBindMap, 632},
|
|
{"crypto_getkeyfp", PF_crypto_getkeyfp, 633},
|
|
{"crypto_getidfp", PF_crypto_getidfp, 634},
|
|
{"crypto_getencryptlevel", PF_crypto_getencryptlevel, 635},
|
|
{"crypto_getmykeyfp", PF_crypto_getmykeyfp, 636},
|
|
{"crypto_getmyidfp", PF_crypto_getmyidfp, 637},
|
|
// {NULL, PF_Fixme, 638},
|
|
{"digest_hex", PF_digest_hex, 639},
|
|
{"digest_ptr", PF_digest_ptr, 0},
|
|
// {NULL, PF_Fixme, 640},
|
|
{"crypto_getmyidstatus", PF_crypto_getmyidstatus, 641},
|
|
// {"coverage", PF_Fixme, 642},
|
|
{"crypto_getidstatus", PF_crypto_getidstatus, 643},
|
|
// {NULL, PF_Fixme, 644},
|
|
// {NULL, PF_Fixme, 645},
|
|
// {NULL, PF_Fixme, 646},
|
|
// {NULL, PF_Fixme, 647},
|
|
// {NULL, PF_Fixme, 648},
|
|
// {NULL, PF_Fixme, 649},
|
|
{"fcopy", PF_fcopy, 650},
|
|
{"frename", PF_frename, 651},
|
|
{"fremove", PF_fremove, 652},
|
|
{"fexists", PF_fexists, 653},
|
|
{"rmtree", PF_rmtree, 654},
|
|
|
|
{"stachievement_unlock", PF_Fixme, 730}, // EXT_STEAM_REKI
|
|
{"stachievement_query", PF_Fixme, 731}, // EXT_STEAM_REKI
|
|
{"ststat_setvalue", PF_Fixme, 732}, // EXT_STEAM_REKI
|
|
{"ststat_increment", PF_Fixme, 733}, // EXT_STEAM_REKI
|
|
{"ststat_query", PF_Fixme, 734}, // EXT_STEAM_REKI
|
|
{"stachievement_register", PF_Fixme, 735}, // EXT_STEAM_REKI
|
|
{"ststat_register", PF_Fixme, 736}, // EXT_STEAM_REKI
|
|
{"controller_query", PF_cl_gp_querywithcb, 740}, // EXT_CONTROLLER_REKI
|
|
{"controller_rumble", PF_cl_gp_rumble, 741}, // EXT_CONTROLLER_REKI
|
|
{"controller_rumbletriggers",PF_cl_gp_rumbletriggers, 742}, // EXT_CONTROLLER_REKI
|
|
|
|
{"gp_getlayout", PF_cl_gp_getbuttontype, 0}, // #0 float(float devid) gp_getbuttontype
|
|
{"gp_rumble", PF_cl_gp_rumble, 0}, // #0 void(float devid, float amp_low, float amp_high, float duration) gp_rumble
|
|
{"gp_rumbletriggers", PF_cl_gp_rumbletriggers, 0}, // #0 void(float devid, float left, float right, float duration) gp_rumbletriggers
|
|
{"gp_setledcolor", PF_cl_gp_setledcolor, 0}, // #0 void(float devid, float red, float green, float blue) gp_setledcolor
|
|
{"gp_settriggerfx", PF_cl_gp_settriggerfx, 0}, // #0 void(float devid, const void *data, int size) gp_settriggerfx
|
|
|
|
{NULL}
|
|
};
|
|
static builtin_t menu_builtins[1024];
|
|
|
|
|
|
int MP_BuiltinValid(const char *name, int num)
|
|
{
|
|
int i;
|
|
for (i = 0; BuiltinList[i].name; i++)
|
|
{
|
|
if (BuiltinList[i].ebfsnum == num)
|
|
{
|
|
if (!strcmp(BuiltinList[i].name, name))
|
|
{
|
|
if (/*BuiltinList[i].bifunc == PF_NoMenu ||*/ BuiltinList[i].bifunc == PF_Fixme)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void MP_SetupBuiltins(void)
|
|
{
|
|
int i;
|
|
for (i = 0; i < sizeof(menu_builtins)/sizeof(menu_builtins[0]); i++)
|
|
menu_builtins[i] = PF_Fixme;
|
|
for (i = 0; BuiltinList[i].bifunc; i++)
|
|
{
|
|
if (BuiltinList[i].ebfsnum)
|
|
menu_builtins[BuiltinList[i].ebfsnum] = BuiltinList[i].bifunc;
|
|
}
|
|
}
|
|
|
|
static int PDECL PR_Menu_MapNamedBuiltin(pubprogfuncs_t *progfuncs, int headercrc, const char *builtinname)
|
|
{
|
|
int i, binum;
|
|
for (i = 0;BuiltinList[i].name;i++)
|
|
{
|
|
if (!strcmp(BuiltinList[i].name, builtinname) && BuiltinList[i].bifunc != PF_Fixme)
|
|
{
|
|
for (binum = sizeof(menu_builtins)/sizeof(menu_builtins[0]); --binum; )
|
|
{
|
|
if (menu_builtins[binum] && menu_builtins[binum] != PF_Fixme && BuiltinList[i].bifunc)
|
|
continue;
|
|
menu_builtins[binum] = BuiltinList[i].bifunc;
|
|
return binum;
|
|
}
|
|
Con_Printf("No more builtin slots to allocate for %s\n", builtinname);
|
|
break;
|
|
}
|
|
}
|
|
Con_DPrintf("Unknown menu builtin: %s\n", builtinname);
|
|
return 0;
|
|
}
|
|
|
|
static qboolean MP_MouseMove(menu_t *menu, qboolean isabs, unsigned int devid, float xdelta, float ydelta)
|
|
{
|
|
void *pr_globals;
|
|
|
|
if (!menu_world.progs || !mpfuncs.inputevent)
|
|
return false;
|
|
|
|
if (setjmp(mp_abort))
|
|
return false;
|
|
inmenuprogs++;
|
|
pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
G_FLOAT(OFS_PARM0) = isabs?CSIE_MOUSEABS:CSIE_MOUSEDELTA;
|
|
G_FLOAT(OFS_PARM1) = (xdelta * vid.width) / vid.pixelwidth;
|
|
G_FLOAT(OFS_PARM2) = (ydelta * vid.height) / vid.pixelheight;
|
|
G_FLOAT(OFS_PARM3) = devid;
|
|
PR_ExecuteProgram (menu_world.progs, mpfuncs.inputevent);
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
inmenuprogs--;
|
|
return G_FLOAT(OFS_RETURN);
|
|
}
|
|
|
|
static qboolean MP_JoystickAxis(menu_t *menu, unsigned int devid, int axis, float value)
|
|
{
|
|
void *pr_globals;
|
|
if (!menu_world.progs || !mpfuncs.inputevent)
|
|
return false;
|
|
if (setjmp(mp_abort))
|
|
return false;
|
|
inmenuprogs++;
|
|
pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
G_FLOAT(OFS_PARM0) = CSIE_JOYAXIS;
|
|
G_FLOAT(OFS_PARM1) = axis;
|
|
G_FLOAT(OFS_PARM2) = value;
|
|
G_FLOAT(OFS_PARM3) = devid;
|
|
PR_ExecuteProgram (menu_world.progs, mpfuncs.inputevent);
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
inmenuprogs--;
|
|
return G_FLOAT(OFS_RETURN);
|
|
}
|
|
static qboolean MP_KeyEvent(menu_t *menu, qboolean isdown, unsigned int devid, int key, int unicode)
|
|
{
|
|
qboolean result;
|
|
|
|
#ifdef TEXTEDITOR
|
|
if (editormodal)
|
|
return false;
|
|
#endif
|
|
|
|
if (setjmp(mp_abort))
|
|
return true;
|
|
|
|
if (isdown)
|
|
{
|
|
#ifndef NOBUILTINMENUS
|
|
#ifdef _DEBUG
|
|
if (key == 'c')
|
|
{
|
|
if ((keydown[K_LCTRL] || keydown[K_RCTRL]) && (keydown[K_LSHIFT] || keydown[K_RSHIFT]))
|
|
{
|
|
MP_Shutdown();
|
|
M_Init_Internal();
|
|
return true;
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
mpkeysdown[key>>3] |= (1<<(key&7));
|
|
}
|
|
else
|
|
{ //don't fire up events if it was not actually pressed.
|
|
if (key && !(mpkeysdown[key>>3] & (1<<(key&7))))
|
|
return false;
|
|
mpkeysdown[key>>3] &= ~(1<<(key&7));
|
|
}
|
|
|
|
menutime = Sys_DoubleTime();
|
|
if (menu_world.g.time)
|
|
*menu_world.g.time = menutime;
|
|
|
|
inmenuprogs++;
|
|
if (mpfuncs.inputevent)
|
|
{
|
|
void *pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
G_FLOAT(OFS_PARM0) = isdown?CSIE_KEYDOWN:CSIE_KEYUP;
|
|
G_FLOAT(OFS_PARM1) = MP_TranslateFTEtoQCCodes(key);
|
|
G_FLOAT(OFS_PARM2) = unicode;
|
|
G_FLOAT(OFS_PARM3) = devid;
|
|
if (isdown)
|
|
{
|
|
qcinput_scan = G_FLOAT(OFS_PARM1);
|
|
qcinput_unicode = G_FLOAT(OFS_PARM2);
|
|
}
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.inputevent);
|
|
result = G_FLOAT(OFS_RETURN);
|
|
if (!result && key == K_TOUCH)
|
|
{ //convert touches to mouse, for compat. gestures are untranslated but expected to be ignored.
|
|
G_FLOAT(OFS_PARM0) = isdown?CSIE_KEYDOWN:CSIE_KEYUP;
|
|
G_FLOAT(OFS_PARM1) = MP_TranslateFTEtoQCCodes(K_MOUSE1);
|
|
G_FLOAT(OFS_PARM2) = unicode;
|
|
G_FLOAT(OFS_PARM3) = devid;
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.inputevent);
|
|
result = G_FLOAT(OFS_RETURN);
|
|
}
|
|
qcinput_scan = 0;
|
|
qcinput_unicode = 0;
|
|
}
|
|
else if (isdown && mpfuncs.keydown)
|
|
{
|
|
void *pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
if (key == K_TOUCH)
|
|
key = K_MOUSE1; //old api doesn't expect touches nor provides feedback for emulation. make sure stuff works.
|
|
G_FLOAT(OFS_PARM0) = MP_TranslateFTEtoQCCodes(key);
|
|
G_FLOAT(OFS_PARM1) = unicode;
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.keydown);
|
|
result = true; //doesn't have a return value, so if the menu is set up for key events, all events are considered eaten.
|
|
}
|
|
else if (!isdown && mpfuncs.keyup)
|
|
{
|
|
void *pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
if (key == K_TOUCH)
|
|
key = K_MOUSE1; //old api doesn't expect touches.
|
|
G_FLOAT(OFS_PARM0) = MP_TranslateFTEtoQCCodes(key);
|
|
G_FLOAT(OFS_PARM1) = unicode;
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.keyup);
|
|
result = false; // doesn't have a return value, so don't block it
|
|
}
|
|
else
|
|
result = false;
|
|
inmenuprogs--;
|
|
|
|
if (R2D_Flush) //shouldn't be needed, but in case the mod is buggy.
|
|
R2D_Flush();
|
|
return result;
|
|
}
|
|
|
|
void MP_Shutdown (void)
|
|
{
|
|
func_t temp;
|
|
if (!menu_world.progs)
|
|
return;
|
|
|
|
menuqc.release = NULL; //don't notify
|
|
Menu_Unlink(&menuqc, false);
|
|
/*
|
|
{
|
|
char *buffer;
|
|
int size = 1024*1024*8;
|
|
buffer = Z_Malloc(size);
|
|
menuprogs->save_ents(menuprogs, buffer, &size, 1);
|
|
COM_WriteFile("menucore.txt", buffer, size);
|
|
Z_Free(buffer);
|
|
}
|
|
*/
|
|
temp = mpfuncs.shutdown;
|
|
mpfuncs.shutdown = 0;
|
|
if (temp && !inmenuprogs)
|
|
PR_ExecuteProgram(menu_world.progs, temp);
|
|
|
|
PR_Common_Shutdown(menu_world.progs, false);
|
|
menu_world.progs->Shutdown(menu_world.progs);
|
|
memset(&menu_world, 0, sizeof(menu_world));
|
|
PR_ReleaseFonts(kdm_menu);
|
|
|
|
#ifdef CL_MASTER
|
|
Master_ClearMasks();
|
|
#endif
|
|
|
|
Cmd_RemoveCommands(MP_ConsoleCommand_f);
|
|
|
|
Key_Dest_Remove(kdm_menu);
|
|
key_dest_absolutemouse &= ~kdm_menu;
|
|
}
|
|
|
|
static void MP_TryRelease(menu_t *m, qboolean force)
|
|
{
|
|
if (inmenuprogs)
|
|
return; //if the qc asked for it, the qc probably already knows about it. don't recurse.
|
|
MP_Toggle(0);
|
|
|
|
if (force && Menu_IsLinked(m))
|
|
{
|
|
Con_Printf(CON_ERROR"Menuqc retook key grabs when ordered to yield. Killing.\n");
|
|
MP_Shutdown();
|
|
M_Init_Internal();
|
|
}
|
|
}
|
|
|
|
void *VARGS PR_CB_Malloc(int size); //these functions should be tracked by the library reliably, so there should be no need to track them ourselves.
|
|
void VARGS PR_CB_Free(void *mem);
|
|
|
|
//Any menu builtin error or anything like that will come here.
|
|
void VARGS Menu_Abort (char *format, ...)
|
|
{
|
|
va_list argptr;
|
|
char string[1024];
|
|
|
|
va_start (argptr, format);
|
|
vsnprintf (string,sizeof(string)-1, format,argptr);
|
|
va_end (argptr);
|
|
|
|
Con_Printf("Menu_Abort: %s\nShutting down menu.dat\n", string);
|
|
|
|
if (pr_menu_coreonerror.value)
|
|
{
|
|
char *buffer;
|
|
size_t size = 1024*1024*8;
|
|
buffer = Z_Malloc(size);
|
|
menu_world.progs->save_ents(menu_world.progs, buffer, &size, size, 3);
|
|
COM_WriteFile("menucore.txt", FS_GAMEONLY, buffer, size);
|
|
Z_Free(buffer);
|
|
}
|
|
|
|
MP_Shutdown();
|
|
M_Init_Internal();
|
|
|
|
if (inmenuprogs) //something in the menu caused the problem, so...
|
|
{
|
|
inmenuprogs = 0;
|
|
longjmp(mp_abort, 1);
|
|
}
|
|
}
|
|
|
|
void MP_CvarChanged(cvar_t *var)
|
|
{
|
|
if (menu_world.progs)
|
|
{
|
|
PR_AutoCvar(menu_world.progs, var);
|
|
}
|
|
}
|
|
|
|
pbool PDECL Menu_CheckHeaderCrc(pubprogfuncs_t *inst, progsnum_t idx, int crc, const char *filename)
|
|
{
|
|
if (crc == 10020)
|
|
return true; //its okay
|
|
Con_Printf("progs crc is invalid for %s\n", filename);
|
|
if (crc == 12776)
|
|
{ //whoever wrote wrath fucked up.
|
|
Con_Printf("(please correct .src include orders)\n");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void *PDECL MP_PRReadFile (const char *path, qbyte *(PDECL *buf_get)(void *buf_ctx, size_t size), void *buf_ctx, size_t *size, pbool issource)
|
|
{
|
|
flocation_t loc;
|
|
if (FS_FLocateFile(path, FSLF_IFFOUND|FSLF_SECUREONLY, &loc))
|
|
{
|
|
qbyte *buffer = NULL;
|
|
vfsfile_t *file = FS_OpenReadLocation(path, &loc);
|
|
if (file)
|
|
{
|
|
*size = loc.len;
|
|
buffer = buf_get(buf_ctx, *size);
|
|
if (buffer)
|
|
VFS_READ(file, buffer, *size);
|
|
VFS_CLOSE(file);
|
|
}
|
|
return buffer;
|
|
}
|
|
else
|
|
{
|
|
if (FS_FLocateFile(path, FSLF_IFFOUND, &loc))
|
|
Con_Printf("Not loading %s because it comes from an untrusted source\n", path);
|
|
return NULL;
|
|
}
|
|
}
|
|
static int PDECL MP_PRFileSize (const char *path)
|
|
{
|
|
flocation_t loc;
|
|
if (FS_FLocateFile(path, FSLF_IFFOUND|FSLF_SECUREONLY, &loc))
|
|
return loc.len;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
qboolean MP_Init (void)
|
|
{
|
|
struct key_cursor_s *m = &key_customcursor[kc_menuqc];
|
|
|
|
if (qrenderer == QR_NONE)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (forceqmenu.value)
|
|
{
|
|
Con_DPrintf("menu.dat disabled\n");
|
|
return false;
|
|
}
|
|
|
|
MP_SetupBuiltins();
|
|
|
|
memset(&menuc_eval, 0, sizeof(menuc_eval));
|
|
|
|
|
|
menuprogparms.progsversion = PROGSTRUCT_VERSION;
|
|
menuprogparms.ReadFile = MP_PRReadFile;//char *(*ReadFile) (char *fname, void *buffer, int *len);
|
|
menuprogparms.FileSize = MP_PRFileSize;//int (*FileSize) (char *fname); //-1 if file does not exist
|
|
menuprogparms.WriteFile = QC_WriteFile;//bool (*WriteFile) (char *name, void *data, int len);
|
|
menuprogparms.Printf = PR_Printf;//Con_Printf;//void (*printf) (char *, ...);
|
|
menuprogparms.DPrintf = PR_DPrintf;//Con_DPrintf;//void (*dprintf) (char *, ...);
|
|
menuprogparms.Sys_Error = Sys_Error;
|
|
menuprogparms.Abort = Menu_Abort;
|
|
menuprogparms.CheckHeaderCrc = Menu_CheckHeaderCrc;
|
|
menuprogparms.edictsize = sizeof(menuedict_t);
|
|
|
|
menuprogparms.entspawn = NULL;//void (*entspawn) (struct edict_s *ent); //ent has been spawned, but may not have all the extra variables (that may need to be set) set
|
|
menuprogparms.entcanfree = NULL;//bool (*entcanfree) (struct edict_s *ent); //return true to stop ent from being freed
|
|
menuprogparms.stateop = NULL;//StateOp;//void (*stateop) (float var, func_t func);
|
|
menuprogparms.cstateop = NULL;//CStateOp;
|
|
menuprogparms.cwstateop = NULL;//CWStateOp;
|
|
menuprogparms.thinktimeop = NULL;//ThinkTimeOp;
|
|
menuprogparms.MapNamedBuiltin = PR_Menu_MapNamedBuiltin;
|
|
menuprogparms.loadcompleate = NULL;//void (*loadcompleate) (int edictsize); //notification to reset any pointers.
|
|
|
|
menuprogparms.memalloc = PR_CB_Malloc;//void *(*memalloc) (int size); //small string allocation malloced and freed randomly
|
|
menuprogparms.memfree = PR_CB_Free;//void (*memfree) (void * mem);
|
|
|
|
|
|
menuprogparms.globalbuiltins = menu_builtins;//builtin_t *globalbuiltins; //these are available to all progs
|
|
menuprogparms.numglobalbuiltins = sizeof(menu_builtins) / sizeof(menu_builtins[0]);
|
|
|
|
menuprogparms.autocompile = PR_COMPILEIGNORE;//PR_COMPILEEXISTANDCHANGED;//enum {PR_NOCOMPILE, PR_COMPILENEXIST, PR_COMPILECHANGED, PR_COMPILEALWAYS} autocompile;
|
|
|
|
menuprogparms.gametime = &menutime;
|
|
#ifdef MULTITHREAD
|
|
menuprogparms.usethreadedgc = pr_gc_threaded.ival;
|
|
#endif
|
|
|
|
menuprogparms.edicts = (struct edict_s **)&menu_edicts;
|
|
menuprogparms.num_edicts = &num_menu_edicts;
|
|
|
|
menuprogparms.useeditor = QCEditor;//void (*useeditor) (char *filename, int line, int nump, char **parms);
|
|
menuprogparms.user = &menu_world;
|
|
menu_world.keydestmask = kdm_menu;
|
|
|
|
//default to free mouse+hidden cursor, to match dp's default setting, and because its generally the right thing for a menu.
|
|
Q_strncpyz(m->name, "none", sizeof(m->name));
|
|
m->hotspot[0] = 0;
|
|
m->hotspot[1] = 0;
|
|
m->scale = 1;
|
|
m->dirty = true;
|
|
|
|
menuqc.cursor = m;
|
|
menuqc.drawmenu = NULL; //menuqc sucks!
|
|
menuqc.mousemove = MP_MouseMove;
|
|
menuqc.keyevent = MP_KeyEvent;
|
|
menuqc.joyaxis = MP_JoystickAxis;
|
|
menuqc.release = MP_TryRelease;
|
|
|
|
menutime = Sys_DoubleTime();
|
|
if (!menu_world.progs)
|
|
{
|
|
vec3_t fwd,rht,up;
|
|
int mprogs;
|
|
Con_DPrintf("Initializing menu.dat\n");
|
|
menu_world.Get_CModel = MP_GetCModel;
|
|
menu_world.Get_FrameState = MP_Get_FrameState;
|
|
|
|
menu_world.progs = InitProgs(&menuprogparms);
|
|
PR_Configure(menu_world.progs, PR_ReadBytesString(pr_menu_memsize.string), 1, pr_enable_profiling.ival);
|
|
mprogs = PR_LoadProgs(menu_world.progs, "menu.dat");
|
|
if (mprogs < 0) //no per-progs builtins.
|
|
{
|
|
//failed to load or something
|
|
// CloseProgs(menu_world.progs);
|
|
// menuprogs = NULL;
|
|
return false;
|
|
}
|
|
if (setjmp(mp_abort))
|
|
{
|
|
Con_DPrintf("Failed to initialize menu.dat\n");
|
|
inmenuprogs = false;
|
|
return false;
|
|
}
|
|
inmenuprogs++;
|
|
|
|
M_DeInit_Internal();
|
|
|
|
PF_InitTempStrings(menu_world.progs);
|
|
|
|
menu_world.g.self = (int*)PR_FindGlobal(menu_world.progs, "self", 0, NULL);
|
|
menu_world.g.time = (float*)PR_FindGlobal(menu_world.progs, "time", 0, NULL);
|
|
if (menu_world.g.time)
|
|
*menu_world.g.time = Sys_DoubleTime();
|
|
menu_world.g.frametime = (float*)PR_FindGlobal(menu_world.progs, "frametime", 0, NULL);
|
|
|
|
menu_world.g.v_forward = (float*)PR_FindGlobal(menu_world.progs, "v_forward", 0, NULL); if (!menu_world.g.v_forward) menu_world.g.v_forward = fwd;
|
|
menu_world.g.v_right = (float*)PR_FindGlobal(menu_world.progs, "v_right", 0, NULL); if (!menu_world.g.v_right) menu_world.g.v_right = rht;
|
|
menu_world.g.v_up = (float*)PR_FindGlobal(menu_world.progs, "v_up", 0, NULL); if (!menu_world.g.v_up) menu_world.g.v_up = up;
|
|
|
|
menu_world.g.drawfont = (float*)PR_FindGlobal(menu_world.progs, "drawfont", 0, NULL);
|
|
menu_world.g.drawfontscale = (float*)PR_FindGlobal(menu_world.progs, "drawfontscale", 0, NULL);
|
|
|
|
PR_ProgsAdded(menu_world.progs, mprogs, "menu.dat");
|
|
|
|
//ensure that there's space for these fields in.
|
|
//other fields will always be referenced/defined by the qc, or 0.
|
|
PR_RegisterFieldVar(menu_world.progs, ev_string, "model", -1, -1);
|
|
PR_RegisterFieldVar(menu_world.progs, ev_vector, "origin", -1, -1);
|
|
PR_RegisterFieldVar(menu_world.progs, ev_float, "skinobject", -1, -1);
|
|
|
|
menuentsize = PR_InitEnts(menu_world.progs, 8192);
|
|
|
|
|
|
//'world' edict
|
|
// EDICT_NUM_PB(menu_world.progs, 0)->readonly = true;
|
|
EDICT_NUM_PB(menu_world.progs, 0)->ereftype = ER_ENTITY;
|
|
|
|
|
|
mpfuncs.init = PR_FindFunction(menu_world.progs, "m_init", PR_ANY);
|
|
mpfuncs.shutdown = PR_FindFunction(menu_world.progs, "m_shutdown", PR_ANY);
|
|
{
|
|
int args = 0;
|
|
qbyte *argsizes = NULL;
|
|
mpfuncs.draw = PR_FindFunction(menu_world.progs, "m_draw", PR_ANY);
|
|
menu_world.progs->GetFunctionInfo(menu_world.progs, mpfuncs.draw, &args, &argsizes, NULL, NULL, 0);
|
|
mpfuncs.fuckeddrawsizes = (args == 2 && argsizes[0] == 1 && argsizes[1] == 1);
|
|
}
|
|
mpfuncs.drawloading = PR_FindFunction(menu_world.progs, "m_drawloading", PR_ANY);
|
|
mpfuncs.inputevent = PR_FindFunction(menu_world.progs, "Menu_InputEvent", PR_ANY);
|
|
mpfuncs.keydown = PR_FindFunction(menu_world.progs, "m_keydown", PR_ANY);
|
|
mpfuncs.keyup = PR_FindFunction(menu_world.progs, "m_keyup", PR_ANY);
|
|
mpfuncs.toggle = PR_FindFunction(menu_world.progs, "m_toggle", PR_ANY);
|
|
mpfuncs.consolecommand = PR_FindFunction(menu_world.progs, "m_consolecommand", PR_ANY);
|
|
mpfuncs.gethostcachecategory = PR_FindFunction(menu_world.progs, "m_gethostcachecategory", PR_ANY);
|
|
mpfuncs.rendererrestarted = PR_FindFunction(menu_world.progs, "Menu_RendererRestarted", PR_ANY);
|
|
if (mpfuncs.init)
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.init);
|
|
inmenuprogs--;
|
|
|
|
EDICT_NUM_PB(menu_world.progs, 0)->readonly = true;
|
|
|
|
Con_DPrintf("Initialized menu.dat\n");
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void MP_GameCommand_f(void)
|
|
{
|
|
void *pr_globals;
|
|
func_t gamecommand;
|
|
if (!menu_world.progs)
|
|
return;
|
|
gamecommand = PR_FindFunction(menu_world.progs, "GameCommand", PR_ANY);
|
|
if (!gamecommand)
|
|
return;
|
|
|
|
if (setjmp(mp_abort))
|
|
return;
|
|
inmenuprogs++;
|
|
pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
(((string_t *)pr_globals)[OFS_PARM0] = PR_TempString(menu_world.progs, Cmd_Args()));
|
|
PR_ExecuteProgram (menu_world.progs, gamecommand);
|
|
inmenuprogs--;
|
|
}
|
|
|
|
qboolean MP_ConsoleCommand(const char *cmdtext)
|
|
{
|
|
void *pr_globals;
|
|
if (!menu_world.progs)
|
|
return false;
|
|
if (!mpfuncs.consolecommand)
|
|
return false;
|
|
|
|
if (setjmp(mp_abort))
|
|
return true;
|
|
inmenuprogs++;
|
|
pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
(((string_t *)pr_globals)[OFS_PARM0] = PR_TempString(menu_world.progs, cmdtext));
|
|
PR_ExecuteProgram (menu_world.progs, mpfuncs.consolecommand);
|
|
inmenuprogs--;
|
|
return G_FLOAT(OFS_RETURN);
|
|
}
|
|
|
|
void MP_CoreDump_f(void)
|
|
{
|
|
if (!menu_world.progs)
|
|
{
|
|
Con_Printf("Can't core dump, you need to be running the CSQC progs first.");
|
|
return;
|
|
}
|
|
|
|
{
|
|
size_t size = 1024*1024*8;
|
|
char *buffer = BZ_Malloc(size);
|
|
menu_world.progs->save_ents(menu_world.progs, buffer, &size, size, 3);
|
|
COM_WriteFile("menucore.txt", FS_GAMEONLY, buffer, size);
|
|
BZ_Free(buffer);
|
|
}
|
|
}
|
|
|
|
static void MP_Poke_f(void)
|
|
{
|
|
/*if (!SV_MayCheat())
|
|
Con_TPrintf ("Please set sv_cheats 1 and restart the map first.\n");
|
|
else */if (menu_world.progs && menu_world.progs->EvaluateDebugString)
|
|
Con_TPrintf("Result: %s\n", menu_world.progs->EvaluateDebugString(menu_world.progs, Cmd_Args()));
|
|
else
|
|
Con_TPrintf ("not supported.\n");
|
|
}
|
|
|
|
void MP_Breakpoint_f(void)
|
|
{
|
|
int wasset;
|
|
int isset;
|
|
char *filename = Cmd_Argv(1);
|
|
int line = atoi(Cmd_Argv(2));
|
|
|
|
if (!menu_world.progs)
|
|
{
|
|
Con_Printf("Menu not running\n");
|
|
return;
|
|
}
|
|
wasset = menu_world.progs->ToggleBreak(menu_world.progs, filename, line, 3);
|
|
isset = menu_world.progs->ToggleBreak(menu_world.progs, filename, line, 2);
|
|
|
|
if (wasset == isset)
|
|
Con_Printf("Breakpoint was not valid\n");
|
|
else if (isset)
|
|
Con_Printf("Breakpoint has been set\n");
|
|
else
|
|
Con_Printf("Breakpoint has been cleared\n");
|
|
|
|
Cvar_Set(Cvar_FindVar("pr_debugger"), "1");
|
|
}
|
|
|
|
void MP_RegisterCvarsAndCmds(void)
|
|
{
|
|
Cmd_AddCommand("coredump_menuqc", MP_CoreDump_f);
|
|
Cmd_AddCommand("menu_cmd", MP_GameCommand_f);
|
|
Cmd_AddCommand("breakpoint_menu", MP_Breakpoint_f);
|
|
#ifdef HAVE_LEGACY
|
|
Cmd_AddCommand("loadfont", CL_LoadFont_f);
|
|
#endif
|
|
|
|
Cmd_AddCommand("poke_menuqc", MP_Poke_f);
|
|
|
|
|
|
Cvar_Register(&forceqmenu, MENUPROGSGROUP);
|
|
Cvar_Register(&pr_menu_coreonerror, MENUPROGSGROUP);
|
|
Cvar_Register(&pr_menu_memsize, MENUPROGSGROUP);
|
|
}
|
|
|
|
qboolean MP_UsingGamecodeLoadingScreen(void)
|
|
{
|
|
return menu_world.progs && mpfuncs.drawloading;
|
|
}
|
|
|
|
int MP_GetServerCategory(int index)
|
|
{
|
|
int category = 0;
|
|
if (menu_world.progs && mpfuncs.gethostcachecategory)
|
|
{
|
|
void *pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
if (!setjmp(mp_abort))
|
|
{
|
|
inmenuprogs++;
|
|
G_FLOAT(OFS_PARM0) = index;
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.gethostcachecategory);
|
|
category = G_FLOAT(OFS_RETURN);
|
|
inmenuprogs--;
|
|
}
|
|
}
|
|
return category;
|
|
}
|
|
|
|
void MP_RendererRestarted(void)
|
|
{
|
|
int i;
|
|
if (!menu_world.progs)
|
|
return;
|
|
|
|
menu_world.worldmodel = cl.worldmodel;
|
|
|
|
for (i = 0; i < MAX_CSMODELS; i++)
|
|
{
|
|
cl.model_csqcprecache[i] = NULL;
|
|
}
|
|
|
|
//FIXME: registered shaders
|
|
|
|
//let the csqc know that its rendertargets got purged
|
|
if (mpfuncs.rendererrestarted)
|
|
{
|
|
void *pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
(((string_t *)pr_globals)[OFS_PARM0] = PR_TempString(menu_world.progs, rf->description));
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.rendererrestarted);
|
|
}
|
|
//in case it drew to any render targets.
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
if (*r_refdef.rt_destcolour[0].texname)
|
|
{
|
|
Q_strncpyz(r_refdef.rt_destcolour[0].texname, "", sizeof(r_refdef.rt_destcolour[0].texname));
|
|
BE_RenderToTextureUpdate2d(true);
|
|
}
|
|
}
|
|
|
|
void MP_Draw(void)
|
|
{
|
|
extern qboolean scr_drawloading;
|
|
globalvars_t *pr_globals;
|
|
if (!menu_world.progs)
|
|
return;
|
|
if (setjmp(mp_abort))
|
|
return;
|
|
|
|
menutime = Sys_DoubleTime();
|
|
if (menu_world.g.time)
|
|
*menu_world.g.time = menutime;
|
|
if (menu_world.g.frametime)
|
|
*menu_world.g.frametime = host_frametime;
|
|
|
|
inmenuprogs++;
|
|
pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
|
|
if (scr_drawloading||scr_disabled_for_loading)
|
|
{ //don't draw the menu if we're meant to be drawing a loading screen
|
|
//the menu should provide a special function if it wants to draw custom loading screens. this is for compat with old/dp/lazy/crappy menus.
|
|
if (mpfuncs.drawloading)
|
|
{
|
|
((float *)pr_globals)[OFS_PARM0+0] = vid.width;
|
|
((float *)pr_globals)[OFS_PARM0+1] = vid.height;
|
|
((float *)pr_globals)[OFS_PARM0+2] = 0;
|
|
|
|
((float *)pr_globals)[OFS_PARM1] = scr_disabled_for_loading;
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.drawloading);
|
|
}
|
|
}
|
|
else if (mpfuncs.draw)
|
|
{
|
|
if (mpfuncs.fuckeddrawsizes)
|
|
{ //pass useless sizes in two args if its a dp menu
|
|
((float *)pr_globals)[OFS_PARM0] = vid.pixelwidth;
|
|
((float *)pr_globals)[OFS_PARM0+1] = 0; //make sure its set, just in case...
|
|
((float *)pr_globals)[OFS_PARM0+2] = 0;
|
|
((float *)pr_globals)[OFS_PARM1] = vid.pixelheight;
|
|
((float *)pr_globals)[OFS_PARM1+1] = 0;
|
|
((float *)pr_globals)[OFS_PARM1+2] = 0;
|
|
}
|
|
else
|
|
{ //pass useful sizes in a 1-arg vector if its an fte menu.
|
|
((float *)pr_globals)[OFS_PARM0+0] = vid.width;
|
|
((float *)pr_globals)[OFS_PARM0+1] = vid.height;
|
|
((float *)pr_globals)[OFS_PARM0+2] = 0;
|
|
|
|
//make physical pixel counts available too, because we can.
|
|
((float *)pr_globals)[OFS_PARM1+0] = vid.pixelwidth;
|
|
((float *)pr_globals)[OFS_PARM1+1] = vid.pixelheight;
|
|
((float *)pr_globals)[OFS_PARM1+2] = 0;
|
|
}
|
|
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.draw);
|
|
}
|
|
inmenuprogs--;
|
|
}
|
|
|
|
qboolean MP_Toggle(int mode)
|
|
{
|
|
if (!menu_world.progs)
|
|
return false;
|
|
#ifdef TEXTEDITOR
|
|
if (editormodal)
|
|
return false;
|
|
#endif
|
|
|
|
if (!mode && !Key_Dest_Has(kdm_menu))
|
|
return false;
|
|
|
|
if (setjmp(mp_abort))
|
|
return false;
|
|
|
|
menutime = Sys_DoubleTime();
|
|
if (menu_world.g.time)
|
|
*menu_world.g.time = menutime;
|
|
|
|
inmenuprogs++;
|
|
if (mpfuncs.toggle)
|
|
{
|
|
void *pr_globals = PR_globals(menu_world.progs, PR_CURRENT);
|
|
G_FLOAT(OFS_PARM0) = mode;
|
|
PR_ExecuteProgram(menu_world.progs, mpfuncs.toggle);
|
|
}
|
|
if (R2D_Flush)
|
|
R2D_Flush();
|
|
inmenuprogs--;
|
|
|
|
return true;
|
|
}
|
|
#endif
|