return;
CSQC_BEGIN
VM_ClearTraceGlobals();
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.trace_networkentity) = 0;
+ PRVM_clientglobalfloat(trace_networkentity) = 0;
CSQC_END
}
static int cl_numrequiredfunc = sizeof(cl_required_func) / sizeof(char*);
+#define CL_REQFIELDS (sizeof(cl_reqfields) / sizeof(prvm_required_field_t))
+
+prvm_required_field_t cl_reqfields[] =
+{
+#define PRVM_DECLARE_serverglobalfloat(x)
+#define PRVM_DECLARE_serverglobalvector(x)
+#define PRVM_DECLARE_serverglobalstring(x)
+#define PRVM_DECLARE_serverglobaledict(x)
+#define PRVM_DECLARE_serverglobalfunction(x)
+#define PRVM_DECLARE_clientglobalfloat(x)
+#define PRVM_DECLARE_clientglobalvector(x)
+#define PRVM_DECLARE_clientglobalstring(x)
+#define PRVM_DECLARE_clientglobaledict(x)
+#define PRVM_DECLARE_clientglobalfunction(x)
+#define PRVM_DECLARE_menuglobalfloat(x)
+#define PRVM_DECLARE_menuglobalvector(x)
+#define PRVM_DECLARE_menuglobalstring(x)
+#define PRVM_DECLARE_menuglobaledict(x)
+#define PRVM_DECLARE_menuglobalfunction(x)
+#define PRVM_DECLARE_serverfieldfloat(x)
+#define PRVM_DECLARE_serverfieldvector(x)
+#define PRVM_DECLARE_serverfieldstring(x)
+#define PRVM_DECLARE_serverfieldedict(x)
+#define PRVM_DECLARE_serverfieldfunction(x)
+#define PRVM_DECLARE_clientfieldfloat(x) {ev_float, #x },
+#define PRVM_DECLARE_clientfieldvector(x) {ev_vector, #x },
+#define PRVM_DECLARE_clientfieldstring(x) {ev_string, #x },
+#define PRVM_DECLARE_clientfieldedict(x) {ev_entity, #x },
+#define PRVM_DECLARE_clientfieldfunction(x) {ev_function, #x },
+#define PRVM_DECLARE_menufieldfloat(x)
+#define PRVM_DECLARE_menufieldvector(x)
+#define PRVM_DECLARE_menufieldstring(x)
+#define PRVM_DECLARE_menufieldedict(x)
+#define PRVM_DECLARE_menufieldfunction(x)
+#define PRVM_DECLARE_serverfunction(x)
+#define PRVM_DECLARE_clientfunction(x)
+#define PRVM_DECLARE_menufunction(x)
+#define PRVM_DECLARE_field(x)
+#define PRVM_DECLARE_global(x)
+#define PRVM_DECLARE_function(x)
+#include "prvm_offsets.h"
+#undef PRVM_DECLARE_serverglobalfloat
+#undef PRVM_DECLARE_serverglobalvector
+#undef PRVM_DECLARE_serverglobalstring
+#undef PRVM_DECLARE_serverglobaledict
+#undef PRVM_DECLARE_serverglobalfunction
+#undef PRVM_DECLARE_clientglobalfloat
+#undef PRVM_DECLARE_clientglobalvector
+#undef PRVM_DECLARE_clientglobalstring
+#undef PRVM_DECLARE_clientglobaledict
+#undef PRVM_DECLARE_clientglobalfunction
+#undef PRVM_DECLARE_menuglobalfloat
+#undef PRVM_DECLARE_menuglobalvector
+#undef PRVM_DECLARE_menuglobalstring
+#undef PRVM_DECLARE_menuglobaledict
+#undef PRVM_DECLARE_menuglobalfunction
+#undef PRVM_DECLARE_serverfieldfloat
+#undef PRVM_DECLARE_serverfieldvector
+#undef PRVM_DECLARE_serverfieldstring
+#undef PRVM_DECLARE_serverfieldedict
+#undef PRVM_DECLARE_serverfieldfunction
+#undef PRVM_DECLARE_clientfieldfloat
+#undef PRVM_DECLARE_clientfieldvector
+#undef PRVM_DECLARE_clientfieldstring
+#undef PRVM_DECLARE_clientfieldedict
+#undef PRVM_DECLARE_clientfieldfunction
+#undef PRVM_DECLARE_menufieldfloat
+#undef PRVM_DECLARE_menufieldvector
+#undef PRVM_DECLARE_menufieldstring
+#undef PRVM_DECLARE_menufieldedict
+#undef PRVM_DECLARE_menufieldfunction
+#undef PRVM_DECLARE_serverfunction
+#undef PRVM_DECLARE_clientfunction
+#undef PRVM_DECLARE_menufunction
+#undef PRVM_DECLARE_field
+#undef PRVM_DECLARE_global
+#undef PRVM_DECLARE_function
+};
+
+#define CL_REQGLOBALS (sizeof(cl_reqglobals) / sizeof(prvm_required_field_t))
+
+prvm_required_field_t cl_reqglobals[] =
+{
+#define PRVM_DECLARE_serverglobalfloat(x)
+#define PRVM_DECLARE_serverglobalvector(x)
+#define PRVM_DECLARE_serverglobalstring(x)
+#define PRVM_DECLARE_serverglobaledict(x)
+#define PRVM_DECLARE_serverglobalfunction(x)
+#define PRVM_DECLARE_clientglobalfloat(x) {ev_float, #x},
+#define PRVM_DECLARE_clientglobalvector(x) {ev_vector, #x},
+#define PRVM_DECLARE_clientglobalstring(x) {ev_string, #x},
+#define PRVM_DECLARE_clientglobaledict(x) {ev_entity, #x},
+#define PRVM_DECLARE_clientglobalfunction(x) {ev_function, #x},
+#define PRVM_DECLARE_menuglobalfloat(x)
+#define PRVM_DECLARE_menuglobalvector(x)
+#define PRVM_DECLARE_menuglobalstring(x)
+#define PRVM_DECLARE_menuglobaledict(x)
+#define PRVM_DECLARE_menuglobalfunction(x)
+#define PRVM_DECLARE_serverfieldfloat(x)
+#define PRVM_DECLARE_serverfieldvector(x)
+#define PRVM_DECLARE_serverfieldstring(x)
+#define PRVM_DECLARE_serverfieldedict(x)
+#define PRVM_DECLARE_serverfieldfunction(x)
+#define PRVM_DECLARE_clientfieldfloat(x)
+#define PRVM_DECLARE_clientfieldvector(x)
+#define PRVM_DECLARE_clientfieldstring(x)
+#define PRVM_DECLARE_clientfieldedict(x)
+#define PRVM_DECLARE_clientfieldfunction(x)
+#define PRVM_DECLARE_menufieldfloat(x)
+#define PRVM_DECLARE_menufieldvector(x)
+#define PRVM_DECLARE_menufieldstring(x)
+#define PRVM_DECLARE_menufieldedict(x)
+#define PRVM_DECLARE_menufieldfunction(x)
+#define PRVM_DECLARE_serverfunction(x)
+#define PRVM_DECLARE_clientfunction(x)
+#define PRVM_DECLARE_menufunction(x)
+#define PRVM_DECLARE_field(x)
+#define PRVM_DECLARE_global(x)
+#define PRVM_DECLARE_function(x)
+#include "prvm_offsets.h"
+#undef PRVM_DECLARE_serverglobalfloat
+#undef PRVM_DECLARE_serverglobalvector
+#undef PRVM_DECLARE_serverglobalstring
+#undef PRVM_DECLARE_serverglobaledict
+#undef PRVM_DECLARE_serverglobalfunction
+#undef PRVM_DECLARE_clientglobalfloat
+#undef PRVM_DECLARE_clientglobalvector
+#undef PRVM_DECLARE_clientglobalstring
+#undef PRVM_DECLARE_clientglobaledict
+#undef PRVM_DECLARE_clientglobalfunction
+#undef PRVM_DECLARE_menuglobalfloat
+#undef PRVM_DECLARE_menuglobalvector
+#undef PRVM_DECLARE_menuglobalstring
+#undef PRVM_DECLARE_menuglobaledict
+#undef PRVM_DECLARE_menuglobalfunction
+#undef PRVM_DECLARE_serverfieldfloat
+#undef PRVM_DECLARE_serverfieldvector
+#undef PRVM_DECLARE_serverfieldstring
+#undef PRVM_DECLARE_serverfieldedict
+#undef PRVM_DECLARE_serverfieldfunction
+#undef PRVM_DECLARE_clientfieldfloat
+#undef PRVM_DECLARE_clientfieldvector
+#undef PRVM_DECLARE_clientfieldstring
+#undef PRVM_DECLARE_clientfieldedict
+#undef PRVM_DECLARE_clientfieldfunction
+#undef PRVM_DECLARE_menufieldfloat
+#undef PRVM_DECLARE_menufieldvector
+#undef PRVM_DECLARE_menufieldstring
+#undef PRVM_DECLARE_menufieldedict
+#undef PRVM_DECLARE_menufieldfunction
+#undef PRVM_DECLARE_serverfunction
+#undef PRVM_DECLARE_clientfunction
+#undef PRVM_DECLARE_menufunction
+#undef PRVM_DECLARE_field
+#undef PRVM_DECLARE_global
+#undef PRVM_DECLARE_function
+};
+
void CL_VM_Error (const char *format, ...) DP_FUNC_PRINTF(1);
void CL_VM_Error (const char *format, ...) //[515]: hope it will be never executed =)
{
if(cl.csqc_loaded)
{
CSQC_BEGIN
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.dmg_take) = dmg_take;
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.dmg_save) = dmg_save;
- VectorCopy(dmg_origin, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.dmg_origin));
+ PRVM_clientglobalfloat(dmg_take) = dmg_take;
+ PRVM_clientglobalfloat(dmg_save) = dmg_save;
+ VectorCopy(dmg_origin, PRVM_clientglobalvector(dmg_origin));
CSQC_END
}
}
if(!cl.csqc_loaded)
return;
CSQC_BEGIN
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.servertime) = newtime;
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.serverprevtime) = oldtime;
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.serverdeltatime) = newtime - oldtime;
+ PRVM_clientglobalfloat(servertime) = newtime;
+ PRVM_clientglobalfloat(serverprevtime) = oldtime;
+ PRVM_clientglobalfloat(serverdeltatime) = newtime - oldtime;
CSQC_END
}
//[515]: set globals before calling R_UpdateView, WEIRD CRAP
+void CSQC_R_RecalcView (void);
static void CSQC_SetGlobals (void)
{
CSQC_BEGIN
- prog->globals.client->time = cl.time;
- prog->globals.client->frametime = max(0, cl.time - cl.oldtime);
- prog->globals.client->servercommandframe = cls.servermovesequence;
- prog->globals.client->clientcommandframe = cl.movecmd[0].sequence;
- VectorCopy(cl.viewangles, prog->globals.client->input_angles);
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobalfloat(frametime) = max(0, cl.time - cl.oldtime);
+ PRVM_clientglobalfloat(servercommandframe) = cls.servermovesequence;
+ PRVM_clientglobalfloat(clientcommandframe) = cl.movecmd[0].sequence;
+ VectorCopy(cl.viewangles, PRVM_clientglobalvector(input_angles));
// // FIXME: this actually belongs into getinputstate().. [12/17/2007 Black]
- prog->globals.client->input_buttons = cl.movecmd[0].buttons;
- VectorSet(prog->globals.client->input_movevalues, cl.movecmd[0].forwardmove, cl.movecmd[0].sidemove, cl.movecmd[0].upmove);
+ PRVM_clientglobalfloat(input_buttons) = cl.movecmd[0].buttons;
+ VectorSet(PRVM_clientglobalvector(input_movevalues), cl.movecmd[0].forwardmove, cl.movecmd[0].sidemove, cl.movecmd[0].upmove);
VectorCopy(cl.csqc_vieworiginfromengine, cl.csqc_vieworigin);
VectorCopy(cl.csqc_viewanglesfromengine, cl.csqc_viewangles);
// LordHavoc: Spike says not to do this, but without pmove_org the
// CSQC is useless as it can't alter the view origin without
// completely replacing it
- Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, prog->globals.client->pmove_org);
- VectorCopy(cl.movement_velocity, prog->globals.client->pmove_vel);
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.pmove_onground) = cl.onground;
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.pmove_inwater) = cl.inwater;
-
- VectorCopy(cl.viewangles, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.view_angles));
- VectorCopy(cl.punchangle, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.view_punchangle));
- VectorCopy(cl.punchvector, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.view_punchvector));
- prog->globals.client->maxclients = cl.maxclients;
+ Matrix4x4_OriginFromMatrix(&cl.entities[cl.viewentity].render.matrix, PRVM_clientglobalvector(pmove_org));
+ VectorCopy(cl.movement_velocity, PRVM_clientglobalvector(pmove_vel));
+ PRVM_clientglobalfloat(pmove_onground) = cl.onground;
+ PRVM_clientglobalfloat(pmove_inwater) = cl.inwater;
+
+ VectorCopy(cl.viewangles, PRVM_clientglobalvector(view_angles));
+ VectorCopy(cl.punchangle, PRVM_clientglobalvector(view_punchangle));
+ VectorCopy(cl.punchvector, PRVM_clientglobalvector(view_punchvector));
+ PRVM_clientglobalfloat(maxclients) = cl.maxclients;
+
+ CSQC_R_RecalcView();
CSQC_END
}
void CSQC_Predraw (prvm_edict_t *ed)
{
int b;
- if(!ed->fields.client->predraw)
+ if(!PRVM_clientedictfunction(ed, predraw))
return;
- b = prog->globals.client->self;
- prog->globals.client->self = PRVM_EDICT_TO_PROG(ed);
- PRVM_ExecuteProgram(ed->fields.client->predraw, "CSQC_Predraw: NULL function\n");
- prog->globals.client->self = b;
+ b = PRVM_clientglobaledict(self);
+ PRVM_clientglobaledict(self) = PRVM_EDICT_TO_PROG(ed);
+ PRVM_ExecuteProgram(PRVM_clientedictfunction(ed, predraw), "CSQC_Predraw: NULL function\n");
+ PRVM_clientglobaledict(self) = b;
}
void CSQC_Think (prvm_edict_t *ed)
{
int b;
- if(ed->fields.client->think)
- if(ed->fields.client->nextthink && ed->fields.client->nextthink <= prog->globals.client->time)
+ if(PRVM_clientedictfunction(ed, think))
+ if(PRVM_clientedictfloat(ed, nextthink) && PRVM_clientedictfloat(ed, nextthink) <= PRVM_clientglobalfloat(time))
{
- ed->fields.client->nextthink = 0;
- b = prog->globals.client->self;
- prog->globals.client->self = PRVM_EDICT_TO_PROG(ed);
- PRVM_ExecuteProgram(ed->fields.client->think, "CSQC_Think: NULL function\n");
- prog->globals.client->self = b;
+ PRVM_clientedictfloat(ed, nextthink) = 0;
+ b = PRVM_clientglobaledict(self);
+ PRVM_clientglobaledict(self) = PRVM_EDICT_TO_PROG(ed);
+ PRVM_ExecuteProgram(PRVM_clientedictfunction(ed, think), "CSQC_Think: NULL function\n");
+ PRVM_clientglobaledict(self) = b;
}
}
return false;
}
- entrender->userwavefunc_param[0] = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.userwavefunc_param0);
- entrender->userwavefunc_param[1] = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.userwavefunc_param1);
- entrender->userwavefunc_param[2] = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.userwavefunc_param2);
- entrender->userwavefunc_param[3] = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.userwavefunc_param3);
+ entrender->userwavefunc_param[0] = PRVM_clientedictfloat(ed, userwavefunc_param0);
+ entrender->userwavefunc_param[1] = PRVM_clientedictfloat(ed, userwavefunc_param1);
+ entrender->userwavefunc_param[2] = PRVM_clientedictfloat(ed, userwavefunc_param2);
+ entrender->userwavefunc_param[3] = PRVM_clientedictfloat(ed, userwavefunc_param3);
entrender->model = model;
- entrender->skinnum = (int)ed->fields.client->skin;
+ entrender->skinnum = (int)PRVM_clientedictfloat(ed, skin);
entrender->effects |= entrender->model->effects;
- renderflags = (int)PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.renderflags);
- entrender->alpha = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.alpha);
- entrender->scale = scale = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.scale);
- VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.colormod), entrender->colormod);
- VectorCopy(PRVM_EDICTFIELDVECTOR(ed, prog->fieldoffsets.glowmod), entrender->glowmod);
- if(ed->fields.client->effects) entrender->effects |= (int)ed->fields.client->effects;
+ renderflags = (int)PRVM_clientedictfloat(ed, renderflags);
+ entrender->alpha = PRVM_clientedictfloat(ed, alpha);
+ entrender->scale = scale = PRVM_clientedictfloat(ed, scale);
+ VectorCopy(PRVM_clientedictvector(ed, colormod), entrender->colormod);
+ VectorCopy(PRVM_clientedictvector(ed, glowmod), entrender->glowmod);
+ if(PRVM_clientedictfloat(ed, effects)) entrender->effects |= (int)PRVM_clientedictfloat(ed, effects);
if (!entrender->alpha)
entrender->alpha = 1.0f;
if (!entrender->scale)
VM_GenerateFrameGroupBlend(ed->priv.server->framegroupblend, ed);
VM_FrameBlendFromFrameGroupBlend(ed->priv.server->frameblend, ed->priv.server->framegroupblend, model);
VM_UpdateEdictSkeleton(ed, model, ed->priv.server->frameblend);
- entrender->shadertime = PRVM_EDICTFIELDFLOAT(ed, prog->fieldoffsets.shadertime);
+ if (PRVM_clientedictfloat(ed, shadertime)) // hack for csprogs.dat files that do not set shadertime, leaves the value at entity spawn time
+ entrender->shadertime = PRVM_clientedictfloat(ed, shadertime);
// transparent offset
if (renderflags & RF_USETRANSPARENTOFFSET)
- entrender->transparent_offset = PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.transparent_offset);
+ entrender->transparent_offset = PRVM_clientglobalfloat(transparent_offset);
if(renderflags)
{
if(renderflags & RF_ADDITIVE) entrender->flags |= RENDER_ADDITIVE;
}
- c = (int)ed->fields.client->colormap;
+ c = (int)PRVM_clientedictfloat(ed, colormap);
if (c <= 0)
CL_SetEntityColormapColors(entrender, -1);
else if (c <= cl.maxclients && cl.scores != NULL)
return true;
}
-qboolean CL_VM_InputEvent (qboolean down, int key, int ascii)
+// 0 = keydown, key, character (EXT_CSQC)
+// 1 = keyup, key, character (EXT_CSQC)
+// 2 = mousemove relative, x, y (EXT_CSQC)
+// 3 = mousemove absolute, x, y (DP_CSQC)
+qboolean CL_VM_InputEvent (int eventtype, int x, int y)
{
qboolean r;
return false;
CSQC_BEGIN
- if (!prog->funcoffsets.CSQC_InputEvent)
+ if (!PRVM_clientfunction(CSQC_InputEvent))
r = false;
else
{
- prog->globals.client->time = cl.time;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
- PRVM_G_FLOAT(OFS_PARM0) = !down; // 0 is down, 1 is up
- PRVM_G_FLOAT(OFS_PARM1) = key;
- PRVM_G_FLOAT(OFS_PARM2) = ascii;
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_InputEvent, "QC function CSQC_InputEvent is missing");
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_G_FLOAT(OFS_PARM0) = eventtype;
+ PRVM_G_FLOAT(OFS_PARM1) = x; // key or x
+ PRVM_G_FLOAT(OFS_PARM2) = y; // ascii or y
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_InputEvent), "QC function CSQC_InputEvent is missing");
r = CSQC_RETURNVAL != 0;
}
CSQC_END
R_TimeReport("pre-UpdateView");
CSQC_BEGIN
//VectorCopy(cl.viewangles, oldangles);
- prog->globals.client->time = cl.time;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
CSQC_SetGlobals();
// clear renderable entity and light lists to prevent crashes if the
// CSQC_UpdateView function does not call R_ClearScene as it should
// pass in width and height as parameters (EXT_CSQC_1)
PRVM_G_FLOAT(OFS_PARM0) = vid.width;
PRVM_G_FLOAT(OFS_PARM1) = vid.height;
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_UpdateView, "QC function CSQC_UpdateView is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_UpdateView), "QC function CSQC_UpdateView is missing");
//VectorCopy(oldangles, cl.viewangles);
// Dresk : Reset Dmg Globals Here
CL_VM_UpdateDmgGlobals(0, 0, emptyvector);
if(!cl.csqc_loaded)
return false;
CSQC_BEGIN
- if (prog->funcoffsets.CSQC_ConsoleCommand)
+ if (PRVM_clientfunction(CSQC_ConsoleCommand))
{
- prog->globals.client->time = cl.time;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(cmd);
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_ConsoleCommand, "QC function CSQC_ConsoleCommand is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_ConsoleCommand), "QC function CSQC_ConsoleCommand is missing");
vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
r = CSQC_RETURNVAL != 0;
}
if(!cl.csqc_loaded)
return false;
CSQC_BEGIN
- if(prog->funcoffsets.CSQC_Parse_TempEntity)
+ if(PRVM_clientfunction(CSQC_Parse_TempEntity))
{
t = msg_readcount;
- prog->globals.client->time = cl.time;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Parse_TempEntity, "QC function CSQC_Parse_TempEntity is missing");
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_TempEntity), "QC function CSQC_Parse_TempEntity is missing");
r = CSQC_RETURNVAL != 0;
if(!r)
{
return;
}
CSQC_BEGIN
- if(prog->funcoffsets.CSQC_Parse_StuffCmd)
+ if(PRVM_clientfunction(CSQC_Parse_StuffCmd))
{
- prog->globals.client->time = cl.time;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Parse_StuffCmd, "QC function CSQC_Parse_StuffCmd is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_StuffCmd), "QC function CSQC_Parse_StuffCmd is missing");
vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
}
else
static void CL_VM_Parse_Print (const char *msg)
{
int restorevm_tempstringsbuf_cursize;
- prog->globals.client->time = cl.time;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Parse_Print, "QC function CSQC_Parse_Print is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_Print), "QC function CSQC_Parse_Print is missing");
vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
}
return;
}
CSQC_BEGIN
- if(prog->funcoffsets.CSQC_Parse_Print)
+ if(PRVM_clientfunction(CSQC_Parse_Print))
{
// FIXME: is this bugged?
i = strlen(msg)-1;
return;
}
CSQC_BEGIN
- if(prog->funcoffsets.CSQC_Parse_CenterPrint)
+ if(PRVM_clientfunction(CSQC_Parse_CenterPrint))
{
- prog->globals.client->time = cl.time;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
restorevm_tempstringsbuf_cursize = vm_tempstringsbuf.cursize;
PRVM_G_INT(OFS_PARM0) = PRVM_SetTempString(msg);
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Parse_CenterPrint, "QC function CSQC_Parse_CenterPrint is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Parse_CenterPrint), "QC function CSQC_Parse_CenterPrint is missing");
vm_tempstringsbuf.cursize = restorevm_tempstringsbuf_cursize;
}
else
if(cl.csqc_loaded)
{
CSQC_BEGIN
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.intermission) = intermission;
+ PRVM_clientglobalfloat(intermission) = intermission;
CSQC_END
}
}
if(cl.csqc_loaded)
{
CSQC_BEGIN
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.sb_showscores) = showingscores;
+ PRVM_clientglobalfloat(sb_showscores) = showingscores;
CSQC_END
}
}
if(cl.csqc_loaded)
{
CSQC_BEGIN
- if(prog->funcoffsets.CSQC_Event_Sound)
+ if(PRVM_clientfunction(CSQC_Event_Sound))
{
- prog->globals.client->time = cl.time;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
PRVM_G_FLOAT(OFS_PARM0) = ent;
- PRVM_G_FLOAT(OFS_PARM1) = channel;
+ PRVM_G_FLOAT(OFS_PARM1) = CHAN_ENGINE2USER(channel);
PRVM_G_INT(OFS_PARM2) = PRVM_SetTempString(cl.sound_name[sound_num] );
PRVM_G_FLOAT(OFS_PARM3) = volume;
PRVM_G_FLOAT(OFS_PARM4) = attenuation;
VectorCopy(pos, PRVM_G_VECTOR(OFS_PARM5) );
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Event_Sound, "QC function CSQC_Event_Sound is missing");
+ PRVM_G_FLOAT(OFS_PARM6) = 0; // pitch shift not supported yet
+ PRVM_G_FLOAT(OFS_PARM7) = 0; // flags - none can come in at this point yet
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Event_Sound), "QC function CSQC_Event_Sound is missing");
r = CSQC_RETURNVAL != 0;
}
CSQC_END
localdeathmatch = 0;
}
CSQC_BEGIN
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.coop) = localcoop;
- PRVM_GLOBALFIELDFLOAT(prog->globaloffsets.deathmatch) = localdeathmatch;
+ PRVM_clientglobalfloat(coop) = localcoop;
+ PRVM_clientglobalfloat(deathmatch) = localdeathmatch;
CSQC_END
}
}
if(!cl.csqc_loaded)
return 0;
CSQC_BEGIN
- if(prog->funcoffsets.CSQC_Event)
+ if(PRVM_clientfunction(CSQC_Event))
{
- prog->globals.client->time = cl.time;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[cl.playerentity];
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[cl.playerentity];
PRVM_G_FLOAT(OFS_PARM0) = event;
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Event, "QC function CSQC_Event is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Event), "QC function CSQC_Event is missing");
r = CSQC_RETURNVAL;
}
CSQC_END
}
CSQC_BEGIN
- prog->globals.client->time = cl.time;
- oldself = prog->globals.client->self;
+ PRVM_clientglobalfloat(time) = cl.time;
+ oldself = PRVM_clientglobaledict(self);
while(1)
{
entnum = MSG_ReadShort();
if(!entnum || msg_badread)
break;
realentnum = entnum & 0x7FFF;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[realentnum];
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[realentnum];
if(entnum & 0x8000)
{
- if(prog->globals.client->self)
+ if(PRVM_clientglobaledict(self))
{
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Ent_Remove, "QC function CSQC_Ent_Remove is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Remove), "QC function CSQC_Ent_Remove is missing");
cl.csqc_server2csqcentitynumber[realentnum] = 0;
}
else
}
else
{
- if(!prog->globals.client->self)
+ if(!PRVM_clientglobaledict(self))
{
- if(!prog->funcoffsets.CSQC_Ent_Spawn)
+ if(!PRVM_clientfunction(CSQC_Ent_Spawn))
{
prvm_edict_t *ed;
ed = PRVM_ED_Alloc();
- ed->fields.client->entnum = realentnum;
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT_TO_PROG(ed);
+ PRVM_clientedictfloat(ed, entnum) = realentnum;
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT_TO_PROG(ed);
}
else
{
// the qc function should set entnum, too (this way it also can return world [2/1/2008 Andreas]
PRVM_G_FLOAT(OFS_PARM0) = (float) realentnum;
// make sure no one gets wrong ideas
- prog->globals.client->self = 0;
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Ent_Spawn, "QC function CSQC_Ent_Spawn is missing");
- prog->globals.client->self = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT( PRVM_G_INT( OFS_RETURN ) );
+ PRVM_clientglobaledict(self) = 0;
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Spawn), "QC function CSQC_Ent_Spawn is missing");
+ PRVM_clientglobaledict(self) = cl.csqc_server2csqcentitynumber[realentnum] = PRVM_EDICT( PRVM_G_INT( OFS_RETURN ) );
}
PRVM_G_FLOAT(OFS_PARM0) = 1;
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Ent_Update, "QC function CSQC_Ent_Update is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Update), "QC function CSQC_Ent_Update is missing");
}
else {
PRVM_G_FLOAT(OFS_PARM0) = 0;
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Ent_Update, "QC function CSQC_Ent_Update is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Ent_Update), "QC function CSQC_Ent_Update is missing");
}
}
}
- prog->globals.client->self = oldself;
+ PRVM_clientglobaledict(self) = oldself;
CSQC_END
}
R_DecalSystem_Reset(&entrender->decalsystem);
memset(entrender, 0, sizeof(*entrender));
World_UnlinkEdict(ed);
- memset(ed->fields.client, 0, sizeof(*ed->fields.client));
+ memset(ed->fields.vp, 0, prog->entityfields * 4);
VM_RemoveEdictSkeleton(ed);
World_Physics_RemoveFromEntity(&cl.world, ed);
World_Physics_RemoveJointFromEntity(&cl.world, ed);
if (ent->priv.server->free)
continue;
active++;
- if (ent->fields.client->solid)
+ if (PRVM_clientedictfloat(ent, solid))
solid++;
- if (ent->fields.client->model)
+ if (PRVM_clientedictstring(ent, model))
models++;
}
return false;
}
-#define CL_REQFIELDS (sizeof(cl_reqfields) / sizeof(prvm_required_field_t))
-
-prvm_required_field_t cl_reqfields[] =
-{
- {ev_entity, "groundentity"},
- {ev_entity, "tag_entity"},
- {ev_float, "alpha"},
- {ev_float, "dimension_hit"},
- {ev_float, "dimension_solid"},
- {ev_float, "dphitcontentsmask"},
- {ev_float, "frame"},
- {ev_float, "frame1time"},
- {ev_float, "frame2"},
- {ev_float, "frame2time"},
- {ev_float, "frame3"},
- {ev_float, "frame3time"},
- {ev_float, "frame4"},
- {ev_float, "frame4time"},
- {ev_float, "gravity"},
- {ev_float, "idealpitch"},
- {ev_float, "lerpfrac"},
- {ev_float, "lerpfrac3"},
- {ev_float, "lerpfrac4"},
- {ev_float, "movetype"}, // used by ODE code
- {ev_float, "nextthink"},
- {ev_float, "pitch_speed"},
- {ev_float, "renderflags"},
- {ev_float, "scale"},
- {ev_float, "shadertime"},
- {ev_float, "skeletonindex"},
- {ev_float, "solid"}, // used by ODE code
- {ev_float, "tag_index"},
- {ev_float, "userwavefunc_param0"},
- {ev_float, "userwavefunc_param1"},
- {ev_float, "userwavefunc_param2"},
- {ev_float, "userwavefunc_param3"},
- {ev_function, "camera_transform"},
- {ev_function, "think"},
- {ev_string, "classname"},
- {ev_vector, "colormod"},
- {ev_vector, "glowmod"},
-
- // physics
- //{ev_float, "solid"},
- //{ev_float, "movetype"},
- //{ev_float, "modelindex"},
- {ev_vector, "mass"},
- //{ev_vector, "origin"},
- //{ev_vector, "velocity"},
- //{ev_vector, "axis_forward"},
- //{ev_vector, "axis_left"},
- //{ev_vector, "axis_up"},
- //{ev_vector, "spinvelocity"},
- //{ev_vector, "angles"},
- //{ev_vector, "avelocity"},
-};
-
-#define CL_REQGLOBALS (sizeof(cl_reqglobals) / sizeof(prvm_required_field_t))
-
-prvm_required_field_t cl_reqglobals[] =
-{
- {ev_entity, "self"},
- {ev_entity, "trace_ent"},
- {ev_entity, "trace_networkentity"},
- {ev_float, "coop"},
- {ev_float, "deathmatch"},
- {ev_float, "dmg_save"},
- {ev_float, "dmg_take"},
- {ev_float, "drawfont"},
- {ev_float, "drawfontscale"},
- {ev_float, "gettaginfo_parent"},
- {ev_float, "intermission"},
- {ev_float, "particle_airfriction"},
- {ev_float, "particle_alpha"},
- {ev_float, "particle_alphafade"},
- {ev_float, "particle_angle"},
- {ev_float, "particle_blendmode"},
- {ev_float, "particle_bounce"},
- {ev_float, "particle_delaycollision"},
- {ev_float, "particle_delayspawn"},
- {ev_float, "particle_gravity"},
- {ev_float, "particle_liquidfriction"},
- {ev_float, "particle_orientation"},
- {ev_float, "particle_originjitter"},
- {ev_float, "particle_qualityreduction"},
- {ev_float, "particle_size"},
- {ev_float, "particle_sizeincrease"},
- {ev_float, "particle_spin"},
- {ev_float, "particle_stainalpha"},
- {ev_float, "particle_stainsize"},
- {ev_float, "particle_staintex"},
- {ev_float, "particle_staintex"},
- {ev_float, "particle_stretch"},
- {ev_float, "particle_tex"},
- {ev_float, "particle_time"},
- {ev_float, "particle_type"},
- {ev_float, "particle_velocityjitter"},
- {ev_float, "particles_alphamax"},
- {ev_float, "particles_alphamin"},
- {ev_float, "pmove_onground"},
- {ev_float, "pmove_inwater"},
- {ev_float, "require_spawnfunc_prefix"},
- {ev_float, "sb_showscores"},
- {ev_float, "serverdeltatime"},
- {ev_float, "serverprevtime"},
- {ev_float, "servertime"},
- {ev_float, "time"},
- {ev_float, "trace_allsolid"},
- {ev_float, "trace_dphitcontents"},
- {ev_float, "trace_dphitq3surfaceflags"},
- {ev_float, "trace_dpstartcontents"},
- {ev_float, "trace_fraction"},
- {ev_float, "trace_inopen"},
- {ev_float, "trace_inwater"},
- {ev_float, "trace_plane_dist"},
- {ev_float, "trace_startsolid"},
- {ev_float, "transparent_offset"},
- {ev_string, "SV_InitCmd"},
- {ev_string, "gettaginfo_name"},
- {ev_string, "trace_dphittexturename"},
- {ev_string, "worldstatus"},
- {ev_string, "message"},
- {ev_vector, "dmg_origin"},
- {ev_vector, "gettaginfo_forward"},
- {ev_vector, "gettaginfo_offset"},
- {ev_vector, "gettaginfo_right"},
- {ev_vector, "gettaginfo_up"},
- {ev_vector, "particle_color1"},
- {ev_vector, "particle_color2"},
- {ev_vector, "particle_staincolor1"},
- {ev_vector, "particle_staincolor2"},
- {ev_vector, "particles_colormax"},
- {ev_vector, "particles_colormin"},
- {ev_vector, "trace_endpos"},
- {ev_vector, "trace_plane_normal"},
- {ev_vector, "v_forward"},
- {ev_vector, "v_right"},
- {ev_vector, "v_up"},
- {ev_vector, "view_angles"},
- {ev_vector, "view_punchangle"},
- {ev_vector, "view_punchvector"},
-};
-
void CL_VM_Init (void)
{
const char* csprogsfn;
// allocate the mempools
prog->progs_mempool = Mem_AllocPool(csqc_progname.string, 0, NULL);
- prog->headercrc = CL_PROGHEADER_CRC;
prog->edictprivate_size = 0; // no private struct used
prog->name = CL_NAME;
prog->num_edicts = 1;
prog->flag |= PRVM_OP_STATE;
// set time
- prog->globals.client->time = cl.time;
- prog->globals.client->self = 0;
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = 0;
- prog->globals.client->mapname = PRVM_SetEngineString(cl.worldname);
- prog->globals.client->player_localentnum = cl.playerentity;
+ PRVM_clientglobalstring(mapname) = PRVM_SetEngineString(cl.worldname);
+ PRVM_clientglobalfloat(player_localentnum) = cl.playerentity;
// set map description (use world entity 0)
- PRVM_EDICTFIELDSTRING(prog->edicts, prog->fieldoffsets.message) = PRVM_SetEngineString(cl.worldmessage);
- VectorCopy(cl.world.mins, prog->edicts->fields.client->mins);
- VectorCopy(cl.world.maxs, prog->edicts->fields.client->maxs);
+ PRVM_clientedictstring(prog->edicts, message) = PRVM_SetEngineString(cl.worldmessage);
+ VectorCopy(cl.world.mins, PRVM_clientedictvector(prog->edicts, mins));
+ VectorCopy(cl.world.maxs, PRVM_clientedictvector(prog->edicts, maxs));
// call the prog init
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Init, "QC function CSQC_Init is missing");
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Init), "QC function CSQC_Init is missing");
PRVM_End;
cl.csqc_loaded = true;
if(!cl.csqc_loaded)
return;
CSQC_BEGIN
- prog->globals.client->time = cl.time;
- prog->globals.client->self = 0;
- if (prog->funcoffsets.CSQC_Shutdown)
- PRVM_ExecuteProgram(prog->funcoffsets.CSQC_Shutdown, "QC function CSQC_Shutdown is missing");
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = 0;
+ if (PRVM_clientfunction(CSQC_Shutdown))
+ PRVM_ExecuteProgram(PRVM_clientfunction(CSQC_Shutdown), "QC function CSQC_Shutdown is missing");
PRVM_ResetProg();
CSQC_END
Con_DPrint("CSQC ^1unloaded\n");
if(!ed->priv.required->free)
{
mod = CL_GetModelFromEdict(ed);
- VectorCopy(ed->fields.client->origin, out);
+ VectorCopy(PRVM_clientedictvector(ed, origin), out);
if(CL_GetTagMatrix (&matrix, ed, 0) == 0)
Matrix4x4_OriginFromMatrix(&matrix, out);
if (mod && mod->soundfromcenter)
ed = PRVM_EDICT_NUM(entnum);
// camera:
// camera_transform
- if(PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.camera_transform))
+ if(PRVM_clientedictfunction(ed, camera_transform))
{
ret = true;
if(viewmatrix || clipplane || visorigin)
{
Matrix4x4_ToVectors(viewmatrix, forward, left, up, origin);
AnglesFromVectors(ang, forward, up, false);
- prog->globals.client->time = cl.time;
- prog->globals.client->self = entnum;
+ PRVM_clientglobalfloat(time) = cl.time;
+ PRVM_clientglobaledict(self) = entnum;
VectorCopy(origin, PRVM_G_VECTOR(OFS_PARM0));
VectorCopy(ang, PRVM_G_VECTOR(OFS_PARM1));
- VectorCopy(forward, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_forward));
- VectorScale(left, -1, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_right));
- VectorCopy(up, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_up));
- VectorCopy(origin, PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_endpos));
- PRVM_ExecuteProgram(PRVM_EDICTFIELDFUNCTION(ed, prog->fieldoffsets.camera_transform), "QC function e.camera_transform is missing");
+ VectorCopy(forward, PRVM_clientglobalvector(v_forward));
+ VectorScale(left, -1, PRVM_clientglobalvector(v_right));
+ VectorCopy(up, PRVM_clientglobalvector(v_up));
+ VectorCopy(origin, PRVM_clientglobalvector(trace_endpos));
+ PRVM_ExecuteProgram(PRVM_clientedictfunction(ed, camera_transform), "QC function e.camera_transform is missing");
VectorCopy(PRVM_G_VECTOR(OFS_RETURN), origin);
- VectorCopy(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_forward), forward);
- VectorScale(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_right), -1, left);
- VectorCopy(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.v_up), up);
- VectorCopy(PRVM_GLOBALFIELDVECTOR(prog->globaloffsets.trace_endpos), visorigin);
+ VectorCopy(PRVM_clientglobalvector(v_forward), forward);
+ VectorScale(PRVM_clientglobalvector(v_right), -1, left);
+ VectorCopy(PRVM_clientglobalvector(v_up), up);
+ VectorCopy(PRVM_clientglobalvector(trace_endpos), visorigin);
Matrix4x4_Invert_Full(&mat, viewmatrix);
Matrix4x4_FromVectors(viewmatrix, forward, left, up, origin);
Matrix4x4_Concat(&matq, viewmatrix, &mat);