void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
void CSQC_RelinkAllEntities (int drawmask);
void CSQC_RelinkCSQCEntities (void);
-const char *Key_GetBind (int key);
// #1 void(vector ang) makevectors
static void VM_CL_makevectors (void)
int move, svent;
prvm_edict_t *ent;
+// R_TimeReport("pretraceline");
+
VM_SAFEPARMCOUNTRANGE(4, 4, VM_CL_traceline);
prog->xfunction->builtinsprofile += 30;
trace = CL_TraceLine(v1, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
CL_VM_SetTraceGlobals(&trace, svent);
+// R_TimeReport("traceline");
}
/*
int move, svent;
prvm_edict_t *ent;
+// R_TimeReport("pretracebox");
VM_SAFEPARMCOUNTRANGE(6, 8, VM_CL_tracebox); // allow more parameters for future expansion
prog->xfunction->builtinsprofile += 30;
trace = CL_TraceBox(v1, m1, m2, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
CL_VM_SetTraceGlobals(&trace, svent);
+// R_TimeReport("tracebox");
}
trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
S_StaticSound (s, f, PRVM_G_FLOAT(OFS_PARM2), PRVM_G_FLOAT(OFS_PARM3)*64);
}
-// #92 vector(vector org) getlight (DP_QC_GETLIGHT)
+// #92 vector(vector org[, float lpflag]) getlight (DP_QC_GETLIGHT)
static void VM_CL_getlight (void)
{
vec3_t ambientcolor, diffusecolor, diffusenormal;
vec_t *p;
- VM_SAFEPARMCOUNT(1, VM_CL_getlight);
+ VM_SAFEPARMCOUNTRANGE(1, 2, VM_CL_getlight);
p = PRVM_G_VECTOR(OFS_PARM0);
VectorClear(ambientcolor);
VectorClear(diffusecolor);
VectorClear(diffusenormal);
- if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
+ if (prog->argc >= 2)
+ R_CompleteLightPoint(ambientcolor, diffusecolor, diffusenormal, p, PRVM_G_FLOAT(OFS_PARM1));
+ else if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
cl.worldmodel->brush.LightPoint(cl.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
}
-
//============================================================================
//[515]: SCENE MANAGER builtins
extern qboolean CSQC_AddRenderEdict (prvm_edict_t *ed, int edictnum);//csprogs.c
r_refdef.view.isoverlay = false;
// FIXME: restore cl.csqc_origin
// FIXME: restore cl.csqc_angles
- cl.csqc_vidvars.drawworld = true;
+ cl.csqc_vidvars.drawworld = r_drawworld.integer != 0;
cl.csqc_vidvars.drawenginesbar = false;
cl.csqc_vidvars.drawcrosshair = false;
}
prog->globals.client->time = cl.time;
for(i=1;i<prog->num_edicts;i++)
{
+ // so we can easily check if CSQC entity #edictnum is currently drawn
+ cl.csqcrenderentities[i].entitynumber = 0;
ed = &prog->edicts[i];
if(ed->priv.required->free)
continue;
}
//#303 float(float property, ...) setproperty (EXT_CSQC)
+//#303 float(float property) getproperty
+//#303 vector(float property) getpropertyvec
+// VorteX: make this function be able to return previously set property if new value is not given
void VM_CL_R_SetView (void)
{
int c;
float *f;
float k;
- VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_R_SetView);
+ VM_SAFEPARMCOUNTRANGE(1, 3, VM_CL_R_SetView);
c = (int)PRVM_G_FLOAT(OFS_PARM0);
+
+ // return value?
+ if (prog->argc < 2)
+ {
+ switch(c)
+ {
+ case VF_MIN:
+ VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.x, r_refdef.view.y, 0);
+ break;
+ case VF_MIN_X:
+ PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.x;
+ break;
+ case VF_MIN_Y:
+ PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.y;
+ break;
+ case VF_SIZE:
+ VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.width, r_refdef.view.height, 0);
+ break;
+ case VF_SIZE_X:
+ PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.width;
+ break;
+ case VF_SIZE_Y:
+ PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.height;
+ break;
+ case VF_VIEWPORT:
+ VM_Warning("VM_CL_R_GetView : VF_VIEWPORT can't be retrieved, use VF_MIN/VF_SIZE instead\n");
+ break;
+ case VF_FOV:
+ VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.ortho_x, r_refdef.view.ortho_y, 0);
+ break;
+ case VF_FOVX:
+ PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.ortho_x;
+ break;
+ case VF_FOVY:
+ PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.ortho_y;
+ break;
+ case VF_ORIGIN:
+ VectorCopy(cl.csqc_origin, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case VF_ORIGIN_X:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_origin[0];
+ break;
+ case VF_ORIGIN_Y:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_origin[1];
+ break;
+ case VF_ORIGIN_Z:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_origin[2];
+ break;
+ case VF_ANGLES:
+ VectorCopy(cl.csqc_angles, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case VF_ANGLES_X:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_angles[0];
+ break;
+ case VF_ANGLES_Y:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_angles[1];
+ break;
+ case VF_ANGLES_Z:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_angles[2];
+ break;
+ case VF_DRAWWORLD:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vidvars.drawworld;
+ break;
+ case VF_DRAWENGINESBAR:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vidvars.drawenginesbar;
+ break;
+ case VF_DRAWCROSSHAIR:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vidvars.drawcrosshair;
+ break;
+ case VF_CL_VIEWANGLES:
+ VectorCopy(cl.viewangles, PRVM_G_VECTOR(OFS_RETURN));;
+ break;
+ case VF_CL_VIEWANGLES_X:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.viewangles[0];
+ break;
+ case VF_CL_VIEWANGLES_Y:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.viewangles[1];
+ break;
+ case VF_CL_VIEWANGLES_Z:
+ PRVM_G_FLOAT(OFS_RETURN) = cl.viewangles[2];
+ break;
+ case VF_PERSPECTIVE:
+ PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.useperspective;
+ break;
+ case VF_CLEARSCREEN:
+ PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.isoverlay;
+ break;
+ default:
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ VM_Warning("VM_CL_R_GetView : unknown parm %i\n", c);
+ return;
+ }
+ return;
+ }
+
f = PRVM_G_VECTOR(OFS_PARM1);
k = PRVM_G_FLOAT(OFS_PARM1);
-
switch(c)
{
case VF_MIN:
r_refdef.view.x = (int)(f[0]);
r_refdef.view.y = (int)(f[1]);
+ DrawQ_RecalcView();
break;
case VF_MIN_X:
r_refdef.view.x = (int)(k);
+ DrawQ_RecalcView();
break;
case VF_MIN_Y:
r_refdef.view.y = (int)(k);
+ DrawQ_RecalcView();
break;
case VF_SIZE:
r_refdef.view.width = (int)(f[0]);
r_refdef.view.height = (int)(f[1]);
+ DrawQ_RecalcView();
break;
case VF_SIZE_X:
r_refdef.view.width = (int)(k);
+ DrawQ_RecalcView();
break;
case VF_SIZE_Y:
r_refdef.view.height = (int)(k);
+ DrawQ_RecalcView();
break;
case VF_VIEWPORT:
r_refdef.view.x = (int)(f[0]);
f = PRVM_G_VECTOR(OFS_PARM2);
r_refdef.view.width = (int)(f[0]);
r_refdef.view.height = (int)(f[1]);
+ DrawQ_RecalcView();
break;
case VF_FOV:
r_refdef.view.frustum_x = tan(f[0] * M_PI / 360.0);r_refdef.view.ortho_x = f[0];
CSQC_R_RecalcView();
break;
case VF_DRAWWORLD:
- cl.csqc_vidvars.drawworld = k != 0;
+ cl.csqc_vidvars.drawworld = ((k != 0) && r_drawworld.integer);
break;
case VF_DRAWENGINESBAR:
cl.csqc_vidvars.drawenginesbar = k != 0;
VM_SAFEPARMCOUNT(1, VM_CL_unproject);
f = PRVM_G_VECTOR(OFS_PARM0);
- if(v_flipped.integer)
- f[0] = (2 * r_refdef.view.x + r_refdef.view.width) * (vid_conwidth.integer / (float) vid.width) - f[0];
VectorSet(temp,
f[2],
- (-1.0 + 2.0 * (f[0] / (vid_conwidth.integer / (float) vid.width) - r_refdef.view.x) / r_refdef.view.width) * f[2] * -r_refdef.view.frustum_x,
- (-1.0 + 2.0 * (f[1] / (vid_conheight.integer / (float) vid.height) - r_refdef.view.y) / r_refdef.view.height) * f[2] * -r_refdef.view.frustum_y);
+ (-1.0 + 2.0 * (f[0] / vid_conwidth.integer)) * f[2] * -r_refdef.view.frustum_x,
+ (-1.0 + 2.0 * (f[1] / vid_conheight.integer)) * f[2] * -r_refdef.view.frustum_y);
+ if(v_flipped.integer)
+ temp[1] = -temp[1];
Matrix4x4_Transform(&r_refdef.view.matrix, temp, PRVM_G_VECTOR(OFS_RETURN));
}
if(v_flipped.integer)
v[1] = -v[1];
VectorSet(PRVM_G_VECTOR(OFS_RETURN),
- (vid_conwidth.integer / (float) vid.width) * (r_refdef.view.x + r_refdef.view.width*0.5*(1.0+v[1]/v[0]/-r_refdef.view.frustum_x)),
- (vid_conheight.integer / (float) vid.height) * (r_refdef.view.y + r_refdef.view.height*0.5*(1.0+v[2]/v[0]/-r_refdef.view.frustum_y)),
+ vid_conwidth.integer * (0.5*(1.0+v[1]/v[0]/-r_refdef.view.frustum_x)),
+ vid_conheight.integer * (0.5*(1.0+v[2]/v[0]/-r_refdef.view.frustum_y)),
v[0]);
+ // explanation:
+ // after transforming, relative position to viewport (0..1) = 0.5 * (1 + v[2]/v[0]/-frustum_{x \or y})
+ // as 2D drawing honors the viewport too, to get the same pixel, we simply multiply this by conwidth/height
}
//#330 float(float stnum) getstatf (EXT_CSQC)
if (i < 0)
return;
- CL_ParticleEffect(i, VectorDistance(start, end), start, end, t->fields.client->velocity, t->fields.client->velocity, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
+ CL_ParticleEffect(i, 1, start, end, t->fields.client->velocity, t->fields.client->velocity, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
}
//#337 void(float effectnum, vector origin, vector dir, float count[, float color]) pointparticles (EXT_CSQC)
static void VM_CL_pointparticles (void)
{
- int i, n;
+ int i;
+ float n;
float *f, *v;
VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_pointparticles);
i = (int)PRVM_G_FLOAT(OFS_PARM0);
f = PRVM_G_VECTOR(OFS_PARM1);
v = PRVM_G_VECTOR(OFS_PARM2);
- n = (int)PRVM_G_FLOAT(OFS_PARM3);
+ n = PRVM_G_FLOAT(OFS_PARM3);
if (i < 0)
return;
CL_ParticleEffect(i, n, f, f, v, v, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
}
-//#342 string(float keynum) getkeybind (EXT_CSQC)
-static void VM_CL_getkeybind (void)
+//#502 void(float effectnum, entity own, vector origin_from, vector origin_to, vector dir_from, vector dir_to, float count, float extflags) boxparticles (DP_CSQC_BOXPARTICLES)
+static void VM_CL_boxparticles (void)
{
- VM_SAFEPARMCOUNT(1, VM_CL_getkeybind);
- PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_GetBind((int)PRVM_G_FLOAT(OFS_PARM0)));
+ int effectnum;
+ // prvm_edict_t *own;
+ float *origin_from, *origin_to, *dir_from, *dir_to;
+ float count;
+ int flags;
+ float tintmins[4], tintmaxs[4];
+ prvm_eval_t *val;
+ VM_SAFEPARMCOUNTRANGE(7, 8, VM_CL_boxparticles);
+
+ effectnum = (int)PRVM_G_FLOAT(OFS_PARM0);
+ // own = PRVM_G_EDICT(OFS_PARM1); // TODO find use for this
+ origin_from = PRVM_G_VECTOR(OFS_PARM2);
+ origin_to = PRVM_G_VECTOR(OFS_PARM3);
+ dir_from = PRVM_G_VECTOR(OFS_PARM4);
+ dir_to = PRVM_G_VECTOR(OFS_PARM5);
+ count = PRVM_G_FLOAT(OFS_PARM6);
+ if(prog->argc >= 8)
+ flags = PRVM_G_FLOAT(OFS_PARM7);
+ else
+ flags = 0;
+ Vector4Set(tintmins, 1, 1, 1, 1);
+ Vector4Set(tintmaxs, 1, 1, 1, 1);
+ if(flags & 1) // read alpha
+ {
+ if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.particles_alphamin)))
+ tintmins[3] = val->_float;
+ if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.particles_alphamax)))
+ tintmaxs[3] = val->_float;
+ }
+ if(flags & 2) // read color
+ {
+ if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.particles_colormin)))
+ VectorCopy(val->vector, tintmins);
+ if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.particles_colormax)))
+ VectorCopy(val->vector, tintmaxs);
+ }
+ if (effectnum < 0)
+ return;
+ CL_ParticleTrail(effectnum, count, origin_from, origin_to, dir_from, dir_to, NULL, 0, true, true, tintmins, tintmaxs);
+}
+
+//#531 void(float pause) setpause
+static void VM_CL_setpause(void)
+{
+ VM_SAFEPARMCOUNT(1, VM_CL_setpause);
+ if ((int)PRVM_G_FLOAT(OFS_PARM0) != 0)
+ cl.csqc_paused = true;
+ else
+ cl.csqc_paused = false;
}
//#343 void(float usecursor) setcursormode (EXT_CSQC)
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
}
-//#349 float() isdemo (EXT_CSQC)
-static void VM_CL_isdemo (void)
-{
- VM_SAFEPARMCOUNT(0, VM_CL_isdemo);
- PRVM_G_FLOAT(OFS_RETURN) = cls.demoplayback;
-}
-
//#351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
static void VM_CL_setlistener (void)
{
// texture found and loaded
// skip over the jpeg as we don't need it
for(i = 0; i < size; ++i)
- MSG_ReadByte();
+ (void) MSG_ReadByte();
}
else
{
// use the attached jpeg as texture
buf = (unsigned char *) Mem_Alloc(tempmempool, size);
MSG_ReadBytes(size, buf);
- data = JPEG_LoadImage_BGRA(buf, size);
+ data = JPEG_LoadImage_BGRA(buf, size, NULL);
Mem_Free(buf);
Draw_NewPic(name, image_width, image_height, false, data);
Mem_Free(data);
int tex;
float size;
float sizeincrease;
- int alpha;
- int alphafade;
+ float alpha;
+ float alphafade;
float gravity;
float bounce;
float airfriction;
int staincolor1;
int staincolor2;
int staintex;
+ float stainalpha;
+ float stainsize;
float delayspawn;
float delaycollision;
+ float angle;
+ float spin;
}vmparticletheme_t;
// particle spawner
float *particle_stretch;
float *particle_staincolor1;
float *particle_staincolor2;
+ float *particle_stainalpha;
+ float *particle_stainsize;
float *particle_staintex;
float *particle_delayspawn;
float *particle_delaycollision;
+ float *particle_angle;
+ float *particle_spin;
}vmparticlespawner_t;
vmparticlespawner_t vmpartspawner;
getglobal(particle_stretch, "particle_stretch");
getglobalvector(particle_staincolor1, "particle_staincolor1");
getglobalvector(particle_staincolor2, "particle_staincolor2");
+ getglobal(particle_stainalpha, "particle_stainalpha");
+ getglobal(particle_stainsize, "particle_stainsize");
+ getglobal(particle_staintex, "particle_staintex");
getglobal(particle_staintex, "particle_staintex");
getglobal(particle_delayspawn, "particle_delayspawn");
getglobal(particle_delaycollision, "particle_delaycollision");
+ getglobal(particle_angle, "particle_angle");
+ getglobal(particle_spin, "particle_spin");
#undef getglobal
#undef getglobalvector
}
theme->staintex = -1;
theme->delayspawn = 0.0f;
theme->delaycollision = 0.0f;
+ theme->angle = 0.0f;
+ theme->spin = 0.0f;
}
// particle theme -> QC globals
*vmpartspawner.particle_tex = (float)theme->tex;
*vmpartspawner.particle_size = theme->size;
*vmpartspawner.particle_sizeincrease = theme->sizeincrease;
- *vmpartspawner.particle_alpha = (float)theme->alpha/256;
- *vmpartspawner.particle_alphafade = (float)theme->alphafade/256;
+ *vmpartspawner.particle_alpha = theme->alpha/256;
+ *vmpartspawner.particle_alphafade = theme->alphafade/256;
*vmpartspawner.particle_time = theme->lifetime;
*vmpartspawner.particle_gravity = theme->gravity;
*vmpartspawner.particle_bounce = theme->bounce;
vmpartspawner.particle_staincolor2[1] = ((int)theme->staincolor2 >> 8) & 0xFF;
vmpartspawner.particle_staincolor2[2] = ((int)theme->staincolor2 >> 0) & 0xFF;
*vmpartspawner.particle_staintex = (float)theme->staintex;
+ *vmpartspawner.particle_stainalpha = (float)theme->stainalpha/256;
+ *vmpartspawner.particle_stainsize = (float)theme->stainsize;
*vmpartspawner.particle_delayspawn = theme->delayspawn;
*vmpartspawner.particle_delaycollision = theme->delaycollision;
+ *vmpartspawner.particle_angle = theme->angle;
+ *vmpartspawner.particle_spin = theme->spin;
}
// QC globals -> particle theme
void VM_CL_ParticleThemeFromGlobals(vmparticletheme_t *theme)
{
theme->typeindex = (unsigned short)*vmpartspawner.particle_type;
- theme->blendmode = (pblend_t)*vmpartspawner.particle_blendmode;
- theme->orientation = (porientation_t)*vmpartspawner.particle_orientation;
+ theme->blendmode = (pblend_t)(int)*vmpartspawner.particle_blendmode;
+ theme->orientation = (porientation_t)(int)*vmpartspawner.particle_orientation;
theme->color1 = ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]);
theme->color2 = ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]);
theme->tex = (int)*vmpartspawner.particle_tex;
theme->size = *vmpartspawner.particle_size;
theme->sizeincrease = *vmpartspawner.particle_sizeincrease;
- theme->alpha = (int)(*vmpartspawner.particle_alpha*256);
- theme->alphafade = (int)(*vmpartspawner.particle_alphafade*256);
+ theme->alpha = *vmpartspawner.particle_alpha*256;
+ theme->alphafade = *vmpartspawner.particle_alphafade*256;
theme->lifetime = *vmpartspawner.particle_time;
theme->gravity = *vmpartspawner.particle_gravity;
theme->bounce = *vmpartspawner.particle_bounce;
theme->staincolor1 = ((int)vmpartspawner.particle_staincolor1[0])*65536 + (int)(vmpartspawner.particle_staincolor1[1])*256 + (int)(vmpartspawner.particle_staincolor1[2]);
theme->staincolor2 = (int)(vmpartspawner.particle_staincolor2[0])*65536 + (int)(vmpartspawner.particle_staincolor2[1])*256 + (int)(vmpartspawner.particle_staincolor2[2]);
theme->staintex =(int)*vmpartspawner.particle_staintex;
+ theme->stainalpha = *vmpartspawner.particle_stainalpha*256;
+ theme->stainsize = *vmpartspawner.particle_stainsize;
theme->delayspawn = *vmpartspawner.particle_delayspawn;
theme->delaycollision = *vmpartspawner.particle_delaycollision;
+ theme->angle = *vmpartspawner.particle_angle;
+ theme->spin = *vmpartspawner.particle_spin;
}
// init particle spawner interface
if (prog->argc < 3) // global-set particle
{
- part = CL_NewParticle((unsigned short)*vmpartspawner.particle_type, ((int)(vmpartspawner.particle_color1[0]) << 16) + ((int)(vmpartspawner.particle_color1[1]) << 8) + ((int)(vmpartspawner.particle_color1[2])), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, (int)(*vmpartspawner.particle_alpha*256), (int)(*vmpartspawner.particle_alphafade*256), *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)*vmpartspawner.particle_blendmode, (porientation_t)*vmpartspawner.particle_orientation, (int)(vmpartspawner.particle_staincolor1[0])*65536 + (int)(vmpartspawner.particle_staincolor1[1])*256 + (int)(vmpartspawner.particle_staincolor1[2]), (int)(vmpartspawner.particle_staincolor2[0])*65536 + (int)(vmpartspawner.particle_staincolor2[1])*256 + (int)(vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex);
+ part = CL_NewParticle(org, (unsigned short)*vmpartspawner.particle_type, ((int)(vmpartspawner.particle_color1[0]) << 16) + ((int)(vmpartspawner.particle_color1[1]) << 8) + ((int)(vmpartspawner.particle_color1[2])), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, *vmpartspawner.particle_alpha*256, *vmpartspawner.particle_alphafade*256, *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)(int)*vmpartspawner.particle_blendmode, (porientation_t)(int)*vmpartspawner.particle_orientation, (int)(vmpartspawner.particle_staincolor1[0])*65536 + (int)(vmpartspawner.particle_staincolor1[1])*256 + (int)(vmpartspawner.particle_staincolor1[2]), (int)(vmpartspawner.particle_staincolor2[0])*65536 + (int)(vmpartspawner.particle_staincolor2[1])*256 + (int)(vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex, *vmpartspawner.particle_stainalpha*256, *vmpartspawner.particle_stainsize, *vmpartspawner.particle_angle, *vmpartspawner.particle_spin, NULL);
if (!part)
{
PRVM_G_FLOAT(OFS_RETURN) = 0;
}
if (*vmpartspawner.particle_delayspawn)
part->delayedspawn = cl.time + *vmpartspawner.particle_delayspawn;
- if (*vmpartspawner.particle_delaycollision)
- part->delayedcollisions = cl.time + *vmpartspawner.particle_delaycollision;
+ //if (*vmpartspawner.particle_delaycollision)
+ // part->delayedcollisions = cl.time + *vmpartspawner.particle_delaycollision;
}
else // quick themed particle
{
return;
}
theme = &vmpartspawner.themes[themenum];
- part = CL_NewParticle(theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex);
+ part = CL_NewParticle(org, theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex, theme->stainalpha, theme->stainsize, theme->angle, theme->spin, NULL);
if (!part)
{
PRVM_G_FLOAT(OFS_RETURN) = 0;
}
if (theme->delayspawn)
part->delayedspawn = cl.time + theme->delayspawn;
- if (theme->delaycollision)
- part->delayedcollisions = cl.time + theme->delaycollision;
+ //if (theme->delaycollision)
+ // part->delayedcollisions = cl.time + theme->delaycollision;
}
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
org = PRVM_G_VECTOR(OFS_PARM0);
dir = PRVM_G_VECTOR(OFS_PARM1);
if (prog->argc < 5) // global-set particle
- part = CL_NewParticle((unsigned short)*vmpartspawner.particle_type, ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, (int)(*vmpartspawner.particle_alpha*256), (int)(*vmpartspawner.particle_alphafade*256), *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)*vmpartspawner.particle_blendmode, (porientation_t)*vmpartspawner.particle_orientation, ((int)vmpartspawner.particle_staincolor1[0] << 16) + ((int)vmpartspawner.particle_staincolor1[1] << 8) + ((int)vmpartspawner.particle_staincolor1[2]), ((int)vmpartspawner.particle_staincolor2[0] << 16) + ((int)vmpartspawner.particle_staincolor2[1] << 8) + ((int)vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex);
+ part = CL_NewParticle(org, (unsigned short)*vmpartspawner.particle_type, ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, *vmpartspawner.particle_alpha*256, *vmpartspawner.particle_alphafade*256, *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)(int)*vmpartspawner.particle_blendmode, (porientation_t)(int)*vmpartspawner.particle_orientation, ((int)vmpartspawner.particle_staincolor1[0] << 16) + ((int)vmpartspawner.particle_staincolor1[1] << 8) + ((int)vmpartspawner.particle_staincolor1[2]), ((int)vmpartspawner.particle_staincolor2[0] << 16) + ((int)vmpartspawner.particle_staincolor2[1] << 8) + ((int)vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex, *vmpartspawner.particle_stainalpha*256, *vmpartspawner.particle_stainsize, *vmpartspawner.particle_angle, *vmpartspawner.particle_spin, NULL);
else // themed particle
{
themenum = (int)PRVM_G_FLOAT(OFS_PARM4);
return;
}
theme = &vmpartspawner.themes[themenum];
- part = CL_NewParticle(theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex);
+ part = CL_NewParticle(org, theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex, theme->stainalpha, theme->stainsize, theme->angle, theme->spin, NULL);
}
if (!part)
{
return;
}
part->delayedspawn = cl.time + PRVM_G_FLOAT(OFS_PARM2);
- part->delayedcollisions = cl.time + PRVM_G_FLOAT(OFS_PARM3);
+ //part->delayedcollisions = cl.time + PRVM_G_FLOAT(OFS_PARM3);
PRVM_G_FLOAT(OFS_RETURN) = 0;
}
-//
+//====================
+//CSQC engine entities query
+//====================
+
+// float(float entitynum, float whatfld) getentity;
+// vector(float entitynum, float whatfld) getentityvec;
+// querying engine-drawn entity
+// VorteX: currently it's only tested with whatfld = 1..7
+void VM_CL_GetEntity (void)
+{
+ int entnum, fieldnum;
+ float org[3], v1[3], v2[3];
+ VM_SAFEPARMCOUNT(2, VM_CL_GetEntityVec);
+
+ entnum = PRVM_G_FLOAT(OFS_PARM0);
+ if (entnum < 0 || entnum >= cl.num_entities)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ return;
+ }
+ fieldnum = PRVM_G_FLOAT(OFS_PARM1);
+ switch(fieldnum)
+ {
+ case 0: // active state
+ PRVM_G_FLOAT(OFS_RETURN) = cl.entities_active[entnum];
+ break;
+ case 1: // origin
+ Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case 2: // forward
+ Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, PRVM_G_VECTOR(OFS_RETURN), v1, v2, org);
+ break;
+ case 3: // right
+ Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, v1, PRVM_G_VECTOR(OFS_RETURN), v2, org);
+ break;
+ case 4: // up
+ Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, v1, v2, PRVM_G_VECTOR(OFS_RETURN), org);
+ break;
+ case 5: // scale
+ PRVM_G_FLOAT(OFS_RETURN) = Matrix4x4_ScaleFromMatrix(&cl.entities[entnum].render.matrix);
+ break;
+ case 6: // origin + v_forward, v_right, v_up
+ Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, prog->globals.client->v_forward, prog->globals.client->v_right, prog->globals.client->v_up, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case 7: // alpha
+ PRVM_G_FLOAT(OFS_RETURN) = cl.entities[entnum].render.alpha;
+ break;
+ case 8: // colormor
+ VectorCopy(cl.entities[entnum].render.colormod, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case 9: // pants colormod
+ VectorCopy(cl.entities[entnum].render.colormap_pantscolor, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case 10: // shirt colormod
+ VectorCopy(cl.entities[entnum].render.colormap_shirtcolor, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case 11: // skinnum
+ PRVM_G_FLOAT(OFS_RETURN) = cl.entities[entnum].render.skinnum;
+ break;
+ case 12: // mins
+ VectorCopy(cl.entities[entnum].render.mins, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case 13: // maxs
+ VectorCopy(cl.entities[entnum].render.maxs, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case 14: // absmin
+ Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, org);
+ VectorAdd(cl.entities[entnum].render.mins, org, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case 15: // absmax
+ Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, org);
+ VectorAdd(cl.entities[entnum].render.maxs, org, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ case 16: // light
+ VectorMA(cl.entities[entnum].render.modellight_ambient, 0.5, cl.entities[entnum].render.modellight_diffuse, PRVM_G_VECTOR(OFS_RETURN));
+ break;
+ default:
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
+ break;
+ }
+}
+
//====================
//QC POLYGON functions
//====================
{
rtexture_t *texture;
int drawflag;
+ qboolean hasalpha;
unsigned short elements[3];
}vmpolygons_triangle_t;
unsigned short *data_sortedelement3s;
qboolean begin_active;
+ int begin_draw2d;
rtexture_t *begin_texture;
int begin_drawflag;
int begin_vertices;
float begin_vertex[VMPOLYGONS_MAXPOINTS][3];
float begin_color[VMPOLYGONS_MAXPOINTS][4];
float begin_texcoord[VMPOLYGONS_MAXPOINTS][2];
+ qboolean begin_texture_hasalpha;
} vmpolygons_t;
// FIXME: make VM_CL_R_Polygon functions use Debug_Polygon functions?
vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
if(polys->progstarttime != prog->starttime) // from other progs? won't draw these (this can cause crashes!)
return;
- R_Mesh_ResetTextureState();
+// R_Mesh_ResetTextureState();
R_EntityMatrix(&identitymatrix);
GL_CullFace(GL_NONE);
- R_Mesh_VertexPointer(polys->data_vertex3f, 0, 0);
- R_Mesh_ColorPointer(polys->data_color4f, 0, 0);
- R_Mesh_TexCoordPointer(0, 2, polys->data_texcoord2f, 0, 0);
+ GL_DepthTest(true); // polys in 3D space shall always have depth test
+ GL_DepthRange(0, 1);
+ R_Mesh_PrepareVertices_Generic_Arrays(polys->num_vertices, polys->data_vertex3f, polys->data_color4f, polys->data_texcoord2f);
for (surfacelistindex = 0;surfacelistindex < numsurfaces;)
{
int numtriangles = 0;
rtexture_t *tex = polys->data_triangles[surfacelist[surfacelistindex]].texture;
int drawflag = polys->data_triangles[surfacelist[surfacelistindex]].drawflag;
- // this can't call _DrawQ_ProcessDrawFlag, but should be in sync with it
- // FIXME factor this out
- if(drawflag == DRAWFLAG_ADDITIVE)
- GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
- else if(drawflag == DRAWFLAG_MODULATE)
- GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
- else if(drawflag == DRAWFLAG_2XMODULATE)
- GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR);
- else if(drawflag == DRAWFLAG_SCREEN)
- GL_BlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ONE);
- else
- GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ DrawQ_ProcessDrawFlag(drawflag, polys->data_triangles[surfacelist[surfacelistindex]].hasalpha);
R_SetupShader_Generic(tex, NULL, GL_MODULATE, 1);
numtriangles = 0;
for (;surfacelistindex < numsurfaces;surfacelistindex++)
VectorCopy(polys->data_triangles[surfacelist[surfacelistindex]].elements, polys->data_sortedelement3s + 3*numtriangles);
numtriangles++;
}
- R_Mesh_Draw(0, polys->num_vertices, 0, numtriangles, NULL, polys->data_sortedelement3s, 0, 0);
+ R_Mesh_Draw(0, polys->num_vertices, 0, numtriangles, NULL, NULL, 0, polys->data_sortedelement3s, NULL, 0);
}
}
void VMPolygons_Store(vmpolygons_t *polys)
{
- if (r_refdef.draw2dstage)
+ qboolean hasalpha;
+ int i;
+
+ // detect if we have alpha
+ hasalpha = polys->begin_texture_hasalpha;
+ for(i = 0; !hasalpha && (i < polys->begin_vertices); ++i)
+ if(polys->begin_color[i][3] < 1)
+ hasalpha = true;
+
+ if (polys->begin_draw2d)
{
// draw the polygon as 2D immediately
drawqueuemesh_t mesh;
mesh.data_vertex3f = polys->begin_vertex[0];
mesh.data_color4f = polys->begin_color[0];
mesh.data_texcoord2f = polys->begin_texcoord[0];
- DrawQ_Mesh(&mesh, polys->begin_drawflag);
+ DrawQ_Mesh(&mesh, polys->begin_drawflag, hasalpha);
}
else
{
int i;
if (polys->max_triangles < polys->num_triangles + polys->begin_vertices-2)
{
- polys->max_triangles *= 2;
+ while (polys->max_triangles < polys->num_triangles + polys->begin_vertices-2)
+ polys->max_triangles *= 2;
VM_ResizePolygons(polys);
}
if (polys->num_vertices + polys->begin_vertices <= polys->max_vertices)
polys->data_triangles[polys->num_triangles].elements[0] = polys->num_vertices;
polys->data_triangles[polys->num_triangles].elements[1] = polys->num_vertices + i+1;
polys->data_triangles[polys->num_triangles].elements[2] = polys->num_vertices + i+2;
+ polys->data_triangles[polys->num_triangles].hasalpha = hasalpha;
polys->num_triangles++;
}
polys->num_vertices += polys->begin_vertices;
polys->num_vertices = 0; // otherwise it's not rendered at all and prints an error message --blub */
}
-//void(string texturename, float flag) R_BeginPolygon
+//void(string texturename, float flag[, float is2d]) R_BeginPolygon
void VM_CL_R_PolygonBegin (void)
{
const char *picname;
// better management of flags, and is more suited for 3D rendering), what
// about supporting Q3 shaders?
- VM_SAFEPARMCOUNT(2, VM_CL_R_PolygonBegin);
+ VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_R_PolygonBegin);
if (!polys->initialized)
VM_InitPolygons(polys);
}
polys->begin_texture = (sf && sf->base) ? sf->base : r_texture_white;
+ polys->begin_texture_hasalpha = (sf && sf->base) ? sf->hasalpha : false;
polys->begin_drawflag = (int)PRVM_G_FLOAT(OFS_PARM1) & DRAWFLAG_MASK;
polys->begin_vertices = 0;
polys->begin_active = true;
+ polys->begin_draw2d = (prog->argc >= 3 ? (int)PRVM_G_FLOAT(OFS_PARM2) : r_refdef.draw2dstage);
}
//void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
Con_Printf("Debug_PolygonBegin: called twice without Debug_PolygonEnd after first\n");
return;
}
- debugPolys.begin_texture = picname[0] ? Draw_CachePic (picname)->tex : r_texture_white;
+ debugPolys.begin_texture = picname[0] ? Draw_CachePic_Flags (picname, CACHEPICFLAG_NOTPERSISTENT)->tex : r_texture_white;
debugPolys.begin_drawflag = drawflag;
debugPolys.begin_vertices = 0;
debugPolys.begin_active = true;
break;
if (i == MAX_EDICTS)
return;
- prog->skeletons[i] = skeleton = Mem_Alloc(cls.levelmempool, sizeof(skeleton_t) + model->num_bones * sizeof(matrix4x4_t));
+ prog->skeletons[i] = skeleton = (skeleton_t *)Mem_Alloc(cls.levelmempool, sizeof(skeleton_t) + model->num_bones * sizeof(matrix4x4_t));
PRVM_G_FLOAT(OFS_RETURN) = i + 1;
skeleton->model = model;
skeleton->relativetransforms = (matrix4x4_t *)(skeleton+1);
prvm_edict_t *ed = PRVM_G_EDICT(OFS_PARM1);
int modelindex = (int)PRVM_G_FLOAT(OFS_PARM2);
float retainfrac = PRVM_G_FLOAT(OFS_PARM3);
- int firstbone = PRVM_G_FLOAT(OFS_PARM4);
- int lastbone = PRVM_G_FLOAT(OFS_PARM5);
+ int firstbone = PRVM_G_FLOAT(OFS_PARM4) - 1;
+ int lastbone = PRVM_G_FLOAT(OFS_PARM5) - 1;
dp_model_t *model = CL_GetModelByIndex(modelindex);
float blendfrac;
int numblends;
PRVM_G_FLOAT(OFS_RETURN) = 0;
if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
return;
- PRVM_G_FLOAT(OFS_RETURN) = Mod_Alias_GetTagIndexForName(skeleton->model, 0, tagname) + 1;
+ PRVM_G_FLOAT(OFS_RETURN) = Mod_Alias_GetTagIndexForName(skeleton->model, 0, tagname);
}
// #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
VM_CL_R_SetView, // #303 float(float property, ...) setproperty (EXT_CSQC)
VM_CL_R_RenderScene, // #304 void() renderscene (EXT_CSQC)
VM_CL_R_AddDynamicLight, // #305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
-VM_CL_R_PolygonBegin, // #306 void(string texturename, float flag[, float is2d, float lines]) R_BeginPolygon
+VM_CL_R_PolygonBegin, // #306 void(string texturename, float flag, float is2d[NYI: , float lines]) R_BeginPolygon
VM_CL_R_PolygonVertex, // #307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
VM_CL_R_PolygonEnd, // #308 void() R_EndPolygon
NULL /* R_LoadWorldModel in menu VM, should stay unassigned in client*/, // #309
VM_print, // #339 void(string s, ...) print (EXT_CSQC, DP_SV_PRINT)
VM_keynumtostring, // #340 string(float keynum) keynumtostring (EXT_CSQC)
VM_stringtokeynum, // #341 float(string keyname) stringtokeynum (EXT_CSQC)
-VM_CL_getkeybind, // #342 string(float keynum) getkeybind (EXT_CSQC)
+VM_getkeybind, // #342 string(float keynum[, float bindmap]) getkeybind (EXT_CSQC)
VM_CL_setcursormode, // #343 void(float usecursor) setcursormode (EXT_CSQC)
VM_CL_getmousepos, // #344 vector() getmousepos (EXT_CSQC)
VM_CL_getinputstate, // #345 float(float framenum) getinputstate (EXT_CSQC)
VM_CL_registercmd, // #352 void(string cmdname) registercommand (EXT_CSQC)
VM_wasfreed, // #353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
VM_CL_serverkey, // #354 string(string key) serverkey (EXT_CSQC)
-NULL, // #355
-NULL, // #356
-NULL, // #357
+VM_CL_videoplaying, // #355
+VM_findfont, // #356 float(string fontname) loadfont (DP_GFX_FONTS)
+VM_loadfont, // #357 float(string fontname, string fontmaps, string sizes, float slot) loadfont (DP_GFX_FONTS)
NULL, // #358
NULL, // #359
VM_CL_ReadByte, // #360 float() readbyte (EXT_CSQC)
VM_getentityfieldstring, // #499 string(float fieldnum, entity ent) getentityfieldstring = #499; (DP_QC_ENTITYDATA)
VM_putentityfieldstring, // #500 float(float fieldnum, entity ent, string s) putentityfieldstring = #500; (DP_QC_ENTITYDATA)
VM_CL_ReadPicture, // #501 string() ReadPicture = #501;
-NULL, // #502
+VM_CL_boxparticles, // #502 void(float effectnum, entity own, vector origin_from, vector origin_to, vector dir_from, vector dir_to, float count) boxparticles (DP_CSQC_BOXPARTICLES)
VM_whichpack, // #503 string(string) whichpack = #503;
-NULL, // #504
+VM_CL_GetEntity, // #504 float(float entitynum, float fldnum) getentity = #504; vector(float entitynum, float fldnum) getentityvec = #504;
NULL, // #505
NULL, // #506
NULL, // #507
VM_uri_escape, // #510 string(string in) uri_escape = #510;
VM_uri_unescape, // #511 string(string in) uri_unescape = #511;
VM_etof, // #512 float(entity ent) num_for_edict = #512 (DP_QC_NUM_FOR_EDICT)
-VM_uri_get, // #513 float(string uril, float id) uri_get = #512; (DP_QC_URI_GET)
+VM_uri_get, // #513 float(string uri, float id, [string post_contenttype, string post_delim, [float buf]]) uri_get = #513; (DP_QC_URI_GET, DP_QC_URI_POST)
VM_tokenize_console, // #514 float(string str) tokenize_console = #514; (DP_QC_TOKENIZE_CONSOLE)
VM_argv_start_index, // #515 float(float idx) argv_start_index = #515; (DP_QC_TOKENIZE_CONSOLE)
VM_argv_end_index, // #516 float(float idx) argv_end_index = #516; (DP_QC_TOKENIZE_CONSOLE)
VM_cvar_description, // #518 float(string name) cvar_description = #518; (DP_QC_CVAR_DESCRIPTION)
VM_gettime, // #519 float(float timer) gettime = #519; (DP_QC_GETTIME)
VM_keynumtostring, // #520 string keynumtostring(float keynum)
-VM_findkeysforcommand, // #521 string findkeysforcommand(string command)
+VM_findkeysforcommand, // #521 string findkeysforcommand(string command[, float bindmap])
VM_CL_InitParticleSpawner, // #522 void(float max_themes) initparticlespawner (DP_CSQC_SPAWNPARTICLE)
VM_CL_ResetParticle, // #523 void() resetparticle (DP_CSQC_SPAWNPARTICLE)
VM_CL_ParticleTheme, // #524 void(float theme) particletheme (DP_CSQC_SPAWNPARTICLE)
VM_CL_SpawnParticleDelayed, // #528 float(vector org, vector vel, float delay, float collisiondelay, [float theme]) delayedparticle (DP_CSQC_SPAWNPARTICLE)
VM_loadfromdata, // #529
VM_loadfromfile, // #530
-NULL, // #531
+VM_CL_setpause, // #531 float(float ispaused) setpause = #531 (DP_CSQC_SETPAUSE)
VM_log, // #532
-NULL, // #533
-NULL, // #534
+VM_getsoundtime, // #533 float(entity e, float channel) getsoundtime = #533; (DP_SND_GETSOUNDTIME)
+VM_soundlength, // #534 float(string sample) soundlength = #534; (DP_SND_GETSOUNDTIME)
NULL, // #535
NULL, // #536
NULL, // #537
NULL, // #538
NULL, // #539
-NULL, // #540
-NULL, // #541
-NULL, // #542
+VM_physics_enable, // #540 void(entity e, float physics_enabled) physics_enable = #540; (DP_PHYSICS_ODE)
+VM_physics_addforce, // #541 void(entity e, vector force, vector relative_ofs) physics_addforce = #541; (DP_PHYSICS_ODE)
+VM_physics_addtorque, // #542 void(entity e, vector torque) physics_addtorque = #542; (DP_PHYSICS_ODE)
NULL, // #543
NULL, // #544
NULL, // #545
VM_isfunction, // #607
NULL, // #608
NULL, // #609
-NULL, // #610
+VM_findkeysforcommand, // #610 string findkeysforcommand(string command[, float bindmap])
NULL, // #611
NULL, // #612
VM_parseentitydata, // #613
VM_sprintf, // #627 string sprintf(string format, ...)
VM_getsurfacenumtriangles, // #628 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACETRIANGLE)
VM_getsurfacetriangle, // #629 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACETRIANGLE)
-NULL, // #630
+VM_setkeybind, // #630 float(float key, string bind[, float bindmap]) setkeybind
+VM_getbindmaps, // #631 vector(void) getbindmap
+VM_setbindmaps, // #632 float(vector bm) setbindmap
+NULL, // #633
};
const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);