dpvsnprintf(msg,sizeof(msg),fmt,argptr);
va_end(argptr);
- Con_Warn(msg);
+ Con_Printf(CON_WARN "%s", msg);
// TODO: either add a cvar/cmd to control the state dumping or replace some of the calls with Con_Printf [9/13/2006 Black]
- if(prvm_backtraceforwarnings.integer && recursive != realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set
+ if(prvm_backtraceforwarnings.integer && recursive != host.realtime) // NOTE: this compares to the time, just in case if PRVM_PrintState causes a Host_Error and keeps recursive set
{
- recursive = realtime;
+ recursive = host.realtime;
PRVM_PrintState(prog, 0);
recursive = -1;
}
// LadyHavoc: quite tempting to break apart this function to reuse the
// duplicated code, but I suspect it is better for performance
// this way
-void VM_FrameBlendFromFrameGroupBlend(frameblend_t *frameblend, const framegroupblend_t *framegroupblend, const dp_model_t *model, double curtime)
+void VM_FrameBlendFromFrameGroupBlend(frameblend_t *frameblend, const framegroupblend_t *framegroupblend, const model_t *model, double curtime)
{
int sub2, numframes, f, i, k;
int isfirstframegroup = true;
return;
}
- nolerp = (model->type == mod_sprite) ? !r_lerpsprites.integer : !r_lerpmodels.integer;
+ nolerp = ((model->type == mod_sprite) ? !r_lerpsprites.integer : !r_lerpmodels.integer) || (model->nolerp == true);
numframes = model->numframes;
for (k = 0, g = framegroupblend;k < MAX_FRAMEGROUPBLENDS;k++, g++)
{
}
}
-void VM_UpdateEdictSkeleton(prvm_prog_t *prog, prvm_edict_t *ed, const dp_model_t *edmodel, const frameblend_t *frameblend)
+void VM_UpdateEdictSkeleton(prvm_prog_t *prog, prvm_edict_t *ed, const model_t *edmodel, const frameblend_t *frameblend)
{
if (ed->priv.server->skeleton.model != edmodel)
{
*/
// kind of helper function
-static qboolean checkextension(prvm_prog_t *prog, const char *name)
+static qbool checkextension(prvm_prog_t *prog, const char *name)
{
- int len;
- const char *e, *start;
- len = (int)strlen(name);
+ const char **e;
for (e = prog->extensionstring;*e;e++)
{
- while (*e == ' ')
- e++;
- if (!*e)
- break;
- start = e;
- while (*e && *e != ' ')
- e++;
- if ((e - start) == len && !strncasecmp(start, name, len))
+ if(!strcasecmp(*e, name))
{
#ifdef USEODE
// special sheck for ODE
char string[VM_STRINGTEMP_LENGTH];
VM_VarString(prog, 0, string, sizeof(string));
- Con_Errorf("======%s ERROR in %s:\n%s\n", prog->name, PRVM_GetString(prog, prog->xfunction->s_name), string);
+ Con_Printf(CON_ERROR "======%s ERROR in %s:\n%s\n", prog->name, PRVM_GetString(prog, prog->xfunction->s_name), string);
ed = PRVM_PROG_TO_EDICT(PRVM_allglobaledict(self));
PRVM_ED_Print(prog, ed, NULL);
char string[VM_STRINGTEMP_LENGTH];
VM_VarString(prog, 0, string, sizeof(string));
- Con_Errorf("======OBJECT ERROR======\n"); // , prog->name, PRVM_GetString(prog->xfunction->s_name), string); // or include them? FIXME
+ Con_Printf(CON_ERROR "======OBJECT ERROR======\n"); // , prog->name, PRVM_GetString(prog->xfunction->s_name), string); // or include them? FIXME
ed = PRVM_PROG_TO_EDICT(PRVM_allglobaledict(self));
PRVM_ED_Print(prog, ed, NULL);
PRVM_ED_Free (prog, ed);
- Con_Errorf("%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", prog->name, PRVM_GetString(prog, prog->xfunction->s_name), string);
+ Con_Printf(CON_ERROR "%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", prog->name, PRVM_GetString(prog, prog->xfunction->s_name), string);
}
/*
void VM_localcmd_client(prvm_prog_t *prog)
{
char string[VM_STRINGTEMP_LENGTH];
- VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd);
+ VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd_client);
VM_VarString(prog, 0, string, sizeof(string));
Cbuf_AddText(&cmd_client, string);
}
void VM_localcmd_server(prvm_prog_t *prog)
{
char string[VM_STRINGTEMP_LENGTH];
- VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd);
+ VM_SAFEPARMCOUNTRANGE(1, 8, VM_localcmd_server);
VM_VarString(prog, 0, string, sizeof(string));
Cbuf_AddText(&cmd_server, string);
}
-static qboolean PRVM_Cvar_ReadOk(prvm_prog_t *prog, const char *string)
+static qbool PRVM_Cvar_ReadOk(prvm_prog_t *prog, const char *string)
{
cvar_t *cvar;
- cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask, false);
- return ((cvar) && ((cvar->flags & CVAR_PRIVATE) == 0));
+ cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask);
+ return ((cvar) && ((cvar->flags & CF_PRIVATE) == 0));
}
/*
cvar_t *cvar;
int ret;
- VM_SAFEPARMCOUNTRANGE(1,8,VM_cvar);
+ VM_SAFEPARMCOUNTRANGE(1, 8, VM_cvar_type);
VM_VarString(prog, 0, string, sizeof(string));
VM_CheckEmptyString(prog, string);
- cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask, true);
+ cvar = Cvar_FindVar(prog->console_cmd->cvars, string, prog->console_cmd->cvars_flagsmask);
if(!cvar)
}
ret = 1; // CVAR_EXISTS
- if(cvar->flags & CVAR_SAVE)
+ if(cvar->flags & CF_ARCHIVE)
ret |= 2; // CVAR_TYPE_SAVED
- if(cvar->flags & CVAR_PRIVATE)
+ if(cvar->flags & CF_PRIVATE)
ret |= 4; // CVAR_TYPE_PRIVATE
- if(!(cvar->flags & CVAR_ALLOCATED))
+ if(!(cvar->flags & CF_ALLOCATED))
ret |= 8; // CVAR_TYPE_ENGINE
if(cvar->description != cvar_dummy_description)
ret |= 16; // CVAR_TYPE_HASDESCRIPTION
- if(cvar->flags & CVAR_READONLY)
+ if(cvar->flags & CF_READONLY)
ret |= 32; // CVAR_TYPE_READONLY
PRVM_G_FLOAT(OFS_RETURN) = ret;
*/
void VM_coredump(prvm_prog_t *prog)
{
- cmd_state_t *cmd = cls.state == ca_dedicated ? &cmd_server : &cmd_client;
+ cmd_state_t *cmd = !host_isclient.integer ? &cmd_server : &cmd_client;
VM_SAFEPARMCOUNT(0,VM_coredump);
Cbuf_AddText(cmd, "prvm_edicts ");
flags = prog->argc >= 3 ? (int)PRVM_G_FLOAT(OFS_PARM2) : 0;
PRVM_G_FLOAT(OFS_RETURN) = 0;
- if(flags > CVAR_MAXFLAGSVAL)
+ if(flags > CF_MAXFLAGSVAL)
return;
// first check to see if it has already been defined
- if (Cvar_FindVar (prog->console_cmd->cvars, name, prog->console_cmd->cvars_flagsmask, true))
+ if (Cvar_FindVar (prog->console_cmd->cvars, name, prog->console_cmd->cvars_flagsmask))
return;
// check for overlap with a command
*/
void VM_entityfieldname(prvm_prog_t *prog)
{
- ddef_t *d;
+ mdef_t *d;
int i = (int)PRVM_G_FLOAT(OFS_PARM0);
if (i < 0 || i >= prog->numfielddefs)
*/
void VM_entityfieldtype(prvm_prog_t *prog)
{
- ddef_t *d;
+ mdef_t *d;
int i = (int)PRVM_G_FLOAT(OFS_PARM0);
if (i < 0 || i >= prog->numfielddefs)
void VM_getentityfieldstring(prvm_prog_t *prog)
{
// put the data into a string
- ddef_t *d;
+ mdef_t *d;
int type, j;
prvm_eval_t *val;
prvm_edict_t * ent;
*/
void VM_putentityfieldstring(prvm_prog_t *prog)
{
- ddef_t *d;
+ mdef_t *d;
prvm_edict_t * ent;
int i = (int)PRVM_G_FLOAT(OFS_PARM0);
char string[VM_STRINGTEMP_LENGTH];
int search_len, replace_len, subject_len;
- VM_SAFEPARMCOUNT(3,VM_strreplace);
+ VM_SAFEPARMCOUNT(3, VM_strireplace);
search = PRVM_G_STRING(OFS_PARM0);
replace = PRVM_G_STRING(OFS_PARM1);
{
const char *p;
- VM_SAFEPARMCOUNT(1,VM_tokenize);
+ VM_SAFEPARMCOUNT(1, VM_tokenize_console);
strlcpy(tokenize_string, PRVM_G_STRING(OFS_PARM0), sizeof(tokenize_string));
p = tokenize_string;
*/
void VM_isserver(prvm_prog_t *prog)
{
- VM_SAFEPARMCOUNT(0,VM_serverstate);
+ VM_SAFEPARMCOUNT(0, VM_isserver);
PRVM_G_FLOAT(OFS_RETURN) = sv.active;
}
if(prog->argc == 0)
{
- PRVM_G_FLOAT(OFS_RETURN) = (prvm_vec_t) realtime;
+ PRVM_G_FLOAT(OFS_RETURN) = (prvm_vec_t) host.realtime;
}
else
{
switch(timer_index)
{
case 0: // GETTIME_FRAMESTART
- PRVM_G_FLOAT(OFS_RETURN) = realtime;
+ PRVM_G_FLOAT(OFS_RETURN) = host.realtime;
break;
case 1: // GETTIME_REALTIME
PRVM_G_FLOAT(OFS_RETURN) = Sys_DirtyTime();
break;
case 2: // GETTIME_HIRES
- PRVM_G_FLOAT(OFS_RETURN) = (Sys_DirtyTime() - host_dirtytime);
+ PRVM_G_FLOAT(OFS_RETURN) = (Sys_DirtyTime() - host.dirtytime);
break;
case 3: // GETTIME_UPTIME
- PRVM_G_FLOAT(OFS_RETURN) = realtime;
+ PRVM_G_FLOAT(OFS_RETURN) = host.realtime;
break;
case 4: // GETTIME_CDTRACK
PRVM_G_FLOAT(OFS_RETURN) = CDAudio_GetPosition();
break;
default:
VM_Warning(prog, "VM_gettime: %s: unsupported timer specified, returning realtime\n", prog->name);
- PRVM_G_FLOAT(OFS_RETURN) = realtime;
+ PRVM_G_FLOAT(OFS_RETURN) = host.realtime;
break;
}
}
*/
void VM_loadfromdata(prvm_prog_t *prog)
{
- VM_SAFEPARMCOUNT(1,VM_loadentsfromfile);
+ VM_SAFEPARMCOUNT(1, VM_loadfromdata);
PRVM_ED_LoadFromFile(prog, PRVM_G_STRING(OFS_PARM0));
}
void VM_modulo(prvm_prog_t *prog)
{
prvm_int_t val, m;
- VM_SAFEPARMCOUNT(2,VM_module);
+ VM_SAFEPARMCOUNT(2, VM_modulo);
val = (prvm_int_t) PRVM_G_FLOAT(OFS_PARM0);
m = (prvm_int_t) PRVM_G_FLOAT(OFS_PARM1);
=========
VM_search_begin
-float search_begin(string pattern, float caseinsensitive, float quiet)
+float search_begin(string pattern, float caseinsensitive, float quiet[, string packfile])
=========
*/
void VM_search_begin(prvm_prog_t *prog)
{
int handle;
- const char *pattern;
+ const char *packfile = NULL, *pattern;
int caseinsens, quiet;
- VM_SAFEPARMCOUNT(3, VM_search_begin);
+ VM_SAFEPARMCOUNTRANGE(3, 4, VM_search_begin);
pattern = PRVM_G_STRING(OFS_PARM0);
caseinsens = (int)PRVM_G_FLOAT(OFS_PARM1);
quiet = (int)PRVM_G_FLOAT(OFS_PARM2);
+ // optional packfile parameter (DP_QC_FS_SEARCH_PACKFILE)
+ if(prog->argc >= 4)
+ packfile = PRVM_G_STRING(OFS_PARM3);
+
for(handle = 0; handle < PRVM_MAX_OPENSEARCHES; handle++)
if(!prog->opensearches[handle])
break;
return;
}
- if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet)))
+ if(!(prog->opensearches[handle] = FS_Search(pattern,caseinsens, quiet, packfile)))
PRVM_G_FLOAT(OFS_RETURN) = -1;
else
{
void VM_search_getsize(prvm_prog_t *prog)
{
int handle;
- VM_SAFEPARMCOUNT(1, VM_M_search_getsize);
+ VM_SAFEPARMCOUNT(1, VM_search_getsize);
handle = (int)PRVM_G_FLOAT(OFS_PARM0);
int colors;
float sx, sy;
size_t maxlen = 0;
- VM_SAFEPARMCOUNTRANGE(2,3,VM_drawstring);
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_stringwidth);
getdrawfontscale(prog, &sx, &sy);
if(prog->argc == 3)
*/
void VM_stringtokeynum (prvm_prog_t *prog)
{
- VM_SAFEPARMCOUNT( 1, VM_keynumtostring );
+ VM_SAFEPARMCOUNT( 1, VM_stringtokeynum );
PRVM_G_FLOAT(OFS_RETURN) = Key_StringToKeynum(PRVM_G_STRING(OFS_PARM0));
}
void VM_getkeybind (prvm_prog_t *prog)
{
int bindmap;
- VM_SAFEPARMCOUNTRANGE(1, 2, VM_CL_getkeybind);
+ VM_SAFEPARMCOUNTRANGE(1, 2, VM_getkeybind);
if(prog->argc == 2)
bindmap = bound(-1, PRVM_G_FLOAT(OFS_PARM1), MAX_BINDMAPS-1);
else
void VM_setkeybind (prvm_prog_t *prog)
{
int bindmap;
- VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_setkeybind);
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_setkeybind);
if(prog->argc == 3)
bindmap = bound(-1, PRVM_G_FLOAT(OFS_PARM2), MAX_BINDMAPS-1);
else
void VM_getbindmaps (prvm_prog_t *prog)
{
int fg, bg;
- VM_SAFEPARMCOUNT(0, VM_CL_getbindmap);
+ VM_SAFEPARMCOUNT(0, VM_getbindmaps);
Key_GetBindMap(&fg, &bg);
PRVM_G_VECTOR(OFS_RETURN)[0] = fg;
PRVM_G_VECTOR(OFS_RETURN)[1] = bg;
*/
void VM_setbindmaps (prvm_prog_t *prog)
{
- VM_SAFEPARMCOUNT(1, VM_CL_setbindmap);
+ VM_SAFEPARMCOUNT(1, VM_setbindmaps);
PRVM_G_FLOAT(OFS_RETURN) = 0;
if(PRVM_G_VECTOR(OFS_PARM0)[2] == 0)
if(Key_SetBindMap((int)PRVM_G_VECTOR(OFS_PARM0)[0], (int)PRVM_G_VECTOR(OFS_PARM0)[1]))
clvideostate_t state;
clvideo_t *video;
- VM_SAFEPARMCOUNT( 2, VM_cin_netstate );
+ VM_SAFEPARMCOUNT( 2, VM_cin_setstate );
name = PRVM_G_STRING( OFS_PARM0 );
VM_CheckEmptyString(prog, name );
{
prvm_stringbuffer_t *stringbuffer;
int i;
-
+
VM_SAFEPARMCOUNTRANGE(0, 2, VM_buf_create);
-
+
// VorteX: optional parm1 (buffer format) is unfinished, to keep intact with future databuffers extension must be set to "string"
if(prog->argc >= 1 && strcmp(PRVM_G_STRING(OFS_PARM0), "string"))
{
}
// todo: support UTF8
-static qboolean match_rule(const char *string, int max_string, const char *pattern, int patternlength, int rule)
+static qbool match_rule(const char *string, int max_string, const char *pattern, int patternlength, int rule)
{
const char *mid;
const char *partial, *antipartial;
size_t len, antilen;
size_t alloclen;
- qboolean ispattern, antiispattern;
+ qbool ispattern, antiispattern;
int n;
prvm_stringbuffer_t *stringbuffer;
VM_SAFEPARMCOUNTRANGE(2, 3, VM_buf_cvarlist);
{
const char *url;
float id;
- qboolean ret;
+ qbool ret;
uri_to_prog_t *handle;
const char *posttype = NULL;
const char *postseparator = NULL;
func = PRVM_ED_FindFunction(prog, s);
if(!func)
- prog->error_cmd("VM_callfunciton: function %s not found !", s);
+ prog->error_cmd("VM_callfunction: function %s not found !", s);
else if (func->first_statement < 0)
{
// negative statements are built in functions
o += u8_strpad(o, end - o, buf, (flags & PRINTF_LEFT) != 0, width, precision);
}
break;
+ //spike FIXME -- 'S' for quoted tokenize-safe-or-print escaping of strings so stuff can safely survive console commands.
case 's':
if(flags & PRINTF_ALTERNATE)
{
// surface querying
-static dp_model_t *getmodel(prvm_prog_t *prog, prvm_edict_t *ed)
+static model_t *getmodel(prvm_prog_t *prog, prvm_edict_t *ed)
{
if (prog == SVVM_prog)
return SV_GetModelFromEdict(ed);
struct animatemodel_cache
{
- dp_model_t *model;
+ model_t *model;
frameblend_t frameblend[MAX_FRAMEBLENDS];
skeleton_t *skeleton_p;
skeleton_t skeleton;
Mem_Free(prog->animatemodel_cache);
}
-static void animatemodel(prvm_prog_t *prog, dp_model_t *model, prvm_edict_t *ed)
+static void animatemodel(prvm_prog_t *prog, model_t *model, prvm_edict_t *ed)
{
skeleton_t *skeleton;
int skeletonindex = -1;
- qboolean need = false;
+ qbool need = false;
struct animatemodel_cache *animatemodel_cache;
if (!prog->animatemodel_cache)
{
VectorCopy(p, out);
}
-static void clippointtosurface(prvm_prog_t *prog, prvm_edict_t *ed, dp_model_t *model, msurface_t *surface, vec3_t p, vec3_t out)
+static void clippointtosurface(prvm_prog_t *prog, prvm_edict_t *ed, model_t *model, msurface_t *surface, vec3_t p, vec3_t out)
{
int i, j, k;
float *v[3], facenormal[3], edgenormal[3], sidenormal[3], temp[3], offsetdist, dist, bestdist;
}
}
-static msurface_t *getsurface(dp_model_t *model, int surfacenum)
+static msurface_t *getsurface(model_t *model, int surfacenum)
{
if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
return NULL;
//PF_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints = #434;
void VM_getsurfacenumpoints(prvm_prog_t *prog)
{
- dp_model_t *model;
+ model_t *model;
msurface_t *surface;
VM_SAFEPARMCOUNT(2, VM_getsurfacenumpoints);
// return 0 if no such surface
void VM_getsurfacepoint(prvm_prog_t *prog)
{
prvm_edict_t *ed;
- dp_model_t *model;
+ model_t *model;
msurface_t *surface;
int pointnum;
vec3_t result;
void VM_getsurfacepointattribute(prvm_prog_t *prog)
{
prvm_edict_t *ed;
- dp_model_t *model;
+ model_t *model;
msurface_t *surface;
int pointnum;
int attributetype;
vec3_t result;
- VM_SAFEPARMCOUNT(4, VM_getsurfacepoint);
+ VM_SAFEPARMCOUNT(4, VM_getsurfacepointattribute);
VectorClear(PRVM_G_VECTOR(OFS_RETURN));
ed = PRVM_G_EDICT(OFS_PARM0);
if (!(model = getmodel(prog, ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
//PF_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal = #436;
void VM_getsurfacenormal(prvm_prog_t *prog)
{
- dp_model_t *model;
+ model_t *model;
msurface_t *surface;
vec3_t normal;
vec3_t result;
//PF_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture = #437;
void VM_getsurfacetexture(prvm_prog_t *prog)
{
- dp_model_t *model;
+ model_t *model;
msurface_t *surface;
VM_SAFEPARMCOUNT(2, VM_getsurfacetexture);
PRVM_G_INT(OFS_RETURN) = OFS_NULL;
vec3_t clipped, p;
vec_t dist, bestdist;
prvm_edict_t *ed;
- dp_model_t *model;
+ model_t *model;
msurface_t *surface;
vec3_t point;
VM_SAFEPARMCOUNT(2, VM_getsurfacenearpoint);
void VM_getsurfaceclippedpoint(prvm_prog_t *prog)
{
prvm_edict_t *ed;
- dp_model_t *model;
+ model_t *model;
msurface_t *surface;
vec3_t p, out, inp;
- VM_SAFEPARMCOUNT(3, VM_te_getsurfaceclippedpoint);
+ VM_SAFEPARMCOUNT(3, VM_getsurfaceclippedpoint);
VectorClear(PRVM_G_VECTOR(OFS_RETURN));
ed = PRVM_G_EDICT(OFS_PARM0);
if (!(model = getmodel(prog, ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
//PF_getsurfacenumtriangles, // #??? float(entity e, float s) getsurfacenumtriangles = #???;
void VM_getsurfacenumtriangles(prvm_prog_t *prog)
{
- dp_model_t *model;
+ model_t *model;
msurface_t *surface;
- VM_SAFEPARMCOUNT(2, VM_SV_getsurfacenumtriangles);
+ VM_SAFEPARMCOUNT(2, VM_getsurfacenumtriangles);
// return 0 if no such surface
if (!(model = getmodel(prog, PRVM_G_EDICT(OFS_PARM0))) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
{
{
const vec3_t d = {-1, -1, -1};
prvm_edict_t *ed;
- dp_model_t *model;
+ model_t *model;
msurface_t *surface;
int trinum;
- VM_SAFEPARMCOUNT(3, VM_SV_getsurfacetriangle);
+ VM_SAFEPARMCOUNT(3, VM_getsurfacetriangle);
VectorClear(PRVM_G_VECTOR(OFS_RETURN));
ed = PRVM_G_EDICT(OFS_PARM0);
if (!(model = getmodel(prog, ed)) || !(surface = getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))