fix broken VM_CL_lightstyle (CSQC): it was using MSG_ReadString instead of value...
[divverent/darkplaces.git] / clvm_cmds.c
1 #include "quakedef.h"
2
3 #include "prvm_cmds.h"
4 #include "csprogs.h"
5 #include "cl_collision.h"
6 #include "r_shadow.h"
7 #include "jpeg.h"
8 #include "image.h"
9
10 //============================================================================
11 // Client
12 //[515]: unsolved PROBLEMS
13 //- finish player physics code (cs_runplayerphysics)
14 //- EntWasFreed ?
15 //- RF_DEPTHHACK is not like it should be
16 //- add builtin that sets cl.viewangles instead of reading "input_angles" global
17 //- finish lines support for R_Polygon***
18 //- insert selecttraceline into traceline somehow
19
20 //4 feature darkplaces csqc: add builtin to clientside qc for reading triangles of model meshes (useful to orient a ui along a triangle of a model mesh)
21 //4 feature darkplaces csqc: add builtins to clientside qc for gl calls
22
23 extern cvar_t v_flipped;
24
25 sfx_t *S_FindName(const char *name);
26 int Sbar_GetSortedPlayerIndex (int index);
27 void Sbar_SortFrags (void);
28 void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
29 void CSQC_RelinkAllEntities (int drawmask);
30 void CSQC_RelinkCSQCEntities (void);
31 const char *Key_GetBind (int key);
32
33 // #1 void(vector ang) makevectors
34 static void VM_CL_makevectors (void)
35 {
36         VM_SAFEPARMCOUNT(1, VM_CL_makevectors);
37         AngleVectors (PRVM_G_VECTOR(OFS_PARM0), prog->globals.client->v_forward, prog->globals.client->v_right, prog->globals.client->v_up);
38 }
39
40 // #2 void(entity e, vector o) setorigin
41 void VM_CL_setorigin (void)
42 {
43         prvm_edict_t    *e;
44         float   *org;
45         VM_SAFEPARMCOUNT(2, VM_CL_setorigin);
46
47         e = PRVM_G_EDICT(OFS_PARM0);
48         if (e == prog->edicts)
49         {
50                 VM_Warning("setorigin: can not modify world entity\n");
51                 return;
52         }
53         if (e->priv.required->free)
54         {
55                 VM_Warning("setorigin: can not modify free entity\n");
56                 return;
57         }
58         org = PRVM_G_VECTOR(OFS_PARM1);
59         VectorCopy (org, e->fields.client->origin);
60         CL_LinkEdict(e);
61 }
62
63 static void SetMinMaxSize (prvm_edict_t *e, float *min, float *max)
64 {
65         int             i;
66
67         for (i=0 ; i<3 ; i++)
68                 if (min[i] > max[i])
69                         PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
70
71         // set derived values
72         VectorCopy (min, e->fields.client->mins);
73         VectorCopy (max, e->fields.client->maxs);
74         VectorSubtract (max, min, e->fields.client->size);
75
76         CL_LinkEdict (e);
77 }
78
79 // #3 void(entity e, string m) setmodel
80 void VM_CL_setmodel (void)
81 {
82         prvm_edict_t    *e;
83         const char              *m;
84         dp_model_t *mod;
85         int                             i;
86
87         VM_SAFEPARMCOUNT(2, VM_CL_setmodel);
88
89         e = PRVM_G_EDICT(OFS_PARM0);
90         e->fields.client->modelindex = 0;
91         e->fields.client->model = 0;
92
93         m = PRVM_G_STRING(OFS_PARM1);
94         mod = NULL;
95         for (i = 0;i < MAX_MODELS && cl.csqc_model_precache[i];i++)
96         {
97                 if (!strcmp(cl.csqc_model_precache[i]->name, m))
98                 {
99                         mod = cl.csqc_model_precache[i];
100                         e->fields.client->model = PRVM_SetEngineString(mod->name);
101                         e->fields.client->modelindex = -(i+1);
102                         break;
103                 }
104         }
105
106         if( !mod ) {
107                 for (i = 0;i < MAX_MODELS;i++)
108                 {
109                         mod = cl.model_precache[i];
110                         if (mod && !strcmp(mod->name, m))
111                         {
112                                 e->fields.client->model = PRVM_SetEngineString(mod->name);
113                                 e->fields.client->modelindex = i;
114                                 break;
115                         }
116                 }
117         }
118
119         if( mod ) {
120                 // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
121                 //SetMinMaxSize (e, mod->normalmins, mod->normalmaxs);
122         }
123         else
124         {
125                 SetMinMaxSize (e, vec3_origin, vec3_origin);
126                 VM_Warning ("setmodel: model '%s' not precached\n", m);
127         }
128 }
129
130 // #4 void(entity e, vector min, vector max) setsize
131 static void VM_CL_setsize (void)
132 {
133         prvm_edict_t    *e;
134         float                   *min, *max;
135         VM_SAFEPARMCOUNT(3, VM_CL_setsize);
136
137         e = PRVM_G_EDICT(OFS_PARM0);
138         if (e == prog->edicts)
139         {
140                 VM_Warning("setsize: can not modify world entity\n");
141                 return;
142         }
143         if (e->priv.server->free)
144         {
145                 VM_Warning("setsize: can not modify free entity\n");
146                 return;
147         }
148         min = PRVM_G_VECTOR(OFS_PARM1);
149         max = PRVM_G_VECTOR(OFS_PARM2);
150
151         SetMinMaxSize( e, min, max );
152
153         CL_LinkEdict(e);
154 }
155
156 // #8 void(entity e, float chan, string samp, float volume, float atten) sound
157 static void VM_CL_sound (void)
158 {
159         const char                      *sample;
160         int                                     channel;
161         prvm_edict_t            *entity;
162         float                           volume;
163         float                           attenuation;
164
165         VM_SAFEPARMCOUNT(5, VM_CL_sound);
166
167         entity = PRVM_G_EDICT(OFS_PARM0);
168         channel = (int)PRVM_G_FLOAT(OFS_PARM1);
169         sample = PRVM_G_STRING(OFS_PARM2);
170         volume = PRVM_G_FLOAT(OFS_PARM3);
171         attenuation = PRVM_G_FLOAT(OFS_PARM4);
172
173         if (volume < 0 || volume > 1)
174         {
175                 VM_Warning("VM_CL_sound: volume must be in range 0-1\n");
176                 return;
177         }
178
179         if (attenuation < 0 || attenuation > 4)
180         {
181                 VM_Warning("VM_CL_sound: attenuation must be in range 0-4\n");
182                 return;
183         }
184
185         if (channel < 0 || channel > 7)
186         {
187                 VM_Warning("VM_CL_sound: channel must be in range 0-7\n");
188                 return;
189         }
190
191         S_StartSound(32768 + PRVM_NUM_FOR_EDICT(entity), channel, S_FindName(sample), entity->fields.client->origin, volume, attenuation);
192 }
193
194 // #483 void(vector origin, string sample, float volume, float attenuation) pointsound
195 static void VM_CL_pointsound(void)
196 {
197         const char                      *sample;
198         float                           volume;
199         float                           attenuation;
200         vec3_t                          org;
201
202         VM_SAFEPARMCOUNT(4, VM_CL_pointsound);
203
204         VectorCopy( PRVM_G_VECTOR(OFS_PARM0), org);
205         sample = PRVM_G_STRING(OFS_PARM1);
206         volume = PRVM_G_FLOAT(OFS_PARM2);
207         attenuation = PRVM_G_FLOAT(OFS_PARM3);
208
209         if (volume < 0 || volume > 1)
210         {
211                 VM_Warning("VM_CL_pointsound: volume must be in range 0-1\n");
212                 return;
213         }
214
215         if (attenuation < 0 || attenuation > 4)
216         {
217                 VM_Warning("VM_CL_pointsound: attenuation must be in range 0-4\n");
218                 return;
219         }
220
221         // Send World Entity as Entity to Play Sound (for CSQC, that is 32768)
222         S_StartSound(32768, 0, S_FindName(sample), org, volume, attenuation);
223 }
224
225 // #14 entity() spawn
226 static void VM_CL_spawn (void)
227 {
228         prvm_edict_t *ed;
229         ed = PRVM_ED_Alloc();
230         VM_RETURN_EDICT(ed);
231 }
232
233 void CL_VM_SetTraceGlobals(const trace_t *trace, int svent)
234 {
235         prvm_eval_t *val;
236         VM_SetTraceGlobals(trace);
237         if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_networkentity)))
238                 val->_float = svent;
239 }
240
241 #define CL_HitNetworkBrushModels(move) !((move) == MOVE_WORLDONLY)
242 #define CL_HitNetworkPlayers(move)     !((move) == MOVE_WORLDONLY || (move) == MOVE_NOMONSTERS)
243
244 // #16 void(vector v1, vector v2, float movetype, entity ignore) traceline
245 static void VM_CL_traceline (void)
246 {
247         float   *v1, *v2;
248         trace_t trace;
249         int             move, svent;
250         prvm_edict_t    *ent;
251
252         VM_SAFEPARMCOUNTRANGE(4, 4, VM_CL_traceline);
253
254         prog->xfunction->builtinsprofile += 30;
255
256         v1 = PRVM_G_VECTOR(OFS_PARM0);
257         v2 = PRVM_G_VECTOR(OFS_PARM1);
258         move = (int)PRVM_G_FLOAT(OFS_PARM2);
259         ent = PRVM_G_EDICT(OFS_PARM3);
260
261         if (IS_NAN(v1[0]) || IS_NAN(v1[1]) || IS_NAN(v1[2]) || IS_NAN(v2[0]) || IS_NAN(v2[1]) || IS_NAN(v2[2]))
262                 PRVM_ERROR("%s: NAN errors detected in traceline('%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
263
264         trace = CL_Move(v1, vec3_origin, vec3_origin, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
265
266         CL_VM_SetTraceGlobals(&trace, svent);
267 }
268
269 /*
270 =================
271 VM_CL_tracebox
272
273 Used for use tracing and shot targeting
274 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
275 if the tryents flag is set.
276
277 tracebox (vector1, vector mins, vector maxs, vector2, tryents)
278 =================
279 */
280 // LordHavoc: added this for my own use, VERY useful, similar to traceline
281 static void VM_CL_tracebox (void)
282 {
283         float   *v1, *v2, *m1, *m2;
284         trace_t trace;
285         int             move, svent;
286         prvm_edict_t    *ent;
287
288         VM_SAFEPARMCOUNTRANGE(6, 8, VM_CL_tracebox); // allow more parameters for future expansion
289
290         prog->xfunction->builtinsprofile += 30;
291
292         v1 = PRVM_G_VECTOR(OFS_PARM0);
293         m1 = PRVM_G_VECTOR(OFS_PARM1);
294         m2 = PRVM_G_VECTOR(OFS_PARM2);
295         v2 = PRVM_G_VECTOR(OFS_PARM3);
296         move = (int)PRVM_G_FLOAT(OFS_PARM4);
297         ent = PRVM_G_EDICT(OFS_PARM5);
298
299         if (IS_NAN(v1[0]) || IS_NAN(v1[1]) || IS_NAN(v1[2]) || IS_NAN(v2[0]) || IS_NAN(v2[1]) || IS_NAN(v2[2]))
300                 PRVM_ERROR("%s: NAN errors detected in tracebox('%f %f %f', '%f %f %f', '%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], m1[0], m1[1], m1[2], m2[0], m2[1], m2[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
301
302         trace = CL_Move(v1, m1, m2, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
303
304         CL_VM_SetTraceGlobals(&trace, svent);
305 }
306
307 trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
308 {
309         int i;
310         float gravity;
311         vec3_t move, end;
312         vec3_t original_origin;
313         vec3_t original_velocity;
314         vec3_t original_angles;
315         vec3_t original_avelocity;
316         prvm_eval_t *val;
317         trace_t trace;
318
319         VectorCopy(tossent->fields.client->origin   , original_origin   );
320         VectorCopy(tossent->fields.client->velocity , original_velocity );
321         VectorCopy(tossent->fields.client->angles   , original_angles   );
322         VectorCopy(tossent->fields.client->avelocity, original_avelocity);
323
324         val = PRVM_EDICTFIELDVALUE(tossent, prog->fieldoffsets.gravity);
325         if (val != NULL && val->_float != 0)
326                 gravity = val->_float;
327         else
328                 gravity = 1.0;
329         gravity *= cl.movevars_gravity * 0.05;
330
331         for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
332         {
333                 tossent->fields.client->velocity[2] -= gravity;
334                 VectorMA (tossent->fields.client->angles, 0.05, tossent->fields.client->avelocity, tossent->fields.client->angles);
335                 VectorScale (tossent->fields.client->velocity, 0.05, move);
336                 VectorAdd (tossent->fields.client->origin, move, end);
337                 trace = CL_Move (tossent->fields.client->origin, tossent->fields.client->mins, tossent->fields.client->maxs, end, MOVE_NORMAL, tossent, CL_GenericHitSuperContentsMask(tossent), true, true, NULL, true);
338                 VectorCopy (trace.endpos, tossent->fields.client->origin);
339
340                 if (trace.fraction < 1)
341                         break;
342         }
343
344         VectorCopy(original_origin   , tossent->fields.client->origin   );
345         VectorCopy(original_velocity , tossent->fields.client->velocity );
346         VectorCopy(original_angles   , tossent->fields.client->angles   );
347         VectorCopy(original_avelocity, tossent->fields.client->avelocity);
348
349         return trace;
350 }
351
352 static void VM_CL_tracetoss (void)
353 {
354         trace_t trace;
355         prvm_edict_t    *ent;
356         prvm_edict_t    *ignore;
357         int svent;
358
359         prog->xfunction->builtinsprofile += 600;
360
361         VM_SAFEPARMCOUNT(2, VM_CL_tracetoss);
362
363         ent = PRVM_G_EDICT(OFS_PARM0);
364         if (ent == prog->edicts)
365         {
366                 VM_Warning("tracetoss: can not use world entity\n");
367                 return;
368         }
369         ignore = PRVM_G_EDICT(OFS_PARM1);
370
371         trace = CL_Trace_Toss (ent, ignore, &svent);
372
373         CL_VM_SetTraceGlobals(&trace, svent);
374 }
375
376
377 // #20 void(string s) precache_model
378 void VM_CL_precache_model (void)
379 {
380         const char      *name;
381         int                     i;
382         dp_model_t              *m;
383
384         VM_SAFEPARMCOUNT(1, VM_CL_precache_model);
385
386         name = PRVM_G_STRING(OFS_PARM0);
387         for (i = 0;i < MAX_MODELS && cl.csqc_model_precache[i];i++)
388         {
389                 if(!strcmp(cl.csqc_model_precache[i]->name, name))
390                 {
391                         PRVM_G_FLOAT(OFS_RETURN) = -(i+1);
392                         return;
393                 }
394         }
395         PRVM_G_FLOAT(OFS_RETURN) = 0;
396         m = Mod_ForName(name, false, false, name[0] == '*' ? cl.model_name[1] : NULL);
397         if(m && m->loaded)
398         {
399                 for (i = 0;i < MAX_MODELS;i++)
400                 {
401                         if (!cl.csqc_model_precache[i])
402                         {
403                                 cl.csqc_model_precache[i] = (dp_model_t*)m;
404                                 PRVM_G_FLOAT(OFS_RETURN) = -(i+1);
405                                 return;
406                         }
407                 }
408                 VM_Warning("VM_CL_precache_model: no free models\n");
409                 return;
410         }
411         VM_Warning("VM_CL_precache_model: model \"%s\" not found\n", name);
412 }
413
414 int CSQC_EntitiesInBox (vec3_t mins, vec3_t maxs, int maxlist, prvm_edict_t **list)
415 {
416         prvm_edict_t    *ent;
417         int                             i, k;
418
419         ent = PRVM_NEXT_EDICT(prog->edicts);
420         for(k=0,i=1; i<prog->num_edicts ;i++, ent = PRVM_NEXT_EDICT(ent))
421         {
422                 if (ent->priv.required->free)
423                         continue;
424                 if(BoxesOverlap(mins, maxs, ent->fields.client->absmin, ent->fields.client->absmax))
425                         list[k++] = ent;
426         }
427         return k;
428 }
429
430 // #22 entity(vector org, float rad) findradius
431 static void VM_CL_findradius (void)
432 {
433         prvm_edict_t    *ent, *chain;
434         vec_t                   radius, radius2;
435         vec3_t                  org, eorg, mins, maxs;
436         int                             i, numtouchedicts;
437         prvm_edict_t    *touchedicts[MAX_EDICTS];
438         int             chainfield;
439
440         VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_findradius);
441
442         if(prog->argc == 3)
443                 chainfield = PRVM_G_INT(OFS_PARM2);
444         else
445                 chainfield = prog->fieldoffsets.chain;
446         if(chainfield < 0)
447                 PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME);
448
449         chain = (prvm_edict_t *)prog->edicts;
450
451         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
452         radius = PRVM_G_FLOAT(OFS_PARM1);
453         radius2 = radius * radius;
454
455         mins[0] = org[0] - (radius + 1);
456         mins[1] = org[1] - (radius + 1);
457         mins[2] = org[2] - (radius + 1);
458         maxs[0] = org[0] + (radius + 1);
459         maxs[1] = org[1] + (radius + 1);
460         maxs[2] = org[2] + (radius + 1);
461         numtouchedicts = CSQC_EntitiesInBox(mins, maxs, MAX_EDICTS, touchedicts);
462         if (numtouchedicts > MAX_EDICTS)
463         {
464                 // this never happens   //[515]: for what then ?
465                 Con_Printf("CSQC_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
466                 numtouchedicts = MAX_EDICTS;
467         }
468         for (i = 0;i < numtouchedicts;i++)
469         {
470                 ent = touchedicts[i];
471                 // Quake did not return non-solid entities but darkplaces does
472                 // (note: this is the reason you can't blow up fallen zombies)
473                 if (ent->fields.client->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
474                         continue;
475                 // LordHavoc: compare against bounding box rather than center so it
476                 // doesn't miss large objects, and use DotProduct instead of Length
477                 // for a major speedup
478                 VectorSubtract(org, ent->fields.client->origin, eorg);
479                 if (sv_gameplayfix_findradiusdistancetobox.integer)
480                 {
481                         eorg[0] -= bound(ent->fields.client->mins[0], eorg[0], ent->fields.client->maxs[0]);
482                         eorg[1] -= bound(ent->fields.client->mins[1], eorg[1], ent->fields.client->maxs[1]);
483                         eorg[2] -= bound(ent->fields.client->mins[2], eorg[2], ent->fields.client->maxs[2]);
484                 }
485                 else
486                         VectorMAMAM(1, eorg, -0.5f, ent->fields.client->mins, -0.5f, ent->fields.client->maxs, eorg);
487                 if (DotProduct(eorg, eorg) < radius2)
488                 {
489                         PRVM_EDICTFIELDVALUE(ent, chainfield)->edict = PRVM_EDICT_TO_PROG(chain);
490                         chain = ent;
491                 }
492         }
493
494         VM_RETURN_EDICT(chain);
495 }
496
497 // #34 float() droptofloor
498 static void VM_CL_droptofloor (void)
499 {
500         prvm_edict_t            *ent;
501         prvm_eval_t                     *val;
502         vec3_t                          end;
503         trace_t                         trace;
504
505         VM_SAFEPARMCOUNTRANGE(0, 2, VM_CL_droptofloor); // allow 2 parameters because the id1 defs.qc had an incorrect prototype
506
507         // assume failure if it returns early
508         PRVM_G_FLOAT(OFS_RETURN) = 0;
509
510         ent = PRVM_PROG_TO_EDICT(prog->globals.client->self);
511         if (ent == prog->edicts)
512         {
513                 VM_Warning("droptofloor: can not modify world entity\n");
514                 return;
515         }
516         if (ent->priv.server->free)
517         {
518                 VM_Warning("droptofloor: can not modify free entity\n");
519                 return;
520         }
521
522         VectorCopy (ent->fields.client->origin, end);
523         end[2] -= 256;
524
525         trace = CL_Move(ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
526
527         if (trace.fraction != 1)
528         {
529                 VectorCopy (trace.endpos, ent->fields.client->origin);
530                 ent->fields.client->flags = (int)ent->fields.client->flags | FL_ONGROUND;
531                 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.groundentity)))
532                         val->edict = PRVM_EDICT_TO_PROG(trace.ent);
533                 PRVM_G_FLOAT(OFS_RETURN) = 1;
534                 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
535 //              ent->priv.server->suspendedinairflag = true;
536         }
537 }
538
539 // #35 void(float style, string value) lightstyle
540 static void VM_CL_lightstyle (void)
541 {
542         int                     i;
543         const char      *c;
544
545         VM_SAFEPARMCOUNT(2, VM_CL_lightstyle);
546
547         i = (int)PRVM_G_FLOAT(OFS_PARM0);
548         c = PRVM_G_STRING(OFS_PARM1);
549         if (i >= cl.max_lightstyle)
550         {
551                 VM_Warning("VM_CL_lightstyle >= MAX_LIGHTSTYLES\n");
552                 return;
553         }
554         strlcpy (cl.lightstyle[i].map, c, sizeof (cl.lightstyle[i].map));
555         cl.lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
556         cl.lightstyle[i].length = (int)strlen(cl.lightstyle[i].map);
557 }
558
559 // #40 float(entity e) checkbottom
560 static void VM_CL_checkbottom (void)
561 {
562         static int              cs_yes, cs_no;
563         prvm_edict_t    *ent;
564         vec3_t                  mins, maxs, start, stop;
565         trace_t                 trace;
566         int                             x, y;
567         float                   mid, bottom;
568
569         VM_SAFEPARMCOUNT(1, VM_CL_checkbottom);
570         ent = PRVM_G_EDICT(OFS_PARM0);
571         PRVM_G_FLOAT(OFS_RETURN) = 0;
572
573         VectorAdd (ent->fields.client->origin, ent->fields.client->mins, mins);
574         VectorAdd (ent->fields.client->origin, ent->fields.client->maxs, maxs);
575
576 // if all of the points under the corners are solid world, don't bother
577 // with the tougher checks
578 // the corners must be within 16 of the midpoint
579         start[2] = mins[2] - 1;
580         for     (x=0 ; x<=1 ; x++)
581                 for     (y=0 ; y<=1 ; y++)
582                 {
583                         start[0] = x ? maxs[0] : mins[0];
584                         start[1] = y ? maxs[1] : mins[1];
585                         if (!(CL_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
586                                 goto realcheck;
587                 }
588
589         cs_yes++;
590         PRVM_G_FLOAT(OFS_RETURN) = true;
591         return;         // we got out easy
592
593 realcheck:
594         cs_no++;
595 //
596 // check it for real...
597 //
598         start[2] = mins[2];
599
600 // the midpoint must be within 16 of the bottom
601         start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
602         start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
603         stop[2] = start[2] - 2*sv_stepheight.value;
604         trace = CL_Move (start, vec3_origin, vec3_origin, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
605
606         if (trace.fraction == 1.0)
607                 return;
608
609         mid = bottom = trace.endpos[2];
610
611 // the corners must be within 16 of the midpoint
612         for     (x=0 ; x<=1 ; x++)
613                 for     (y=0 ; y<=1 ; y++)
614                 {
615                         start[0] = stop[0] = x ? maxs[0] : mins[0];
616                         start[1] = stop[1] = y ? maxs[1] : mins[1];
617
618                         trace = CL_Move (start, vec3_origin, vec3_origin, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
619
620                         if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
621                                 bottom = trace.endpos[2];
622                         if (trace.fraction == 1.0 || mid - trace.endpos[2] > sv_stepheight.value)
623                                 return;
624                 }
625
626         cs_yes++;
627         PRVM_G_FLOAT(OFS_RETURN) = true;
628 }
629
630 // #41 float(vector v) pointcontents
631 static void VM_CL_pointcontents (void)
632 {
633         VM_SAFEPARMCOUNT(1, VM_CL_pointcontents);
634         PRVM_G_FLOAT(OFS_RETURN) = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, CL_PointSuperContents(PRVM_G_VECTOR(OFS_PARM0)));
635 }
636
637 // #48 void(vector o, vector d, float color, float count) particle
638 static void VM_CL_particle (void)
639 {
640         float   *org, *dir;
641         int             count;
642         unsigned char   color;
643         VM_SAFEPARMCOUNT(4, VM_CL_particle);
644
645         org = PRVM_G_VECTOR(OFS_PARM0);
646         dir = PRVM_G_VECTOR(OFS_PARM1);
647         color = (int)PRVM_G_FLOAT(OFS_PARM2);
648         count = (int)PRVM_G_FLOAT(OFS_PARM3);
649         CL_ParticleEffect(EFFECT_SVC_PARTICLE, count, org, org, dir, dir, NULL, color);
650 }
651
652 // #74 void(vector pos, string samp, float vol, float atten) ambientsound
653 static void VM_CL_ambientsound (void)
654 {
655         float   *f;
656         sfx_t   *s;
657         VM_SAFEPARMCOUNT(4, VM_CL_ambientsound);
658         s = S_FindName(PRVM_G_STRING(OFS_PARM0));
659         f = PRVM_G_VECTOR(OFS_PARM1);
660         S_StaticSound (s, f, PRVM_G_FLOAT(OFS_PARM2), PRVM_G_FLOAT(OFS_PARM3)*64);
661 }
662
663 // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
664 static void VM_CL_getlight (void)
665 {
666         vec3_t ambientcolor, diffusecolor, diffusenormal;
667         vec_t *p;
668
669         VM_SAFEPARMCOUNT(1, VM_CL_getlight);
670
671         p = PRVM_G_VECTOR(OFS_PARM0);
672         VectorClear(ambientcolor);
673         VectorClear(diffusecolor);
674         VectorClear(diffusenormal);
675         if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
676                 cl.worldmodel->brush.LightPoint(cl.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
677         VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
678 }
679
680
681 //============================================================================
682 //[515]: SCENE MANAGER builtins
683 extern qboolean CSQC_AddRenderEdict (prvm_edict_t *ed);//csprogs.c
684
685 static void CSQC_R_RecalcView (void)
686 {
687         extern matrix4x4_t viewmodelmatrix;
688         Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, cl.csqc_origin[0], cl.csqc_origin[1], cl.csqc_origin[2], cl.csqc_angles[0], cl.csqc_angles[1], cl.csqc_angles[2], 1);
689         Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix, cl.csqc_origin[0], cl.csqc_origin[1], cl.csqc_origin[2], cl.csqc_angles[0], cl.csqc_angles[1], cl.csqc_angles[2], cl_viewmodel_scale.value);
690 }
691
692 void CL_RelinkLightFlashes(void);
693 //#300 void() clearscene (EXT_CSQC)
694 void VM_CL_R_ClearScene (void)
695 {
696         VM_SAFEPARMCOUNT(0, VM_CL_R_ClearScene);
697         // clear renderable entity and light lists
698         r_refdef.scene.numentities = 0;
699         r_refdef.scene.numlights = 0;
700         // FIXME: restore these to the values from VM_CL_UpdateView
701         r_refdef.view.x = 0;
702         r_refdef.view.y = 0;
703         r_refdef.view.z = 0;
704         r_refdef.view.width = vid.width;
705         r_refdef.view.height = vid.height;
706         r_refdef.view.depth = 1;
707         // FIXME: restore frustum_x/frustum_y
708         r_refdef.view.useperspective = true;
709         r_refdef.view.frustum_y = tan(scr_fov.value * M_PI / 360.0) * (3.0/4.0) * cl.viewzoom;
710         r_refdef.view.frustum_x = r_refdef.view.frustum_y * (float)r_refdef.view.width / (float)r_refdef.view.height / vid_pixelheight.value;
711         r_refdef.view.frustum_x *= r_refdef.frustumscale_x;
712         r_refdef.view.frustum_y *= r_refdef.frustumscale_y;
713         r_refdef.view.ortho_x = scr_fov.value * (3.0 / 4.0) * (float)r_refdef.view.width / (float)r_refdef.view.height / vid_pixelheight.value;
714         r_refdef.view.ortho_y = scr_fov.value * (3.0 / 4.0);
715         r_refdef.view.clear = true;
716         r_refdef.view.isoverlay = false;
717         // FIXME: restore cl.csqc_origin
718         // FIXME: restore cl.csqc_angles
719         cl.csqc_vidvars.drawworld = true;
720         cl.csqc_vidvars.drawenginesbar = false;
721         cl.csqc_vidvars.drawcrosshair = false;
722 }
723
724 //#301 void(float mask) addentities (EXT_CSQC)
725 extern void CSQC_Predraw (prvm_edict_t *ed);//csprogs.c
726 extern void CSQC_Think (prvm_edict_t *ed);//csprogs.c
727 void VM_CL_R_AddEntities (void)
728 {
729         int                     i, drawmask;
730         prvm_edict_t *ed;
731         VM_SAFEPARMCOUNT(1, VM_CL_R_AddEntities);
732         drawmask = (int)PRVM_G_FLOAT(OFS_PARM0);
733         CSQC_RelinkAllEntities(drawmask);
734         CL_RelinkLightFlashes();
735
736         prog->globals.client->time = cl.time;
737         for(i=1;i<prog->num_edicts;i++)
738         {
739                 ed = &prog->edicts[i];
740                 if(ed->priv.required->free)
741                         continue;
742                 CSQC_Think(ed);
743                 if(ed->priv.required->free)
744                         continue;
745                 // note that for RF_USEAXIS entities, Predraw sets v_forward/v_right/v_up globals that are read by CSQC_AddRenderEdict
746                 CSQC_Predraw(ed);
747                 if(ed->priv.required->free)
748                         continue;
749                 if(!((int)ed->fields.client->drawmask & drawmask))
750                         continue;
751                 CSQC_AddRenderEdict(ed);
752         }
753 }
754
755 //#302 void(entity ent) addentity (EXT_CSQC)
756 void VM_CL_R_AddEntity (void)
757 {
758         VM_SAFEPARMCOUNT(1, VM_CL_R_AddEntity);
759         CSQC_AddRenderEdict(PRVM_G_EDICT(OFS_PARM0));
760 }
761
762 //#303 float(float property, ...) setproperty (EXT_CSQC)
763 void VM_CL_R_SetView (void)
764 {
765         int             c;
766         float   *f;
767         float   k;
768
769         VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_R_SetView);
770
771         c = (int)PRVM_G_FLOAT(OFS_PARM0);
772         f = PRVM_G_VECTOR(OFS_PARM1);
773         k = PRVM_G_FLOAT(OFS_PARM1);
774
775         switch(c)
776         {
777         case VF_MIN:
778                 r_refdef.view.x = (int)(f[0]);
779                 r_refdef.view.y = (int)(f[1]);
780                 break;
781         case VF_MIN_X:
782                 r_refdef.view.x = (int)(k);
783                 break;
784         case VF_MIN_Y:
785                 r_refdef.view.y = (int)(k);
786                 break;
787         case VF_SIZE:
788                 r_refdef.view.width = (int)(f[0]);
789                 r_refdef.view.height = (int)(f[1]);
790                 break;
791         case VF_SIZE_X:
792                 r_refdef.view.width = (int)(k);
793                 break;
794         case VF_SIZE_Y:
795                 r_refdef.view.height = (int)(k);
796                 break;
797         case VF_VIEWPORT:
798                 r_refdef.view.x = (int)(f[0]);
799                 r_refdef.view.y = (int)(f[1]);
800                 f = PRVM_G_VECTOR(OFS_PARM2);
801                 r_refdef.view.width = (int)(f[0]);
802                 r_refdef.view.height = (int)(f[1]);
803                 break;
804         case VF_FOV:
805                 r_refdef.view.frustum_x = tan(f[0] * M_PI / 360.0);r_refdef.view.ortho_x = f[0];
806                 r_refdef.view.frustum_y = tan(f[1] * M_PI / 360.0);r_refdef.view.ortho_y = f[1];
807                 break;
808         case VF_FOVX:
809                 r_refdef.view.frustum_x = tan(k * M_PI / 360.0);r_refdef.view.ortho_x = k;
810                 break;
811         case VF_FOVY:
812                 r_refdef.view.frustum_y = tan(k * M_PI / 360.0);r_refdef.view.ortho_y = k;
813                 break;
814         case VF_ORIGIN:
815                 VectorCopy(f, cl.csqc_origin);
816                 CSQC_R_RecalcView();
817                 break;
818         case VF_ORIGIN_X:
819                 cl.csqc_origin[0] = k;
820                 CSQC_R_RecalcView();
821                 break;
822         case VF_ORIGIN_Y:
823                 cl.csqc_origin[1] = k;
824                 CSQC_R_RecalcView();
825                 break;
826         case VF_ORIGIN_Z:
827                 cl.csqc_origin[2] = k;
828                 CSQC_R_RecalcView();
829                 break;
830         case VF_ANGLES:
831                 VectorCopy(f, cl.csqc_angles);
832                 CSQC_R_RecalcView();
833                 break;
834         case VF_ANGLES_X:
835                 cl.csqc_angles[0] = k;
836                 CSQC_R_RecalcView();
837                 break;
838         case VF_ANGLES_Y:
839                 cl.csqc_angles[1] = k;
840                 CSQC_R_RecalcView();
841                 break;
842         case VF_ANGLES_Z:
843                 cl.csqc_angles[2] = k;
844                 CSQC_R_RecalcView();
845                 break;
846         case VF_DRAWWORLD:
847                 cl.csqc_vidvars.drawworld = k;
848                 break;
849         case VF_DRAWENGINESBAR:
850                 cl.csqc_vidvars.drawenginesbar = k;
851                 break;
852         case VF_DRAWCROSSHAIR:
853                 cl.csqc_vidvars.drawcrosshair = k;
854                 break;
855         case VF_CL_VIEWANGLES:
856                 VectorCopy(f, cl.viewangles);
857                 break;
858         case VF_CL_VIEWANGLES_X:
859                 cl.viewangles[0] = k;
860                 break;
861         case VF_CL_VIEWANGLES_Y:
862                 cl.viewangles[1] = k;
863                 break;
864         case VF_CL_VIEWANGLES_Z:
865                 cl.viewangles[2] = k;
866                 break;
867         case VF_PERSPECTIVE:
868                 r_refdef.view.useperspective = k != 0;
869                 break;
870         case VF_CLEARSCREEN:
871                 r_refdef.view.isoverlay = !k;
872                 break;
873         default:
874                 PRVM_G_FLOAT(OFS_RETURN) = 0;
875                 VM_Warning("VM_CL_R_SetView : unknown parm %i\n", c);
876                 return;
877         }
878         PRVM_G_FLOAT(OFS_RETURN) = 1;
879 }
880
881 //#305 void(vector org, float radius, vector lightcolours[, float style, string cubemapname, float pflags]) adddynamiclight (EXT_CSQC)
882 void VM_CL_R_AddDynamicLight (void)
883 {
884         vec_t *org;
885         float radius = 300;
886         vec_t *col;
887         int style = -1;
888         const char *cubemapname = NULL;
889         int pflags = PFLAGS_CORONA | PFLAGS_FULLDYNAMIC;
890         float coronaintensity = 1;
891         float coronasizescale = 0.25;
892         qboolean castshadow = true;
893         float ambientscale = 0;
894         float diffusescale = 1;
895         float specularscale = 1;
896         matrix4x4_t matrix;
897         vec3_t forward, left, up;
898         VM_SAFEPARMCOUNTRANGE(3, 8, VM_CL_R_AddDynamicLight);
899
900         // if we've run out of dlights, just return
901         if (r_refdef.scene.numlights >= MAX_DLIGHTS)
902                 return;
903
904         org = PRVM_G_VECTOR(OFS_PARM0);
905         radius = PRVM_G_FLOAT(OFS_PARM1);
906         col = PRVM_G_VECTOR(OFS_PARM2);
907         if (prog->argc >= 4)
908         {
909                 style = (int)PRVM_G_FLOAT(OFS_PARM3);
910                 if (style >= MAX_LIGHTSTYLES)
911                 {
912                         Con_DPrintf("VM_CL_R_AddDynamicLight: out of bounds lightstyle index %i\n", style);
913                         style = -1;
914                 }
915         }
916         if (prog->argc >= 5)
917                 cubemapname = PRVM_G_STRING(OFS_PARM4);
918         if (prog->argc >= 6)
919                 pflags = (int)PRVM_G_FLOAT(OFS_PARM5);
920         coronaintensity = (pflags & PFLAGS_CORONA) != 0;
921         castshadow = (pflags & PFLAGS_NOSHADOW) == 0;
922
923         VectorScale(prog->globals.client->v_forward, radius, forward);
924         VectorScale(prog->globals.client->v_right, -radius, left);
925         VectorScale(prog->globals.client->v_up, radius, up);
926         Matrix4x4_FromVectors(&matrix, forward, left, up, org);
927
928         R_RTLight_Update(&r_refdef.scene.templights[r_refdef.scene.numlights], false, &matrix, col, style, cubemapname, castshadow, coronaintensity, coronasizescale, ambientscale, diffusescale, specularscale, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
929         r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights++];
930 }
931
932 //============================================================================
933
934 //#310 vector (vector v) cs_unproject (EXT_CSQC)
935 static void VM_CL_unproject (void)
936 {
937         float   *f;
938         vec3_t  temp;
939
940         VM_SAFEPARMCOUNT(1, VM_CL_unproject);
941         f = PRVM_G_VECTOR(OFS_PARM0);
942         if(v_flipped.integer)
943                 f[0] = (2 * r_refdef.view.x + r_refdef.view.width) * (vid_conwidth.integer / (float) vid.width) - f[0];
944         VectorSet(temp,
945                 f[2],
946                 (-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,
947                 (-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);
948         Matrix4x4_Transform(&r_refdef.view.matrix, temp, PRVM_G_VECTOR(OFS_RETURN));
949 }
950
951 //#311 vector (vector v) cs_project (EXT_CSQC)
952 static void VM_CL_project (void)
953 {
954         float   *f;
955         vec3_t  v;
956         matrix4x4_t m;
957
958         VM_SAFEPARMCOUNT(1, VM_CL_project);
959         f = PRVM_G_VECTOR(OFS_PARM0);
960         Matrix4x4_Invert_Simple(&m, &r_refdef.view.matrix);
961         Matrix4x4_Transform(&m, f, v);
962         if(v_flipped.integer)
963                 v[1] = -v[1];
964         VectorSet(PRVM_G_VECTOR(OFS_RETURN),
965                 (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)),
966                 (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)),
967                 v[0]);
968 }
969
970 //#330 float(float stnum) getstatf (EXT_CSQC)
971 static void VM_CL_getstatf (void)
972 {
973         int i;
974         union
975         {
976                 float f;
977                 int l;
978         }dat;
979         VM_SAFEPARMCOUNT(1, VM_CL_getstatf);
980         i = (int)PRVM_G_FLOAT(OFS_PARM0);
981         if(i < 0 || i >= MAX_CL_STATS)
982         {
983                 VM_Warning("VM_CL_getstatf: index>=MAX_CL_STATS or index<0\n");
984                 return;
985         }
986         dat.l = cl.stats[i];
987         PRVM_G_FLOAT(OFS_RETURN) =  dat.f;
988 }
989
990 //#331 float(float stnum) getstati (EXT_CSQC)
991 static void VM_CL_getstati (void)
992 {
993         int i, index;
994         int firstbit, bitcount;
995
996         VM_SAFEPARMCOUNTRANGE(1, 3, VM_CL_getstati);
997
998         index = (int)PRVM_G_FLOAT(OFS_PARM0);
999         if (prog->argc > 1)
1000         {
1001                 firstbit = (int)PRVM_G_FLOAT(OFS_PARM1);
1002                 if (prog->argc > 2)
1003                         bitcount = (int)PRVM_G_FLOAT(OFS_PARM2);
1004                 else
1005                         bitcount = 1;
1006         }
1007         else
1008         {
1009                 firstbit = 0;
1010                 bitcount = 32;
1011         }
1012
1013         if(index < 0 || index >= MAX_CL_STATS)
1014         {
1015                 VM_Warning("VM_CL_getstati: index>=MAX_CL_STATS or index<0\n");
1016                 return;
1017         }
1018         i = cl.stats[index];
1019         if (bitcount != 32)     //32 causes the mask to overflow, so there's nothing to subtract from.
1020                 i = (((unsigned int)i)&(((1<<bitcount)-1)<<firstbit))>>firstbit;
1021         PRVM_G_FLOAT(OFS_RETURN) = i;
1022 }
1023
1024 //#332 string(float firststnum) getstats (EXT_CSQC)
1025 static void VM_CL_getstats (void)
1026 {
1027         int i;
1028         char t[17];
1029         VM_SAFEPARMCOUNT(1, VM_CL_getstats);
1030         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1031         if(i < 0 || i > MAX_CL_STATS-4)
1032         {
1033                 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1034                 VM_Warning("VM_CL_getstats: index>MAX_CL_STATS-4 or index<0\n");
1035                 return;
1036         }
1037         strlcpy(t, (char*)&cl.stats[i], sizeof(t));
1038         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
1039 }
1040
1041 //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
1042 static void VM_CL_setmodelindex (void)
1043 {
1044         int                             i;
1045         prvm_edict_t    *t;
1046         struct model_s  *model;
1047
1048         VM_SAFEPARMCOUNT(2, VM_CL_setmodelindex);
1049
1050         t = PRVM_G_EDICT(OFS_PARM0);
1051
1052         i = (int)PRVM_G_FLOAT(OFS_PARM1);
1053
1054         t->fields.client->model = 0;
1055         t->fields.client->modelindex = 0;
1056
1057         if (!i)
1058                 return;
1059
1060         model = CL_GetModelByIndex(i);
1061         if (!model)
1062         {
1063                 VM_Warning("VM_CL_setmodelindex: null model\n");
1064                 return;
1065         }
1066         t->fields.client->model = PRVM_SetEngineString(model->name);
1067         t->fields.client->modelindex = i;
1068
1069         // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
1070         if (model)
1071         {
1072                 SetMinMaxSize (t, model->normalmins, model->normalmaxs);
1073         }
1074         else
1075                 SetMinMaxSize (t, vec3_origin, vec3_origin);
1076 }
1077
1078 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
1079 static void VM_CL_modelnameforindex (void)
1080 {
1081         dp_model_t *model;
1082
1083         VM_SAFEPARMCOUNT(1, VM_CL_modelnameforindex);
1084
1085         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1086         model = CL_GetModelByIndex((int)PRVM_G_FLOAT(OFS_PARM0));
1087         PRVM_G_INT(OFS_RETURN) = model ? PRVM_SetEngineString(model->name) : 0;
1088 }
1089
1090 //#335 float(string effectname) particleeffectnum (EXT_CSQC)
1091 static void VM_CL_particleeffectnum (void)
1092 {
1093         int                     i;
1094         VM_SAFEPARMCOUNT(1, VM_CL_particleeffectnum);
1095         i = CL_ParticleEffectIndexForName(PRVM_G_STRING(OFS_PARM0));
1096         if (i == 0)
1097                 i = -1;
1098         PRVM_G_FLOAT(OFS_RETURN) = i;
1099 }
1100
1101 // #336 void(entity ent, float effectnum, vector start, vector end[, float color]) trailparticles (EXT_CSQC)
1102 static void VM_CL_trailparticles (void)
1103 {
1104         int                             i;
1105         float                   *start, *end;
1106         prvm_edict_t    *t;
1107         VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_trailparticles);
1108
1109         t = PRVM_G_EDICT(OFS_PARM0);
1110         i               = (int)PRVM_G_FLOAT(OFS_PARM1);
1111         start   = PRVM_G_VECTOR(OFS_PARM2);
1112         end             = PRVM_G_VECTOR(OFS_PARM3);
1113
1114         if (i < 0)
1115                 return;
1116         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);
1117 }
1118
1119 //#337 void(float effectnum, vector origin, vector dir, float count[, float color]) pointparticles (EXT_CSQC)
1120 static void VM_CL_pointparticles (void)
1121 {
1122         int                     i, n;
1123         float           *f, *v;
1124         VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_pointparticles);
1125         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1126         f = PRVM_G_VECTOR(OFS_PARM1);
1127         v = PRVM_G_VECTOR(OFS_PARM2);
1128         n = (int)PRVM_G_FLOAT(OFS_PARM3);
1129         if (i < 0)
1130                 return;
1131         CL_ParticleEffect(i, n, f, f, v, v, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
1132 }
1133
1134 //#342 string(float keynum) getkeybind (EXT_CSQC)
1135 static void VM_CL_getkeybind (void)
1136 {
1137         VM_SAFEPARMCOUNT(1, VM_CL_getkeybind);
1138         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_GetBind((int)PRVM_G_FLOAT(OFS_PARM0)));
1139 }
1140
1141 //#343 void(float usecursor) setcursormode (EXT_CSQC)
1142 static void VM_CL_setcursormode (void)
1143 {
1144         VM_SAFEPARMCOUNT(1, VM_CL_setcursormode);
1145         cl.csqc_wantsmousemove = PRVM_G_FLOAT(OFS_PARM0);
1146         cl_ignoremousemoves = 2;
1147 }
1148
1149 //#344 vector() getmousepos (EXT_CSQC)
1150 static void VM_CL_getmousepos(void)
1151 {
1152         VM_SAFEPARMCOUNT(0,VM_CL_getmousepos);
1153
1154         if (key_consoleactive || key_dest != key_game)
1155                 VectorSet(PRVM_G_VECTOR(OFS_RETURN), 0, 0, 0);
1156         else if (cl.csqc_wantsmousemove)
1157                 VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_windowmouse_x * vid_conwidth.integer / vid.width, in_windowmouse_y * vid_conheight.integer / vid.height, 0);
1158         else
1159                 VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_mouse_x * vid_conwidth.integer / vid.width, in_mouse_y * vid_conheight.integer / vid.height, 0);
1160 }
1161
1162 //#345 float(float framenum) getinputstate (EXT_CSQC)
1163 static void VM_CL_getinputstate (void)
1164 {
1165         int i, frame;
1166         VM_SAFEPARMCOUNT(1, VM_CL_getinputstate);
1167         frame = (int)PRVM_G_FLOAT(OFS_PARM0);
1168         PRVM_G_FLOAT(OFS_RETURN) = false;
1169         for (i = 0;i < CL_MAX_USERCMDS;i++)
1170         {
1171                 if (cl.movecmd[i].sequence == frame)
1172                 {
1173                         VectorCopy(cl.movecmd[i].viewangles, prog->globals.client->input_angles);
1174                         prog->globals.client->input_buttons = cl.movecmd[i].buttons; // FIXME: this should not be directly exposed to csqc (translation layer needed?)
1175                         prog->globals.client->input_movevalues[0] = cl.movecmd[i].forwardmove;
1176                         prog->globals.client->input_movevalues[1] = cl.movecmd[i].sidemove;
1177                         prog->globals.client->input_movevalues[2] = cl.movecmd[i].upmove;
1178                         prog->globals.client->input_timelength = cl.movecmd[i].frametime;
1179                         if(cl.movecmd[i].crouch)
1180                         {
1181                                 VectorCopy(cl.playercrouchmins, prog->globals.client->pmove_mins);
1182                                 VectorCopy(cl.playercrouchmaxs, prog->globals.client->pmove_maxs);
1183                         }
1184                         else
1185                         {
1186                                 VectorCopy(cl.playerstandmins, prog->globals.client->pmove_mins);
1187                                 VectorCopy(cl.playerstandmaxs, prog->globals.client->pmove_maxs);
1188                         }
1189                         PRVM_G_FLOAT(OFS_RETURN) = true;
1190                 }
1191         }
1192 }
1193
1194 //#346 void(float sens) setsensitivityscaler (EXT_CSQC)
1195 static void VM_CL_setsensitivityscale (void)
1196 {
1197         VM_SAFEPARMCOUNT(1, VM_CL_setsensitivityscale);
1198         cl.sensitivityscale = PRVM_G_FLOAT(OFS_PARM0);
1199 }
1200
1201 //#347 void() runstandardplayerphysics (EXT_CSQC)
1202 static void VM_CL_runplayerphysics (void)
1203 {
1204 }
1205
1206 //#348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
1207 static void VM_CL_getplayerkey (void)
1208 {
1209         int                     i;
1210         char            t[128];
1211         const char      *c;
1212
1213         VM_SAFEPARMCOUNT(2, VM_CL_getplayerkey);
1214
1215         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1216         c = PRVM_G_STRING(OFS_PARM1);
1217         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1218         Sbar_SortFrags();
1219
1220         if (i < 0)
1221                 i = Sbar_GetSortedPlayerIndex(-1-i);
1222         if(i < 0 || i >= cl.maxclients)
1223                 return;
1224
1225         t[0] = 0;
1226
1227         if(!strcasecmp(c, "name"))
1228                 strlcpy(t, cl.scores[i].name, sizeof(t));
1229         else
1230                 if(!strcasecmp(c, "frags"))
1231                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].frags);
1232         else
1233                 if(!strcasecmp(c, "ping"))
1234                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_ping);
1235         else
1236                 if(!strcasecmp(c, "pl"))
1237                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_packetloss);
1238         else
1239                 if(!strcasecmp(c, "entertime"))
1240                         dpsnprintf(t, sizeof(t), "%f", cl.scores[i].qw_entertime);
1241         else
1242                 if(!strcasecmp(c, "colors"))
1243                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].colors);
1244         else
1245                 if(!strcasecmp(c, "topcolor"))
1246                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].colors & 0xf0);
1247         else
1248                 if(!strcasecmp(c, "bottomcolor"))
1249                         dpsnprintf(t, sizeof(t), "%i", (cl.scores[i].colors &15)<<4);
1250         else
1251                 if(!strcasecmp(c, "viewentity"))
1252                         dpsnprintf(t, sizeof(t), "%i", i+1);
1253         if(!t[0])
1254                 return;
1255         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
1256 }
1257
1258 //#349 float() isdemo (EXT_CSQC)
1259 static void VM_CL_isdemo (void)
1260 {
1261         VM_SAFEPARMCOUNT(0, VM_CL_isdemo);
1262         PRVM_G_FLOAT(OFS_RETURN) = cls.demoplayback;
1263 }
1264
1265 //#351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
1266 static void VM_CL_setlistener (void)
1267 {
1268         VM_SAFEPARMCOUNT(4, VM_CL_setlistener);
1269         Matrix4x4_FromVectors(&cl.csqc_listenermatrix, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), PRVM_G_VECTOR(OFS_PARM3), PRVM_G_VECTOR(OFS_PARM0));
1270         cl.csqc_usecsqclistener = true; //use csqc listener at this frame
1271 }
1272
1273 //#352 void(string cmdname) registercommand (EXT_CSQC)
1274 static void VM_CL_registercmd (void)
1275 {
1276         char *t;
1277         VM_SAFEPARMCOUNT(1, VM_CL_registercmd);
1278         if(!Cmd_Exists(PRVM_G_STRING(OFS_PARM0)))
1279         {
1280                 size_t alloclen;
1281
1282                 alloclen = strlen(PRVM_G_STRING(OFS_PARM0)) + 1;
1283                 t = (char *)Z_Malloc(alloclen);
1284                 memcpy(t, PRVM_G_STRING(OFS_PARM0), alloclen);
1285                 Cmd_AddCommand(t, NULL, "console command created by QuakeC");
1286         }
1287         else
1288                 Cmd_AddCommand(PRVM_G_STRING(OFS_PARM0), NULL, "console command created by QuakeC");
1289
1290 }
1291
1292 //#360 float() readbyte (EXT_CSQC)
1293 static void VM_CL_ReadByte (void)
1294 {
1295         VM_SAFEPARMCOUNT(0, VM_CL_ReadByte);
1296         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadByte();
1297 }
1298
1299 //#361 float() readchar (EXT_CSQC)
1300 static void VM_CL_ReadChar (void)
1301 {
1302         VM_SAFEPARMCOUNT(0, VM_CL_ReadChar);
1303         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadChar();
1304 }
1305
1306 //#362 float() readshort (EXT_CSQC)
1307 static void VM_CL_ReadShort (void)
1308 {
1309         VM_SAFEPARMCOUNT(0, VM_CL_ReadShort);
1310         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadShort();
1311 }
1312
1313 //#363 float() readlong (EXT_CSQC)
1314 static void VM_CL_ReadLong (void)
1315 {
1316         VM_SAFEPARMCOUNT(0, VM_CL_ReadLong);
1317         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadLong();
1318 }
1319
1320 //#364 float() readcoord (EXT_CSQC)
1321 static void VM_CL_ReadCoord (void)
1322 {
1323         VM_SAFEPARMCOUNT(0, VM_CL_ReadCoord);
1324         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadCoord(cls.protocol);
1325 }
1326
1327 //#365 float() readangle (EXT_CSQC)
1328 static void VM_CL_ReadAngle (void)
1329 {
1330         VM_SAFEPARMCOUNT(0, VM_CL_ReadAngle);
1331         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadAngle(cls.protocol);
1332 }
1333
1334 //#366 string() readstring (EXT_CSQC)
1335 static void VM_CL_ReadString (void)
1336 {
1337         VM_SAFEPARMCOUNT(0, VM_CL_ReadString);
1338         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(MSG_ReadString());
1339 }
1340
1341 //#367 float() readfloat (EXT_CSQC)
1342 static void VM_CL_ReadFloat (void)
1343 {
1344         VM_SAFEPARMCOUNT(0, VM_CL_ReadFloat);
1345         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadFloat();
1346 }
1347
1348 //#501 string() readpicture (DP_CSQC_READWRITEPICTURE)
1349 extern cvar_t cl_readpicture_force;
1350 static void VM_CL_ReadPicture (void)
1351 {
1352         const char *name;
1353         unsigned char *data;
1354         unsigned char *buf;
1355         int size;
1356         int i;
1357         cachepic_t *pic;
1358
1359         VM_SAFEPARMCOUNT(0, VM_CL_ReadPicture);
1360
1361         name = MSG_ReadString();
1362         size = MSG_ReadShort();
1363
1364         // check if a texture of that name exists
1365         // if yes, it is used and the data is discarded
1366         // if not, the (low quality) data is used to build a new texture, whose name will get returned
1367
1368         pic = Draw_CachePic_Flags (name, CACHEPICFLAG_NOTPERSISTENT);
1369
1370         if(size)
1371         {
1372                 if(pic->tex == r_texture_notexture)
1373                         pic->tex = NULL; // don't overwrite the notexture by Draw_NewPic
1374                 if(pic->tex && !cl_readpicture_force.integer)
1375                 {
1376                         // texture found and loaded
1377                         // skip over the jpeg as we don't need it
1378                         for(i = 0; i < size; ++i)
1379                                 MSG_ReadByte();
1380                 }
1381                 else
1382                 {
1383                         // texture not found
1384                         // use the attached jpeg as texture
1385                         buf = (unsigned char *) Mem_Alloc(tempmempool, size);
1386                         MSG_ReadBytes(size, buf);
1387                         data = JPEG_LoadImage_BGRA(buf, size);
1388                         Mem_Free(buf);
1389                         Draw_NewPic(name, image_width, image_height, false, data);
1390                         Mem_Free(data);
1391                 }
1392         }
1393
1394         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(name);
1395 }
1396
1397 //////////////////////////////////////////////////////////
1398
1399 static void VM_CL_makestatic (void)
1400 {
1401         prvm_edict_t *ent;
1402
1403         VM_SAFEPARMCOUNT(1, VM_CL_makestatic);
1404
1405         ent = PRVM_G_EDICT(OFS_PARM0);
1406         if (ent == prog->edicts)
1407         {
1408                 VM_Warning("makestatic: can not modify world entity\n");
1409                 return;
1410         }
1411         if (ent->priv.server->free)
1412         {
1413                 VM_Warning("makestatic: can not modify free entity\n");
1414                 return;
1415         }
1416
1417         if (cl.num_static_entities < cl.max_static_entities)
1418         {
1419                 int renderflags;
1420                 prvm_eval_t *val;
1421                 entity_t *staticent = &cl.static_entities[cl.num_static_entities++];
1422
1423                 // copy it to the current state
1424                 memset(staticent, 0, sizeof(*staticent));
1425                 staticent->render.model = CL_GetModelByIndex((int)ent->fields.client->modelindex);
1426                 staticent->render.framegroupblend[0].frame = (int)ent->fields.client->frame;
1427                 staticent->render.framegroupblend[0].lerp = 1;
1428                 // make torchs play out of sync
1429                 staticent->render.framegroupblend[0].start = lhrandom(-10, -1);
1430                 staticent->render.skinnum = (int)ent->fields.client->skin;
1431                 staticent->render.effects = (int)ent->fields.client->effects;
1432                 staticent->render.alpha = 1;
1433                 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)) && val->_float) staticent->render.alpha = val->_float;
1434                 staticent->render.scale = 1;
1435                 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)) && val->_float) staticent->render.scale = val->_float;
1436                 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod)) && VectorLength2(val->vector)) VectorCopy(val->vector, staticent->render.colormod);
1437
1438                 renderflags = 0;
1439                 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderflags)) && val->_float) renderflags = (int)val->_float;
1440                 if (renderflags & RF_USEAXIS)
1441                 {
1442                         vec3_t left;
1443                         VectorNegate(prog->globals.client->v_right, left);
1444                         Matrix4x4_FromVectors(&staticent->render.matrix, prog->globals.client->v_forward, left, prog->globals.client->v_up, ent->fields.client->origin);
1445                         Matrix4x4_Scale(&staticent->render.matrix, staticent->render.scale, 1);
1446                 }
1447                 else
1448                         Matrix4x4_CreateFromQuakeEntity(&staticent->render.matrix, ent->fields.client->origin[0], ent->fields.client->origin[1], ent->fields.client->origin[2], ent->fields.client->angles[0], ent->fields.client->angles[1], ent->fields.client->angles[2], staticent->render.scale);
1449
1450                 // either fullbright or lit
1451                 if (!(staticent->render.effects & EF_FULLBRIGHT) && !r_fullbright.integer)
1452                         staticent->render.flags |= RENDER_LIGHT;
1453                 // turn off shadows from transparent objects
1454                 if (!(staticent->render.effects & (EF_NOSHADOW | EF_ADDITIVE | EF_NODEPTHTEST)) && (staticent->render.alpha >= 1))
1455                         staticent->render.flags |= RENDER_SHADOW;
1456
1457                 CL_UpdateRenderEntity(&staticent->render);
1458         }
1459         else
1460                 Con_Printf("Too many static entities");
1461
1462 // throw the entity away now
1463         PRVM_ED_Free (ent);
1464 }
1465
1466 //=================================================================//
1467
1468 /*
1469 =================
1470 VM_CL_copyentity
1471
1472 copies data from one entity to another
1473
1474 copyentity(src, dst)
1475 =================
1476 */
1477 static void VM_CL_copyentity (void)
1478 {
1479         prvm_edict_t *in, *out;
1480         VM_SAFEPARMCOUNT(2, VM_CL_copyentity);
1481         in = PRVM_G_EDICT(OFS_PARM0);
1482         if (in == prog->edicts)
1483         {
1484                 VM_Warning("copyentity: can not read world entity\n");
1485                 return;
1486         }
1487         if (in->priv.server->free)
1488         {
1489                 VM_Warning("copyentity: can not read free entity\n");
1490                 return;
1491         }
1492         out = PRVM_G_EDICT(OFS_PARM1);
1493         if (out == prog->edicts)
1494         {
1495                 VM_Warning("copyentity: can not modify world entity\n");
1496                 return;
1497         }
1498         if (out->priv.server->free)
1499         {
1500                 VM_Warning("copyentity: can not modify free entity\n");
1501                 return;
1502         }
1503         memcpy(out->fields.vp, in->fields.vp, prog->progs->entityfields * 4);
1504         CL_LinkEdict(out);
1505 }
1506
1507 //=================================================================//
1508
1509 // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
1510 static void VM_CL_effect (void)
1511 {
1512         VM_SAFEPARMCOUNT(5, VM_CL_effect);
1513         CL_Effect(PRVM_G_VECTOR(OFS_PARM0), (int)PRVM_G_FLOAT(OFS_PARM1), (int)PRVM_G_FLOAT(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), PRVM_G_FLOAT(OFS_PARM4));
1514 }
1515
1516 // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
1517 static void VM_CL_te_blood (void)
1518 {
1519         float   *pos;
1520         vec3_t  pos2;
1521         VM_SAFEPARMCOUNT(3, VM_CL_te_blood);
1522         if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1523                 return;
1524         pos = PRVM_G_VECTOR(OFS_PARM0);
1525         CL_FindNonSolidLocation(pos, pos2, 4);
1526         CL_ParticleEffect(EFFECT_TE_BLOOD, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM1), NULL, 0);
1527 }
1528
1529 // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
1530 static void VM_CL_te_bloodshower (void)
1531 {
1532         vec_t speed;
1533         vec3_t vel1, vel2;
1534         VM_SAFEPARMCOUNT(4, VM_CL_te_bloodshower);
1535         if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1536                 return;
1537         speed = PRVM_G_FLOAT(OFS_PARM2);
1538         vel1[0] = -speed;
1539         vel1[1] = -speed;
1540         vel1[2] = -speed;
1541         vel2[0] = speed;
1542         vel2[1] = speed;
1543         vel2[2] = speed;
1544         CL_ParticleEffect(EFFECT_TE_BLOOD, PRVM_G_FLOAT(OFS_PARM3), PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), vel1, vel2, NULL, 0);
1545 }
1546
1547 // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
1548 static void VM_CL_te_explosionrgb (void)
1549 {
1550         float           *pos;
1551         vec3_t          pos2;
1552         matrix4x4_t     tempmatrix;
1553         VM_SAFEPARMCOUNT(2, VM_CL_te_explosionrgb);
1554         pos = PRVM_G_VECTOR(OFS_PARM0);
1555         CL_FindNonSolidLocation(pos, pos2, 10);
1556         CL_ParticleExplosion(pos2);
1557         Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1558         CL_AllocLightFlash(NULL, &tempmatrix, 350, PRVM_G_VECTOR(OFS_PARM1)[0], PRVM_G_VECTOR(OFS_PARM1)[1], PRVM_G_VECTOR(OFS_PARM1)[2], 700, 0.5, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
1559 }
1560
1561 // #408 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color, float gravityflag, float randomveljitter) te_particlecube (DP_TE_PARTICLECUBE)
1562 static void VM_CL_te_particlecube (void)
1563 {
1564         VM_SAFEPARMCOUNT(7, VM_CL_te_particlecube);
1565         CL_ParticleCube(PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), PRVM_G_FLOAT(OFS_PARM5), PRVM_G_FLOAT(OFS_PARM6));
1566 }
1567
1568 // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
1569 static void VM_CL_te_particlerain (void)
1570 {
1571         VM_SAFEPARMCOUNT(5, VM_CL_te_particlerain);
1572         CL_ParticleRain(PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), 0);
1573 }
1574
1575 // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
1576 static void VM_CL_te_particlesnow (void)
1577 {
1578         VM_SAFEPARMCOUNT(5, VM_CL_te_particlesnow);
1579         CL_ParticleRain(PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), 1);
1580 }
1581
1582 // #411 void(vector org, vector vel, float howmany) te_spark
1583 static void VM_CL_te_spark (void)
1584 {
1585         float           *pos;
1586         vec3_t          pos2;
1587         VM_SAFEPARMCOUNT(3, VM_CL_te_spark);
1588
1589         pos = PRVM_G_VECTOR(OFS_PARM0);
1590         CL_FindNonSolidLocation(pos, pos2, 4);
1591         CL_ParticleEffect(EFFECT_TE_SPARK, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM1), NULL, 0);
1592 }
1593
1594 extern cvar_t cl_sound_ric_gunshot;
1595 // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
1596 static void VM_CL_te_gunshotquad (void)
1597 {
1598         float           *pos;
1599         vec3_t          pos2;
1600         int                     rnd;
1601         VM_SAFEPARMCOUNT(1, VM_CL_te_gunshotquad);
1602
1603         pos = PRVM_G_VECTOR(OFS_PARM0);
1604         CL_FindNonSolidLocation(pos, pos2, 4);
1605         CL_ParticleEffect(EFFECT_TE_GUNSHOTQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1606         if(cl_sound_ric_gunshot.integer >= 2)
1607         {
1608                 if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1609                 else
1610                 {
1611                         rnd = rand() & 3;
1612                         if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1613                         else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1614                         else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1615                 }
1616         }
1617 }
1618
1619 // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
1620 static void VM_CL_te_spikequad (void)
1621 {
1622         float           *pos;
1623         vec3_t          pos2;
1624         int                     rnd;
1625         VM_SAFEPARMCOUNT(1, VM_CL_te_spikequad);
1626
1627         pos = PRVM_G_VECTOR(OFS_PARM0);
1628         CL_FindNonSolidLocation(pos, pos2, 4);
1629         CL_ParticleEffect(EFFECT_TE_SPIKEQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1630         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1631         else
1632         {
1633                 rnd = rand() & 3;
1634                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1635                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1636                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1637         }
1638 }
1639
1640 // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
1641 static void VM_CL_te_superspikequad (void)
1642 {
1643         float           *pos;
1644         vec3_t          pos2;
1645         int                     rnd;
1646         VM_SAFEPARMCOUNT(1, VM_CL_te_superspikequad);
1647
1648         pos = PRVM_G_VECTOR(OFS_PARM0);
1649         CL_FindNonSolidLocation(pos, pos2, 4);
1650         CL_ParticleEffect(EFFECT_TE_SUPERSPIKEQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1651         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos, 1, 1);
1652         else
1653         {
1654                 rnd = rand() & 3;
1655                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1656                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1657                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1658         }
1659 }
1660
1661 // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
1662 static void VM_CL_te_explosionquad (void)
1663 {
1664         float           *pos;
1665         vec3_t          pos2;
1666         VM_SAFEPARMCOUNT(1, VM_CL_te_explosionquad);
1667
1668         pos = PRVM_G_VECTOR(OFS_PARM0);
1669         CL_FindNonSolidLocation(pos, pos2, 10);
1670         CL_ParticleEffect(EFFECT_TE_EXPLOSIONQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1671         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1672 }
1673
1674 // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
1675 static void VM_CL_te_smallflash (void)
1676 {
1677         float           *pos;
1678         vec3_t          pos2;
1679         VM_SAFEPARMCOUNT(1, VM_CL_te_smallflash);
1680
1681         pos = PRVM_G_VECTOR(OFS_PARM0);
1682         CL_FindNonSolidLocation(pos, pos2, 10);
1683         CL_ParticleEffect(EFFECT_TE_SMALLFLASH, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1684 }
1685
1686 // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
1687 static void VM_CL_te_customflash (void)
1688 {
1689         float           *pos;
1690         vec3_t          pos2;
1691         matrix4x4_t     tempmatrix;
1692         VM_SAFEPARMCOUNT(4, VM_CL_te_customflash);
1693
1694         pos = PRVM_G_VECTOR(OFS_PARM0);
1695         CL_FindNonSolidLocation(pos, pos2, 4);
1696         Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1697         CL_AllocLightFlash(NULL, &tempmatrix, PRVM_G_FLOAT(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM3)[0], PRVM_G_VECTOR(OFS_PARM3)[1], PRVM_G_VECTOR(OFS_PARM3)[2], PRVM_G_FLOAT(OFS_PARM1) / PRVM_G_FLOAT(OFS_PARM2), PRVM_G_FLOAT(OFS_PARM2), 0, -1, true, 1, 0.25, 1, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
1698 }
1699
1700 // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
1701 static void VM_CL_te_gunshot (void)
1702 {
1703         float           *pos;
1704         vec3_t          pos2;
1705         int                     rnd;
1706         VM_SAFEPARMCOUNT(1, VM_CL_te_gunshot);
1707
1708         pos = PRVM_G_VECTOR(OFS_PARM0);
1709         CL_FindNonSolidLocation(pos, pos2, 4);
1710         CL_ParticleEffect(EFFECT_TE_GUNSHOT, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1711         if(cl_sound_ric_gunshot.integer == 1 || cl_sound_ric_gunshot.integer == 3)
1712         {
1713                 if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1714                 else
1715                 {
1716                         rnd = rand() & 3;
1717                         if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1718                         else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1719                         else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1720                 }
1721         }
1722 }
1723
1724 // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
1725 static void VM_CL_te_spike (void)
1726 {
1727         float           *pos;
1728         vec3_t          pos2;
1729         int                     rnd;
1730         VM_SAFEPARMCOUNT(1, VM_CL_te_spike);
1731
1732         pos = PRVM_G_VECTOR(OFS_PARM0);
1733         CL_FindNonSolidLocation(pos, pos2, 4);
1734         CL_ParticleEffect(EFFECT_TE_SPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1735         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1736         else
1737         {
1738                 rnd = rand() & 3;
1739                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1740                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1741                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1742         }
1743 }
1744
1745 // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
1746 static void VM_CL_te_superspike (void)
1747 {
1748         float           *pos;
1749         vec3_t          pos2;
1750         int                     rnd;
1751         VM_SAFEPARMCOUNT(1, VM_CL_te_superspike);
1752
1753         pos = PRVM_G_VECTOR(OFS_PARM0);
1754         CL_FindNonSolidLocation(pos, pos2, 4);
1755         CL_ParticleEffect(EFFECT_TE_SUPERSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1756         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1757         else
1758         {
1759                 rnd = rand() & 3;
1760                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1761                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1762                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1763         }
1764 }
1765
1766 // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
1767 static void VM_CL_te_explosion (void)
1768 {
1769         float           *pos;
1770         vec3_t          pos2;
1771         VM_SAFEPARMCOUNT(1, VM_CL_te_explosion);
1772
1773         pos = PRVM_G_VECTOR(OFS_PARM0);
1774         CL_FindNonSolidLocation(pos, pos2, 10);
1775         CL_ParticleEffect(EFFECT_TE_EXPLOSION, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1776         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1777 }
1778
1779 // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
1780 static void VM_CL_te_tarexplosion (void)
1781 {
1782         float           *pos;
1783         vec3_t          pos2;
1784         VM_SAFEPARMCOUNT(1, VM_CL_te_tarexplosion);
1785
1786         pos = PRVM_G_VECTOR(OFS_PARM0);
1787         CL_FindNonSolidLocation(pos, pos2, 10);
1788         CL_ParticleEffect(EFFECT_TE_TAREXPLOSION, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1789         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1790 }
1791
1792 // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
1793 static void VM_CL_te_wizspike (void)
1794 {
1795         float           *pos;
1796         vec3_t          pos2;
1797         VM_SAFEPARMCOUNT(1, VM_CL_te_wizspike);
1798
1799         pos = PRVM_G_VECTOR(OFS_PARM0);
1800         CL_FindNonSolidLocation(pos, pos2, 4);
1801         CL_ParticleEffect(EFFECT_TE_WIZSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1802         S_StartSound(-1, 0, cl.sfx_wizhit, pos2, 1, 1);
1803 }
1804
1805 // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
1806 static void VM_CL_te_knightspike (void)
1807 {
1808         float           *pos;
1809         vec3_t          pos2;
1810         VM_SAFEPARMCOUNT(1, VM_CL_te_knightspike);
1811
1812         pos = PRVM_G_VECTOR(OFS_PARM0);
1813         CL_FindNonSolidLocation(pos, pos2, 4);
1814         CL_ParticleEffect(EFFECT_TE_KNIGHTSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1815         S_StartSound(-1, 0, cl.sfx_knighthit, pos2, 1, 1);
1816 }
1817
1818 // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
1819 static void VM_CL_te_lavasplash (void)
1820 {
1821         VM_SAFEPARMCOUNT(1, VM_CL_te_lavasplash);
1822         CL_ParticleEffect(EFFECT_TE_LAVASPLASH, 1, PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM0), vec3_origin, vec3_origin, NULL, 0);
1823 }
1824
1825 // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
1826 static void VM_CL_te_teleport (void)
1827 {
1828         VM_SAFEPARMCOUNT(1, VM_CL_te_teleport);
1829         CL_ParticleEffect(EFFECT_TE_TELEPORT, 1, PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM0), vec3_origin, vec3_origin, NULL, 0);
1830 }
1831
1832 // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
1833 static void VM_CL_te_explosion2 (void)
1834 {
1835         float           *pos;
1836         vec3_t          pos2, color;
1837         matrix4x4_t     tempmatrix;
1838         int                     colorStart, colorLength;
1839         unsigned char           *tempcolor;
1840         VM_SAFEPARMCOUNT(3, VM_CL_te_explosion2);
1841
1842         pos = PRVM_G_VECTOR(OFS_PARM0);
1843         colorStart = (int)PRVM_G_FLOAT(OFS_PARM1);
1844         colorLength = (int)PRVM_G_FLOAT(OFS_PARM2);
1845         CL_FindNonSolidLocation(pos, pos2, 10);
1846         CL_ParticleExplosion2(pos2, colorStart, colorLength);
1847         tempcolor = palette_rgb[(rand()%colorLength) + colorStart];
1848         color[0] = tempcolor[0] * (2.0f / 255.0f);
1849         color[1] = tempcolor[1] * (2.0f / 255.0f);
1850         color[2] = tempcolor[2] * (2.0f / 255.0f);
1851         Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1852         CL_AllocLightFlash(NULL, &tempmatrix, 350, color[0], color[1], color[2], 700, 0.5, 0, -1, true, 1, 0.25, 0.25, 1, 1, LIGHTFLAG_NORMALMODE | LIGHTFLAG_REALTIMEMODE);
1853         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1854 }
1855
1856
1857 // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
1858 static void VM_CL_te_lightning1 (void)
1859 {
1860         VM_SAFEPARMCOUNT(3, VM_CL_te_lightning1);
1861         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt, true);
1862 }
1863
1864 // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
1865 static void VM_CL_te_lightning2 (void)
1866 {
1867         VM_SAFEPARMCOUNT(3, VM_CL_te_lightning2);
1868         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt2, true);
1869 }
1870
1871 // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
1872 static void VM_CL_te_lightning3 (void)
1873 {
1874         VM_SAFEPARMCOUNT(3, VM_CL_te_lightning3);
1875         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt3, false);
1876 }
1877
1878 // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
1879 static void VM_CL_te_beam (void)
1880 {
1881         VM_SAFEPARMCOUNT(3, VM_CL_te_beam);
1882         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_beam, false);
1883 }
1884
1885 // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
1886 static void VM_CL_te_plasmaburn (void)
1887 {
1888         float           *pos;
1889         vec3_t          pos2;
1890         VM_SAFEPARMCOUNT(1, VM_CL_te_plasmaburn);
1891
1892         pos = PRVM_G_VECTOR(OFS_PARM0);
1893         CL_FindNonSolidLocation(pos, pos2, 4);
1894         CL_ParticleEffect(EFFECT_TE_PLASMABURN, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1895 }
1896
1897 // #457 void(vector org, vector velocity, float howmany) te_flamejet (DP_TE_FLAMEJET)
1898 static void VM_CL_te_flamejet (void)
1899 {
1900         float *pos;
1901         vec3_t pos2;
1902         VM_SAFEPARMCOUNT(3, VM_CL_te_flamejet);
1903         if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1904                 return;
1905         pos = PRVM_G_VECTOR(OFS_PARM0);
1906         CL_FindNonSolidLocation(pos, pos2, 4);
1907         CL_ParticleEffect(EFFECT_TE_FLAMEJET, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM1), NULL, 0);
1908 }
1909
1910
1911 //====================================================================
1912 //DP_QC_GETSURFACE
1913
1914 extern void clippointtosurface(dp_model_t *model, msurface_t *surface, vec3_t p, vec3_t out);
1915
1916 static msurface_t *cl_getsurface(dp_model_t *model, int surfacenum)
1917 {
1918         if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
1919                 return NULL;
1920         return model->data_surfaces + surfacenum + model->firstmodelsurface;
1921 }
1922
1923 // #434 float(entity e, float s) getsurfacenumpoints
1924 static void VM_CL_getsurfacenumpoints(void)
1925 {
1926         dp_model_t *model;
1927         msurface_t *surface;
1928         VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenumpoints);
1929         // return 0 if no such surface
1930         if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1931         {
1932                 PRVM_G_FLOAT(OFS_RETURN) = 0;
1933                 return;
1934         }
1935
1936         // note: this (incorrectly) assumes it is a simple polygon
1937         PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
1938 }
1939
1940 // #435 vector(entity e, float s, float n) getsurfacepoint
1941 static void VM_CL_getsurfacepoint(void)
1942 {
1943         prvm_edict_t *ed;
1944         dp_model_t *model;
1945         msurface_t *surface;
1946         int pointnum;
1947         VM_SAFEPARMCOUNT(3, VM_CL_getsurfacenumpoints);
1948         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
1949         ed = PRVM_G_EDICT(OFS_PARM0);
1950         if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1951                 return;
1952         // note: this (incorrectly) assumes it is a simple polygon
1953         pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
1954         if (pointnum < 0 || pointnum >= surface->num_vertices)
1955                 return;
1956         // FIXME: implement rotation/scaling
1957         VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
1958 }
1959 //PF_getsurfacepointattribute,     // #486 vector(entity e, float s, float n, float a) getsurfacepointattribute = #486;
1960 // float SPA_POSITION = 0;
1961 // float SPA_S_AXIS = 1;
1962 // float SPA_T_AXIS = 2;
1963 // float SPA_R_AXIS = 3; // same as SPA_NORMAL
1964 // float SPA_TEXCOORDS0 = 4;
1965 // float SPA_LIGHTMAP0_TEXCOORDS = 5;
1966 // float SPA_LIGHTMAP0_COLOR = 6;
1967 // TODO: add some wrapper code and merge VM_CL/SV_getsurface* [12/16/2007 Black]
1968 static void VM_CL_getsurfacepointattribute(void)
1969 {
1970         prvm_edict_t *ed;
1971         dp_model_t *model;
1972         msurface_t *surface;
1973         int pointnum;
1974         int attributetype;
1975
1976         VM_SAFEPARMCOUNT(4, VM_CL_getsurfacenumpoints);
1977         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
1978         ed = PRVM_G_EDICT(OFS_PARM0);
1979         if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1980                 return;
1981         // note: this (incorrectly) assumes it is a simple polygon
1982         pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
1983         if (pointnum < 0 || pointnum >= surface->num_vertices)
1984                 return;
1985
1986         // FIXME: implement rotation/scaling
1987         attributetype = (int) PRVM_G_FLOAT(OFS_PARM3);
1988
1989         switch( attributetype ) {
1990                 // float SPA_POSITION = 0;
1991                 case 0:
1992                         VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
1993                         break;
1994                 // float SPA_S_AXIS = 1;
1995                 case 1:
1996                         VectorCopy(&(model->surfmesh.data_svector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
1997                         break;
1998                 // float SPA_T_AXIS = 2;
1999                 case 2:
2000                         VectorCopy(&(model->surfmesh.data_tvector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
2001                         break;
2002                 // float SPA_R_AXIS = 3; // same as SPA_NORMAL
2003                 case 3:
2004                         VectorCopy(&(model->surfmesh.data_normal3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
2005                         break;
2006                 // float SPA_TEXCOORDS0 = 4;
2007                 case 4: {
2008                         float *ret = PRVM_G_VECTOR(OFS_RETURN);
2009                         float *texcoord = &(model->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[pointnum * 2];
2010                         ret[0] = texcoord[0];
2011                         ret[1] = texcoord[1];
2012                         ret[2] = 0.0f;
2013                         break;
2014                 }
2015                 // float SPA_LIGHTMAP0_TEXCOORDS = 5;
2016                 case 5: {
2017                         float *ret = PRVM_G_VECTOR(OFS_RETURN);
2018                         float *texcoord = &(model->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[pointnum * 2];
2019                         ret[0] = texcoord[0];
2020                         ret[1] = texcoord[1];
2021                         ret[2] = 0.0f;
2022                         break;
2023                 }
2024                 // float SPA_LIGHTMAP0_COLOR = 6;
2025                 case 6:
2026                         // ignore alpha for now..
2027                         VectorCopy( &(model->surfmesh.data_lightmapcolor4f + 4 * surface->num_firstvertex)[pointnum * 4], PRVM_G_VECTOR(OFS_RETURN));
2028                         break;
2029                 default:
2030                         VectorSet( PRVM_G_VECTOR(OFS_RETURN), 0.0f, 0.0f, 0.0f );
2031                         break;
2032         }
2033 }
2034 // #436 vector(entity e, float s) getsurfacenormal
2035 static void VM_CL_getsurfacenormal(void)
2036 {
2037         dp_model_t *model;
2038         msurface_t *surface;
2039         vec3_t normal;
2040         VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenormal);
2041         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2042         if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2043                 return;
2044         // FIXME: implement rotation/scaling
2045         // note: this (incorrectly) assumes it is a simple polygon
2046         // note: this only returns the first triangle, so it doesn't work very
2047         // well for curved surfaces or arbitrary meshes
2048         TriangleNormal((model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex), (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 3, (model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex) + 6, normal);
2049         VectorNormalize(normal);
2050         VectorCopy(normal, PRVM_G_VECTOR(OFS_RETURN));
2051 }
2052
2053 // #437 string(entity e, float s) getsurfacetexture
2054 static void VM_CL_getsurfacetexture(void)
2055 {
2056         dp_model_t *model;
2057         msurface_t *surface;
2058         VM_SAFEPARMCOUNT(2, VM_CL_getsurfacetexture);
2059         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2060         if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2061                 return;
2062         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(surface->texture->name);
2063 }
2064
2065 // #438 float(entity e, vector p) getsurfacenearpoint
2066 static void VM_CL_getsurfacenearpoint(void)
2067 {
2068         int surfacenum, best;
2069         vec3_t clipped, p;
2070         vec_t dist, bestdist;
2071         prvm_edict_t *ed;
2072         dp_model_t *model = NULL;
2073         msurface_t *surface;
2074         vec_t *point;
2075         VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenearpoint);
2076         PRVM_G_FLOAT(OFS_RETURN) = -1;
2077         ed = PRVM_G_EDICT(OFS_PARM0);
2078         if(!(model = CL_GetModelFromEdict(ed)) || !model->num_surfaces)
2079                 return;
2080
2081         // FIXME: implement rotation/scaling
2082         point = PRVM_G_VECTOR(OFS_PARM1);
2083         VectorSubtract(point, ed->fields.client->origin, p);
2084         best = -1;
2085         bestdist = 1000000000;
2086         for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++)
2087         {
2088                 surface = model->data_surfaces + surfacenum + model->firstmodelsurface;
2089                 // first see if the nearest point on the surface's box is closer than the previous match
2090                 clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0];
2091                 clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1];
2092                 clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2];
2093                 dist = VectorLength2(clipped);
2094                 if (dist < bestdist)
2095                 {
2096                         // it is, check the nearest point on the actual geometry
2097                         clippointtosurface(model, surface, p, clipped);
2098                         VectorSubtract(clipped, p, clipped);
2099                         dist += VectorLength2(clipped);
2100                         if (dist < bestdist)
2101                         {
2102                                 // that's closer too, store it as the best match
2103                                 best = surfacenum;
2104                                 bestdist = dist;
2105                         }
2106                 }
2107         }
2108         PRVM_G_FLOAT(OFS_RETURN) = best;
2109 }
2110
2111 // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint
2112 static void VM_CL_getsurfaceclippedpoint(void)
2113 {
2114         prvm_edict_t *ed;
2115         dp_model_t *model;
2116         msurface_t *surface;
2117         vec3_t p, out;
2118         VM_SAFEPARMCOUNT(3, VM_CL_getsurfaceclippedpoint);
2119         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2120         ed = PRVM_G_EDICT(OFS_PARM0);
2121         if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2122                 return;
2123         // FIXME: implement rotation/scaling
2124         VectorSubtract(PRVM_G_VECTOR(OFS_PARM2), ed->fields.client->origin, p);
2125         clippointtosurface(model, surface, p, out);
2126         // FIXME: implement rotation/scaling
2127         VectorAdd(out, ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
2128 }
2129
2130 // #443 void(entity e, entity tagentity, string tagname) setattachment
2131 void VM_CL_setattachment (void)
2132 {
2133         prvm_edict_t *e;
2134         prvm_edict_t *tagentity;
2135         const char *tagname;
2136         prvm_eval_t *v;
2137         int modelindex;
2138         dp_model_t *model;
2139         VM_SAFEPARMCOUNT(3, VM_CL_setattachment);
2140
2141         e = PRVM_G_EDICT(OFS_PARM0);
2142         tagentity = PRVM_G_EDICT(OFS_PARM1);
2143         tagname = PRVM_G_STRING(OFS_PARM2);
2144
2145         if (e == prog->edicts)
2146         {
2147                 VM_Warning("setattachment: can not modify world entity\n");
2148                 return;
2149         }
2150         if (e->priv.server->free)
2151         {
2152                 VM_Warning("setattachment: can not modify free entity\n");
2153                 return;
2154         }
2155
2156         if (tagentity == NULL)
2157                 tagentity = prog->edicts;
2158
2159         v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_entity);
2160         if (v)
2161                 v->edict = PRVM_EDICT_TO_PROG(tagentity);
2162
2163         v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_index);
2164         if (v)
2165                 v->_float = 0;
2166         if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
2167         {
2168                 modelindex = (int)tagentity->fields.client->modelindex;
2169                 model = CL_GetModelByIndex(modelindex);
2170                 if (model)
2171                 {
2172                         v->_float = Mod_Alias_GetTagIndexForName(model, (int)tagentity->fields.client->skin, tagname);
2173                         if (v->_float == 0)
2174                                 Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i (model \"%s\") but could not find it\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity), model->name);
2175                 }
2176                 else
2177                         Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", PRVM_NUM_FOR_EDICT(e), PRVM_NUM_FOR_EDICT(tagentity), tagname, tagname, PRVM_NUM_FOR_EDICT(tagentity));
2178         }
2179 }
2180
2181 /////////////////////////////////////////
2182 // DP_MD3_TAGINFO extension coded by VorteX
2183
2184 int CL_GetTagIndex (prvm_edict_t *e, const char *tagname)
2185 {
2186         dp_model_t *model = CL_GetModelFromEdict(e);
2187         if (model)
2188                 return Mod_Alias_GetTagIndexForName(model, (int)e->fields.client->skin, tagname);
2189         else
2190                 return -1;
2191 }
2192
2193 int CL_GetExtendedTagInfo (prvm_edict_t *e, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)
2194 {
2195         int r;
2196         dp_model_t *model;
2197         int frame;
2198
2199         *tagname = NULL;
2200         *parentindex = 0;
2201         Matrix4x4_CreateIdentity(tag_localmatrix);
2202
2203         if (tagindex >= 0
2204          && (model = CL_GetModelFromEdict(e))
2205          && model->animscenes)
2206         {
2207                 frame = (int)e->fields.client->frame;
2208                 if (frame < 0 || frame >= model->numframes)
2209                         frame = 0;
2210
2211                 r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)e->fields.client->skin, model->animscenes[frame].firstframe, tagindex - 1, parentindex, tagname, tag_localmatrix);
2212
2213                 if(!r) // success?
2214                         *parentindex += 1;
2215
2216                 return r;
2217         }
2218
2219         return 1;
2220 }
2221
2222 void CL_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
2223 {
2224         prvm_eval_t *val;
2225         float scale;
2226         float pitchsign = 1;
2227         dp_model_t *model;
2228
2229         scale = 1;
2230         val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale);
2231         if (val && val->_float != 0)
2232                 scale = val->_float;
2233
2234         // TODO do we need the same weird angle inverting logic here as in the server side case?
2235         if(viewmatrix)
2236                 Matrix4x4_CreateFromQuakeEntity(out, cl.csqc_origin[0], cl.csqc_origin[1], cl.csqc_origin[2], cl.csqc_angles[0], cl.csqc_angles[1], cl.csqc_angles[2], scale * cl_viewmodel_scale.value);
2237         else
2238         {
2239                 if ((model = CL_GetModelFromEdict(ent)) && model->type == mod_alias)
2240                         pitchsign = -1;
2241                 Matrix4x4_CreateFromQuakeEntity(out, ent->fields.client->origin[0], ent->fields.client->origin[1], ent->fields.client->origin[2], pitchsign * ent->fields.client->angles[0], ent->fields.client->angles[1], ent->fields.client->angles[2], scale);
2242         }
2243 }
2244
2245
2246 int CL_GetEntityLocalTagMatrix(prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
2247 {
2248         int frame;
2249         dp_model_t *model;
2250         if (tagindex >= 0
2251          && (model = CL_GetModelFromEdict(ent))
2252          && model->animscenes)
2253         {
2254                 // if model has wrong frame, engine automatically switches to model first frame
2255                 frame = (int)ent->fields.client->frame;
2256                 if (frame < 0 || frame >= model->numframes)
2257                         frame = 0;
2258                 return Mod_Alias_GetTagMatrix(model, model->animscenes[frame].firstframe, tagindex, out);
2259         }
2260         *out = identitymatrix;
2261         return 0;
2262 }
2263
2264 // Warnings/errors code:
2265 // 0 - normal (everything all-right)
2266 // 1 - world entity
2267 // 2 - free entity
2268 // 3 - null or non-precached model
2269 // 4 - no tags with requested index
2270 // 5 - runaway loop at attachment chain
2271 extern cvar_t cl_bob;
2272 extern cvar_t cl_bobcycle;
2273 extern cvar_t cl_bobup;
2274 int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
2275 {
2276         int ret;
2277         prvm_eval_t *val;
2278         int attachloop;
2279         matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
2280         dp_model_t *model;
2281
2282         *out = identitymatrix; // warnings and errors return identical matrix
2283
2284         if (ent == prog->edicts)
2285                 return 1;
2286         if (ent->priv.server->free)
2287                 return 2;
2288
2289         model = CL_GetModelFromEdict(ent);
2290         if(!model)
2291                 return 3;
2292
2293         tagmatrix = identitymatrix;
2294         attachloop = 0;
2295         for(;;)
2296         {
2297                 if(attachloop >= 256)
2298                         return 5;
2299                 // apply transformation by child's tagindex on parent entity and then
2300                 // by parent entity itself
2301                 ret = CL_GetEntityLocalTagMatrix(ent, tagindex - 1, &attachmatrix);
2302                 if(ret && attachloop == 0)
2303                         return ret;
2304                 CL_GetEntityMatrix(ent, &entitymatrix, false);
2305                 Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
2306                 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2307                 // next iteration we process the parent entity
2308                 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)) && val->edict)
2309                 {
2310                         tagindex = (int)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
2311                         ent = PRVM_EDICT_NUM(val->edict);
2312                 }
2313                 else
2314                         break;
2315                 attachloop++;
2316         }
2317
2318         // RENDER_VIEWMODEL magic
2319         if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderflags)) && (RF_VIEWMODEL & (int)val->_float))
2320         {
2321                 Matrix4x4_Copy(&tagmatrix, out);
2322
2323                 CL_GetEntityMatrix(prog->edicts, &entitymatrix, true);
2324                 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2325
2326                 /*
2327                 // Cl_bob, ported from rendering code
2328                 if (ent->fields.client->health > 0 && cl_bob.value && cl_bobcycle.value)
2329                 {
2330                         double bob, cycle;
2331                         // LordHavoc: this code is *weird*, but not replacable (I think it
2332                         // should be done in QC on the server, but oh well, quake is quake)
2333                         // LordHavoc: figured out bobup: the time at which the sin is at 180
2334                         // degrees (which allows lengthening or squishing the peak or valley)
2335                         cycle = cl.time/cl_bobcycle.value;
2336                         cycle -= (int)cycle;
2337                         if (cycle < cl_bobup.value)
2338                                 cycle = sin(M_PI * cycle / cl_bobup.value);
2339                         else
2340                                 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
2341                         // bob is proportional to velocity in the xy plane
2342                         // (don't count Z, or jumping messes it up)
2343                         bob = sqrt(ent->fields.client->velocity[0]*ent->fields.client->velocity[0] + ent->fields.client->velocity[1]*ent->fields.client->velocity[1])*cl_bob.value;
2344                         bob = bob*0.3 + bob*0.7*cycle;
2345                         Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
2346                 }
2347                 */
2348         }
2349         return 0;
2350 }
2351
2352 // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
2353 void VM_CL_gettagindex (void)
2354 {
2355         prvm_edict_t *ent;
2356         const char *tag_name;
2357         int modelindex, tag_index;
2358
2359         VM_SAFEPARMCOUNT(2, VM_CL_gettagindex);
2360
2361         ent = PRVM_G_EDICT(OFS_PARM0);
2362         tag_name = PRVM_G_STRING(OFS_PARM1);
2363         if (ent == prog->edicts)
2364         {
2365                 VM_Warning("gettagindex: can't affect world entity\n");
2366                 return;
2367         }
2368         if (ent->priv.server->free)
2369         {
2370                 VM_Warning("gettagindex: can't affect free entity\n");
2371                 return;
2372         }
2373
2374         modelindex = (int)ent->fields.client->modelindex;
2375         tag_index = 0;
2376         if (modelindex >= MAX_MODELS || (modelindex <= -MAX_MODELS /* client models */))
2377                 Con_DPrintf("gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
2378         else
2379         {
2380                 tag_index = CL_GetTagIndex(ent, tag_name);
2381                 if (tag_index == 0)
2382                         Con_DPrintf("gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
2383         }
2384         PRVM_G_FLOAT(OFS_RETURN) = tag_index;
2385 }
2386
2387 // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
2388 void VM_CL_gettaginfo (void)
2389 {
2390         prvm_edict_t *e;
2391         int tagindex;
2392         matrix4x4_t tag_matrix;
2393         matrix4x4_t tag_localmatrix;
2394         int parentindex;
2395         const char *tagname;
2396         int returncode;
2397         prvm_eval_t *val;
2398         vec3_t fo, le, up, trans;
2399
2400         VM_SAFEPARMCOUNT(2, VM_CL_gettaginfo);
2401
2402         e = PRVM_G_EDICT(OFS_PARM0);
2403         tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
2404         returncode = CL_GetTagMatrix(&tag_matrix, e, tagindex);
2405         Matrix4x4_ToVectors(&tag_matrix, prog->globals.client->v_forward, le, prog->globals.client->v_up, PRVM_G_VECTOR(OFS_RETURN));
2406         VectorScale(le, -1, prog->globals.client->v_right);
2407         CL_GetExtendedTagInfo(e, tagindex, &parentindex, &tagname, &tag_localmatrix);
2408         Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
2409
2410         if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_parent)))
2411                 val->_float = parentindex;
2412         if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_name)))
2413                 val->string = tagname ? PRVM_SetTempString(tagname) : 0;
2414         if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_offset)))
2415                 VectorCopy(trans, val->vector);
2416         if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_forward)))
2417                 VectorCopy(fo, val->vector);
2418         if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_right)))
2419                 VectorScale(le, -1, val->vector);
2420         if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_up)))
2421                 VectorCopy(up, val->vector);
2422
2423         switch(returncode)
2424         {
2425                 case 1:
2426                         VM_Warning("gettagindex: can't affect world entity\n");
2427                         break;
2428                 case 2:
2429                         VM_Warning("gettagindex: can't affect free entity\n");
2430                         break;
2431                 case 3:
2432                         Con_DPrintf("CL_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
2433                         break;
2434                 case 4:
2435                         Con_DPrintf("CL_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", PRVM_NUM_FOR_EDICT(e), tagindex);
2436                         break;
2437                 case 5:
2438                         Con_DPrintf("CL_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", PRVM_NUM_FOR_EDICT(e));
2439                         break;
2440         }
2441 }
2442
2443 //============================================================================
2444
2445 //====================
2446 //QC POLYGON functions
2447 //====================
2448
2449 #define VMPOLYGONS_MAXPOINTS 64
2450
2451 typedef struct vmpolygons_triangle_s
2452 {
2453         rtexture_t              *texture;
2454         int                             drawflag;
2455         unsigned short  elements[3];
2456 }vmpolygons_triangle_t;
2457
2458 typedef struct vmpolygons_s
2459 {
2460         mempool_t               *pool;
2461         qboolean                initialized;
2462         double          progstarttime;
2463
2464         int                             max_vertices;
2465         int                             num_vertices;
2466         float                   *data_vertex3f;
2467         float                   *data_color4f;
2468         float                   *data_texcoord2f;
2469
2470         int                             max_triangles;
2471         int                             num_triangles;
2472         vmpolygons_triangle_t *data_triangles;
2473         unsigned short  *data_sortedelement3s;
2474
2475         qboolean                begin_active;
2476         rtexture_t              *begin_texture;
2477         int                             begin_drawflag;
2478         int                             begin_vertices;
2479         float                   begin_vertex[VMPOLYGONS_MAXPOINTS][3];
2480         float                   begin_color[VMPOLYGONS_MAXPOINTS][4];
2481         float                   begin_texcoord[VMPOLYGONS_MAXPOINTS][2];
2482 } vmpolygons_t;
2483
2484 // FIXME: make VM_CL_R_Polygon functions use Debug_Polygon functions?
2485 vmpolygons_t vmpolygons[PRVM_MAXPROGS];
2486
2487 //#304 void() renderscene (EXT_CSQC)
2488 // moved that here to reset the polygons,
2489 // resetting them earlier causes R_Mesh_Draw to be called with numvertices = 0
2490 // --blub
2491 void VM_CL_R_RenderScene (void)
2492 {
2493         vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
2494         VM_SAFEPARMCOUNT(0, VM_CL_R_RenderScene);
2495         // we need to update any RENDER_VIEWMODEL entities at this point because
2496         // csqc supplies its own view matrix
2497         CL_UpdateViewEntities();
2498         // now draw stuff!
2499         R_RenderView();
2500
2501         polys->num_vertices = polys->num_triangles = 0;
2502         polys->progstarttime = prog->starttime;
2503 }
2504
2505 static void VM_ResizePolygons(vmpolygons_t *polys)
2506 {
2507         float *oldvertex3f = polys->data_vertex3f;
2508         float *oldcolor4f = polys->data_color4f;
2509         float *oldtexcoord2f = polys->data_texcoord2f;
2510         vmpolygons_triangle_t *oldtriangles = polys->data_triangles;
2511         unsigned short *oldsortedelement3s = polys->data_sortedelement3s;
2512         polys->max_vertices = min(polys->max_triangles*3, 65536);
2513         polys->data_vertex3f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[3]));
2514         polys->data_color4f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[4]));
2515         polys->data_texcoord2f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[2]));
2516         polys->data_triangles = (vmpolygons_triangle_t *)Mem_Alloc(polys->pool, polys->max_triangles*sizeof(vmpolygons_triangle_t));
2517         polys->data_sortedelement3s = (unsigned short *)Mem_Alloc(polys->pool, polys->max_triangles*sizeof(unsigned short[3]));
2518         if (polys->num_vertices)
2519         {
2520                 memcpy(polys->data_vertex3f, oldvertex3f, polys->num_vertices*sizeof(float[3]));
2521                 memcpy(polys->data_color4f, oldcolor4f, polys->num_vertices*sizeof(float[4]));
2522                 memcpy(polys->data_texcoord2f, oldtexcoord2f, polys->num_vertices*sizeof(float[2]));
2523         }
2524         if (polys->num_triangles)
2525         {
2526                 memcpy(polys->data_triangles, oldtriangles, polys->num_triangles*sizeof(vmpolygons_triangle_t));
2527                 memcpy(polys->data_sortedelement3s, oldsortedelement3s, polys->num_triangles*sizeof(unsigned short[3]));
2528         }
2529         if (oldvertex3f)
2530                 Mem_Free(oldvertex3f);
2531         if (oldcolor4f)
2532                 Mem_Free(oldcolor4f);
2533         if (oldtexcoord2f)
2534                 Mem_Free(oldtexcoord2f);
2535         if (oldtriangles)
2536                 Mem_Free(oldtriangles);
2537         if (oldsortedelement3s)
2538                 Mem_Free(oldsortedelement3s);
2539 }
2540
2541 static void VM_InitPolygons (vmpolygons_t* polys)
2542 {
2543         memset(polys, 0, sizeof(*polys));
2544         polys->pool = Mem_AllocPool("VMPOLY", 0, NULL);
2545         polys->max_triangles = 1024;
2546         VM_ResizePolygons(polys);
2547         polys->initialized = true;
2548 }
2549
2550 static void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
2551 {
2552         int surfacelistindex;
2553         vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
2554         if(polys->progstarttime != prog->starttime) // from other progs? won't draw these (this can cause crashes!)
2555                 return;
2556         R_Mesh_ResetTextureState();
2557         R_Mesh_Matrix(&identitymatrix);
2558         GL_CullFace(GL_NONE);
2559         R_Mesh_VertexPointer(polys->data_vertex3f, 0, 0);
2560         R_Mesh_ColorPointer(polys->data_color4f, 0, 0);
2561         R_Mesh_TexCoordPointer(0, 2, polys->data_texcoord2f, 0, 0);
2562         R_SetupGenericShader(true);
2563
2564         for (surfacelistindex = 0;surfacelistindex < numsurfaces;)
2565         {
2566                 int numtriangles = 0;
2567                 rtexture_t *tex = polys->data_triangles[surfacelist[surfacelistindex]].texture;
2568                 int drawflag = polys->data_triangles[surfacelist[surfacelistindex]].drawflag;
2569                 // this can't call _DrawQ_ProcessDrawFlag, but should be in sync with it
2570                 // FIXME factor this out
2571                 if(drawflag == DRAWFLAG_ADDITIVE)
2572                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
2573                 else if(drawflag == DRAWFLAG_MODULATE)
2574                         GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
2575                 else if(drawflag == DRAWFLAG_2XMODULATE)
2576                         GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR);
2577                 else if(drawflag == DRAWFLAG_SCREEN)
2578                         GL_BlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ONE);
2579                 else
2580                         GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2581                 R_Mesh_TexBind(0, R_GetTexture(tex));
2582                 numtriangles = 0;
2583                 for (;surfacelistindex < numsurfaces;surfacelistindex++)
2584                 {
2585                         if (polys->data_triangles[surfacelist[surfacelistindex]].texture != tex || polys->data_triangles[surfacelist[surfacelistindex]].drawflag != drawflag)
2586                                 break;
2587                         VectorCopy(polys->data_triangles[surfacelist[surfacelistindex]].elements, polys->data_sortedelement3s + 3*numtriangles);
2588                         numtriangles++;
2589                 }
2590                 R_Mesh_Draw(0, polys->num_vertices, 0, numtriangles, NULL, polys->data_sortedelement3s, 0, 0);
2591         }
2592 }
2593
2594 void VMPolygons_Store(vmpolygons_t *polys)
2595 {
2596         if (r_refdef.draw2dstage)
2597         {
2598                 // draw the polygon as 2D immediately
2599                 drawqueuemesh_t mesh;
2600                 mesh.texture = polys->begin_texture;
2601                 mesh.num_vertices = polys->begin_vertices;
2602                 mesh.num_triangles = polys->begin_vertices-2;
2603                 mesh.data_element3s = polygonelements;
2604                 mesh.data_vertex3f = polys->begin_vertex[0];
2605                 mesh.data_color4f = polys->begin_color[0];
2606                 mesh.data_texcoord2f = polys->begin_texcoord[0];
2607                 DrawQ_Mesh(&mesh, polys->begin_drawflag);
2608         }
2609         else
2610         {
2611                 // queue the polygon as 3D for sorted transparent rendering later
2612                 int i;
2613                 if (polys->max_triangles < polys->num_triangles + polys->begin_vertices-2)
2614                 {
2615                         polys->max_triangles *= 2;
2616                         VM_ResizePolygons(polys);
2617                 }
2618                 if (polys->num_vertices + polys->begin_vertices <= polys->max_vertices)
2619                 {
2620                         // needle in a haystack!
2621                         // polys->num_vertices was used for copying where we actually want to copy begin_vertices
2622                         // that also caused it to not render the first polygon that is added
2623                         // --blub
2624                         memcpy(polys->data_vertex3f + polys->num_vertices * 3, polys->begin_vertex[0], polys->begin_vertices * sizeof(float[3]));
2625                         memcpy(polys->data_color4f + polys->num_vertices * 4, polys->begin_color[0], polys->begin_vertices * sizeof(float[4]));
2626                         memcpy(polys->data_texcoord2f + polys->num_vertices * 2, polys->begin_texcoord[0], polys->begin_vertices * sizeof(float[2]));
2627                         for (i = 0;i < polys->begin_vertices-2;i++)
2628                         {
2629                                 polys->data_triangles[polys->num_triangles].texture = polys->begin_texture;
2630                                 polys->data_triangles[polys->num_triangles].drawflag = polys->begin_drawflag;
2631                                 polys->data_triangles[polys->num_triangles].elements[0] = polys->num_vertices;
2632                                 polys->data_triangles[polys->num_triangles].elements[1] = polys->num_vertices + i+1;
2633                                 polys->data_triangles[polys->num_triangles].elements[2] = polys->num_vertices + i+2;
2634                                 polys->num_triangles++;
2635                         }
2636                         polys->num_vertices += polys->begin_vertices;
2637                 }
2638         }
2639         polys->begin_active = false;
2640 }
2641
2642 // TODO: move this into the client code and clean-up everything else, too! [1/6/2008 Black]
2643 // LordHavoc: agreed, this is a mess
2644 void VM_CL_AddPolygonsToMeshQueue (void)
2645 {
2646         int i;
2647         vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
2648         vec3_t center;
2649
2650         // only add polygons of the currently active prog to the queue - if there is none, we're done
2651         if( !prog )
2652                 return;
2653
2654         if (!polys->num_triangles)
2655                 return;
2656
2657         for (i = 0;i < polys->num_triangles;i++)
2658         {
2659                 VectorMAMAM(1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].elements[0], 1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].elements[1], 1.0f / 3.0f, polys->data_vertex3f + 3*polys->data_triangles[i].elements[2], center);
2660                 R_MeshQueue_AddTransparent(center, VM_DrawPolygonCallback, NULL, i, NULL);
2661         }
2662
2663         /*polys->num_triangles = 0; // now done after rendering the scene,
2664           polys->num_vertices = 0;  // otherwise it's not rendered at all and prints an error message --blub */
2665 }
2666
2667 //void(string texturename, float flag) R_BeginPolygon
2668 void VM_CL_R_PolygonBegin (void)
2669 {
2670         const char              *picname;
2671         skinframe_t     *sf;
2672         vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
2673         int tf;
2674
2675         // TODO instead of using skinframes here (which provides the benefit of
2676         // better management of flags, and is more suited for 3D rendering), what
2677         // about supporting Q3 shaders?
2678
2679         VM_SAFEPARMCOUNT(2, VM_CL_R_PolygonBegin);
2680
2681         if (!polys->initialized)
2682                 VM_InitPolygons(polys);
2683         if(polys->progstarttime != prog->starttime)
2684         {
2685                 // from another progs? then reset the polys first (fixes crashes on map change, because that can make skinframe textures invalid)
2686                 polys->num_vertices = polys->num_triangles = 0;
2687                 polys->progstarttime = prog->starttime;
2688         }
2689         if (polys->begin_active)
2690         {
2691                 VM_Warning("VM_CL_R_PolygonBegin: called twice without VM_CL_R_PolygonBegin after first\n");
2692                 return;
2693         }
2694         picname = PRVM_G_STRING(OFS_PARM0);
2695
2696         sf = NULL;
2697         if(*picname)
2698         {
2699                 tf = TEXF_ALPHA;
2700                 if((int)PRVM_G_FLOAT(OFS_PARM1) & DRAWFLAG_MIPMAP)
2701                         tf |= TEXF_MIPMAP;
2702
2703                 do
2704                 {
2705                         sf = R_SkinFrame_FindNextByName(sf, picname);
2706                 }
2707                 while(sf && sf->textureflags != tf);
2708
2709                 if(!sf || !sf->base)
2710                         sf = R_SkinFrame_LoadExternal(picname, tf, true);
2711
2712                 if(sf)
2713                         R_SkinFrame_MarkUsed(sf);
2714         }
2715
2716         polys->begin_texture = (sf && sf->base) ? sf->base : r_texture_white;
2717         polys->begin_drawflag = (int)PRVM_G_FLOAT(OFS_PARM1) & DRAWFLAG_MASK;
2718         polys->begin_vertices = 0;
2719         polys->begin_active = true;
2720 }
2721
2722 //void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
2723 void VM_CL_R_PolygonVertex (void)
2724 {
2725         vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
2726
2727         VM_SAFEPARMCOUNT(4, VM_CL_R_PolygonVertex);
2728
2729         if (!polys->begin_active)
2730         {
2731                 VM_Warning("VM_CL_R_PolygonVertex: VM_CL_R_PolygonBegin wasn't called\n");
2732                 return;
2733         }
2734
2735         if (polys->begin_vertices >= VMPOLYGONS_MAXPOINTS)
2736         {
2737                 VM_Warning("VM_CL_R_PolygonVertex: may have %i vertices max\n", VMPOLYGONS_MAXPOINTS);
2738                 return;
2739         }
2740
2741         polys->begin_vertex[polys->begin_vertices][0] = PRVM_G_VECTOR(OFS_PARM0)[0];
2742         polys->begin_vertex[polys->begin_vertices][1] = PRVM_G_VECTOR(OFS_PARM0)[1];
2743         polys->begin_vertex[polys->begin_vertices][2] = PRVM_G_VECTOR(OFS_PARM0)[2];
2744         polys->begin_texcoord[polys->begin_vertices][0] = PRVM_G_VECTOR(OFS_PARM1)[0];
2745         polys->begin_texcoord[polys->begin_vertices][1] = PRVM_G_VECTOR(OFS_PARM1)[1];
2746         polys->begin_color[polys->begin_vertices][0] = PRVM_G_VECTOR(OFS_PARM2)[0];
2747         polys->begin_color[polys->begin_vertices][1] = PRVM_G_VECTOR(OFS_PARM2)[1];
2748         polys->begin_color[polys->begin_vertices][2] = PRVM_G_VECTOR(OFS_PARM2)[2];
2749         polys->begin_color[polys->begin_vertices][3] = PRVM_G_FLOAT(OFS_PARM3);
2750         polys->begin_vertices++;
2751 }
2752
2753 //void() R_EndPolygon
2754 void VM_CL_R_PolygonEnd (void)
2755 {
2756         vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
2757
2758         VM_SAFEPARMCOUNT(0, VM_CL_R_PolygonEnd);
2759         if (!polys->begin_active)
2760         {
2761                 VM_Warning("VM_CL_R_PolygonEnd: VM_CL_R_PolygonBegin wasn't called\n");
2762                 return;
2763         }
2764         polys->begin_active = false;
2765         if (polys->begin_vertices >= 3)
2766                 VMPolygons_Store(polys);
2767         else
2768                 VM_Warning("VM_CL_R_PolygonEnd: %i vertices isn't a good choice\n", polys->begin_vertices);
2769 }
2770
2771 static vmpolygons_t debugPolys;
2772
2773 void Debug_PolygonBegin(const char *picname, int drawflag)
2774 {
2775         if(!debugPolys.initialized)
2776                 VM_InitPolygons(&debugPolys);
2777         if(debugPolys.begin_active)
2778         {
2779                 Con_Printf("Debug_PolygonBegin: called twice without Debug_PolygonEnd after first\n");
2780                 return;
2781         }
2782         debugPolys.begin_texture = picname[0] ? Draw_CachePic (picname)->tex : r_texture_white;
2783         debugPolys.begin_drawflag = drawflag;
2784         debugPolys.begin_vertices = 0;
2785         debugPolys.begin_active = true;
2786 }
2787
2788 void Debug_PolygonVertex(float x, float y, float z, float s, float t, float r, float g, float b, float a)
2789 {
2790         if(!debugPolys.begin_active)
2791         {
2792                 Con_Printf("Debug_PolygonVertex: Debug_PolygonBegin wasn't called\n");
2793                 return;
2794         }
2795
2796         if(debugPolys.begin_vertices > VMPOLYGONS_MAXPOINTS)
2797         {
2798                 Con_Printf("Debug_PolygonVertex: may have %i vertices max\n", VMPOLYGONS_MAXPOINTS);
2799                 return;
2800         }
2801
2802         debugPolys.begin_vertex[debugPolys.begin_vertices][0] = x;
2803         debugPolys.begin_vertex[debugPolys.begin_vertices][1] = y;
2804         debugPolys.begin_vertex[debugPolys.begin_vertices][2] = z;
2805         debugPolys.begin_texcoord[debugPolys.begin_vertices][0] = s;
2806         debugPolys.begin_texcoord[debugPolys.begin_vertices][1] = t;
2807         debugPolys.begin_color[debugPolys.begin_vertices][0] = r;
2808         debugPolys.begin_color[debugPolys.begin_vertices][1] = g;
2809         debugPolys.begin_color[debugPolys.begin_vertices][2] = b;
2810         debugPolys.begin_color[debugPolys.begin_vertices][3] = a;
2811         debugPolys.begin_vertices++;
2812 }
2813
2814 void Debug_PolygonEnd(void)
2815 {
2816         if (!debugPolys.begin_active)
2817         {
2818                 Con_Printf("Debug_PolygonEnd: Debug_PolygonBegin wasn't called\n");
2819                 return;
2820         }
2821         debugPolys.begin_active = false;
2822         if (debugPolys.begin_vertices >= 3)
2823                 VMPolygons_Store(&debugPolys);
2824         else
2825                 Con_Printf("Debug_PolygonEnd: %i vertices isn't a good choice\n", debugPolys.begin_vertices);
2826 }
2827
2828 /*
2829 =============
2830 CL_CheckBottom
2831
2832 Returns false if any part of the bottom of the entity is off an edge that
2833 is not a staircase.
2834
2835 =============
2836 */
2837 qboolean CL_CheckBottom (prvm_edict_t *ent)
2838 {
2839         vec3_t  mins, maxs, start, stop;
2840         trace_t trace;
2841         int             x, y;
2842         float   mid, bottom;
2843
2844         VectorAdd (ent->fields.client->origin, ent->fields.client->mins, mins);
2845         VectorAdd (ent->fields.client->origin, ent->fields.client->maxs, maxs);
2846
2847 // if all of the points under the corners are solid world, don't bother
2848 // with the tougher checks
2849 // the corners must be within 16 of the midpoint
2850         start[2] = mins[2] - 1;
2851         for     (x=0 ; x<=1 ; x++)
2852                 for     (y=0 ; y<=1 ; y++)
2853                 {
2854                         start[0] = x ? maxs[0] : mins[0];
2855                         start[1] = y ? maxs[1] : mins[1];
2856                         if (!(CL_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
2857                                 goto realcheck;
2858                 }
2859
2860         return true;            // we got out easy
2861
2862 realcheck:
2863 //
2864 // check it for real...
2865 //
2866         start[2] = mins[2];
2867
2868 // the midpoint must be within 16 of the bottom
2869         start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
2870         start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
2871         stop[2] = start[2] - 2*sv_stepheight.value;
2872         trace = CL_Move (start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), true, false, NULL, true);
2873
2874         if (trace.fraction == 1.0)
2875                 return false;
2876         mid = bottom = trace.endpos[2];
2877
2878 // the corners must be within 16 of the midpoint
2879         for     (x=0 ; x<=1 ; x++)
2880                 for     (y=0 ; y<=1 ; y++)
2881                 {
2882                         start[0] = stop[0] = x ? maxs[0] : mins[0];
2883                         start[1] = stop[1] = y ? maxs[1] : mins[1];
2884
2885                         trace = CL_Move (start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), true, false, NULL, true);
2886
2887                         if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
2888                                 bottom = trace.endpos[2];
2889                         if (trace.fraction == 1.0 || mid - trace.endpos[2] > sv_stepheight.value)
2890                                 return false;
2891                 }
2892
2893         return true;
2894 }
2895
2896 /*
2897 =============
2898 CL_movestep
2899
2900 Called by monster program code.
2901 The move will be adjusted for slopes and stairs, but if the move isn't
2902 possible, no move is done and false is returned
2903 =============
2904 */
2905 qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean noenemy, qboolean settrace)
2906 {
2907         float           dz;
2908         vec3_t          oldorg, neworg, end, traceendpos;
2909         trace_t         trace;
2910         int                     i, svent;
2911         prvm_edict_t            *enemy;
2912         prvm_eval_t     *val;
2913
2914 // try the move
2915         VectorCopy (ent->fields.client->origin, oldorg);
2916         VectorAdd (ent->fields.client->origin, move, neworg);
2917
2918 // flying monsters don't step up
2919         if ( (int)ent->fields.client->flags & (FL_SWIM | FL_FLY) )
2920         {
2921         // try one move with vertical motion, then one without
2922                 for (i=0 ; i<2 ; i++)
2923                 {
2924                         VectorAdd (ent->fields.client->origin, move, neworg);
2925                         enemy = PRVM_PROG_TO_EDICT(ent->fields.client->enemy);
2926                         if (i == 0 && enemy != prog->edicts)
2927                         {
2928                                 dz = ent->fields.client->origin[2] - PRVM_PROG_TO_EDICT(ent->fields.client->enemy)->fields.client->origin[2];
2929                                 if (dz > 40)
2930                                         neworg[2] -= 8;
2931                                 if (dz < 30)
2932                                         neworg[2] += 8;
2933                         }
2934                         trace = CL_Move (ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->maxs, neworg, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
2935                         if (settrace)
2936                                 CL_VM_SetTraceGlobals(&trace, svent);
2937
2938                         if (trace.fraction == 1)
2939                         {
2940                                 VectorCopy(trace.endpos, traceendpos);
2941                                 if (((int)ent->fields.client->flags & FL_SWIM) && !(CL_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
2942                                         return false;   // swim monster left water
2943
2944                                 VectorCopy (traceendpos, ent->fields.client->origin);
2945                                 if (relink)
2946                                         CL_LinkEdict(ent);
2947                                 return true;
2948                         }
2949
2950                         if (enemy == prog->edicts)
2951                                 break;
2952                 }
2953
2954                 return false;
2955         }
2956
2957 // push down from a step height above the wished position
2958         neworg[2] += sv_stepheight.value;
2959         VectorCopy (neworg, end);
2960         end[2] -= sv_stepheight.value*2;
2961
2962         trace = CL_Move (neworg, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
2963         if (settrace)
2964                 CL_VM_SetTraceGlobals(&trace, svent);
2965
2966         if (trace.startsolid)
2967         {
2968                 neworg[2] -= sv_stepheight.value;
2969                 trace = CL_Move (neworg, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
2970                 if (settrace)
2971                         CL_VM_SetTraceGlobals(&trace, svent);
2972                 if (trace.startsolid)
2973                         return false;
2974         }
2975         if (trace.fraction == 1)
2976         {
2977         // if monster had the ground pulled out, go ahead and fall
2978                 if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
2979                 {
2980                         VectorAdd (ent->fields.client->origin, move, ent->fields.client->origin);
2981                         if (relink)
2982                                 CL_LinkEdict(ent);
2983                         ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_ONGROUND;
2984                         return true;
2985                 }
2986
2987                 return false;           // walked off an edge
2988         }
2989
2990 // check point traces down for dangling corners
2991         VectorCopy (trace.endpos, ent->fields.client->origin);
2992
2993         if (!CL_CheckBottom (ent))
2994         {
2995                 if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
2996                 {       // entity had floor mostly pulled out from underneath it
2997                         // and is trying to correct
2998                         if (relink)
2999                                 CL_LinkEdict(ent);
3000                         return true;
3001                 }
3002                 VectorCopy (oldorg, ent->fields.client->origin);
3003                 return false;
3004         }
3005
3006         if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
3007                 ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_PARTIALGROUND;
3008
3009         if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.groundentity)))
3010                 val->edict = PRVM_EDICT_TO_PROG(trace.ent);
3011
3012 // the move is ok
3013         if (relink)
3014                 CL_LinkEdict(ent);
3015         return true;
3016 }
3017
3018 /*
3019 ===============
3020 VM_CL_walkmove
3021
3022 float(float yaw, float dist[, settrace]) walkmove
3023 ===============
3024 */
3025 static void VM_CL_walkmove (void)
3026 {
3027         prvm_edict_t    *ent;
3028         float   yaw, dist;
3029         vec3_t  move;
3030         mfunction_t     *oldf;
3031         int     oldself;
3032         qboolean        settrace;
3033
3034         VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_walkmove);
3035
3036         // assume failure if it returns early
3037         PRVM_G_FLOAT(OFS_RETURN) = 0;
3038
3039         ent = PRVM_PROG_TO_EDICT(prog->globals.client->self);
3040         if (ent == prog->edicts)
3041         {
3042                 VM_Warning("walkmove: can not modify world entity\n");
3043                 return;
3044         }
3045         if (ent->priv.server->free)
3046         {
3047                 VM_Warning("walkmove: can not modify free entity\n");
3048                 return;
3049         }
3050         yaw = PRVM_G_FLOAT(OFS_PARM0);
3051         dist = PRVM_G_FLOAT(OFS_PARM1);
3052         settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
3053
3054         if ( !( (int)ent->fields.client->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
3055                 return;
3056
3057         yaw = yaw*M_PI*2 / 360;
3058
3059         move[0] = cos(yaw)*dist;
3060         move[1] = sin(yaw)*dist;
3061         move[2] = 0;
3062
3063 // save program state, because CL_movestep may call other progs
3064         oldf = prog->xfunction;
3065         oldself = prog->globals.client->self;
3066
3067         PRVM_G_FLOAT(OFS_RETURN) = CL_movestep(ent, move, true, false, settrace);
3068
3069
3070 // restore program state
3071         prog->xfunction = oldf;
3072         prog->globals.client->self = oldself;
3073 }
3074
3075 /*
3076 ===============
3077 VM_CL_serverkey
3078
3079 string(string key) serverkey
3080 ===============
3081 */
3082 void VM_CL_serverkey(void)
3083 {
3084         char string[VM_STRINGTEMP_LENGTH];
3085         VM_SAFEPARMCOUNT(1, VM_CL_serverkey);
3086         InfoString_GetValue(cl.qw_serverinfo, PRVM_G_STRING(OFS_PARM0), string, sizeof(string));
3087         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
3088 }
3089
3090 /*
3091 =================
3092 VM_CL_checkpvs
3093
3094 Checks if an entity is in a point's PVS.
3095 Should be fast but can be inexact.
3096
3097 float checkpvs(vector viewpos, entity viewee) = #240;
3098 =================
3099 */
3100 static void VM_CL_checkpvs (void)
3101 {
3102         vec3_t viewpos;
3103         prvm_edict_t *viewee;
3104         vec3_t mi, ma;
3105 #if 1
3106         unsigned char *pvs;
3107 #else
3108         static int fatpvsbytes;
3109         static unsigned char fatpvs[MAX_MAP_LEAFS/8];
3110 #endif
3111
3112         VM_SAFEPARMCOUNT(2, VM_SV_checkpvs);
3113         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), viewpos);
3114         viewee = PRVM_G_EDICT(OFS_PARM1);
3115
3116         if(viewee->priv.required->free)
3117         {
3118                 VM_Warning("checkpvs: can not check free entity\n");
3119                 PRVM_G_FLOAT(OFS_RETURN) = 4;
3120                 return;
3121         }
3122
3123         VectorAdd(viewee->fields.server->origin, viewee->fields.server->mins, mi);
3124         VectorAdd(viewee->fields.server->origin, viewee->fields.server->maxs, ma);
3125
3126 #if 1
3127         if(!sv.worldmodel->brush.GetPVS || !sv.worldmodel->brush.BoxTouchingPVS)
3128         {
3129                 // no PVS support on this worldmodel... darn
3130                 PRVM_G_FLOAT(OFS_RETURN) = 3;
3131                 return;
3132         }
3133         pvs = sv.worldmodel->brush.GetPVS(sv.worldmodel, viewpos);
3134         if(!pvs)
3135         {
3136                 // viewpos isn't in any PVS... darn
3137                 PRVM_G_FLOAT(OFS_RETURN) = 2;
3138                 return;
3139         }
3140         PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, pvs, mi, ma);
3141 #else
3142         // using fat PVS like FTEQW does (slow)
3143         if(!sv.worldmodel->brush.FatPVS || !sv.worldmodel->brush.BoxTouchingPVS)
3144         {
3145                 // no PVS support on this worldmodel... darn
3146                 PRVM_G_FLOAT(OFS_RETURN) = 3;
3147                 return;
3148         }
3149         fatpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, viewpos, 8, fatpvs, sizeof(fatpvs), false);
3150         if(!fatpvsbytes)
3151         {
3152                 // viewpos isn't in any PVS... darn
3153                 PRVM_G_FLOAT(OFS_RETURN) = 2;
3154                 return;
3155         }
3156         PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, fatpvs, mi, ma);
3157 #endif
3158 }
3159 //============================================================================
3160
3161 // To create a almost working builtin file from this replace:
3162 // "^NULL.*" with ""
3163 // "^{.*//.*}:Wh\(.*\)" with "\1"
3164 // "\:" with "//"
3165 // "^.*//:Wh{\#:d*}:Wh{.*}" with "\2 = \1;"
3166 // "\n\n+" with "\n\n"
3167
3168 prvm_builtin_t vm_cl_builtins[] = {
3169 NULL,                                                   // #0 NULL function (not callable) (QUAKE)
3170 VM_CL_makevectors,                              // #1 void(vector ang) makevectors (QUAKE)
3171 VM_CL_setorigin,                                // #2 void(entity e, vector o) setorigin (QUAKE)
3172 VM_CL_setmodel,                                 // #3 void(entity e, string m) setmodel (QUAKE)
3173 VM_CL_setsize,                                  // #4 void(entity e, vector min, vector max) setsize (QUAKE)
3174 NULL,                                                   // #5 void(entity e, vector min, vector max) setabssize (QUAKE)
3175 VM_break,                                               // #6 void() break (QUAKE)
3176 VM_random,                                              // #7 float() random (QUAKE)
3177 VM_CL_sound,                                    // #8 void(entity e, float chan, string samp) sound (QUAKE)
3178 VM_normalize,                                   // #9 vector(vector v) normalize (QUAKE)
3179 VM_error,                                               // #10 void(string e) error (QUAKE)
3180 VM_objerror,                                    // #11 void(string e) objerror (QUAKE)
3181 VM_vlen,                                                // #12 float(vector v) vlen (QUAKE)
3182 VM_vectoyaw,                                    // #13 float(vector v) vectoyaw (QUAKE)
3183 VM_CL_spawn,                                    // #14 entity() spawn (QUAKE)
3184 VM_remove,                                              // #15 void(entity e) remove (QUAKE)
3185 VM_CL_traceline,                                // #16 void(vector v1, vector v2, float tryents, entity ignoreentity) traceline (QUAKE)
3186 NULL,                                                   // #17 entity() checkclient (QUAKE)
3187 VM_find,                                                // #18 entity(entity start, .string fld, string match) find (QUAKE)
3188 VM_precache_sound,                              // #19 void(string s) precache_sound (QUAKE)
3189 VM_CL_precache_model,                   // #20 void(string s) precache_model (QUAKE)
3190 NULL,                                                   // #21 void(entity client, string s, ...) stuffcmd (QUAKE)
3191 VM_CL_findradius,                               // #22 entity(vector org, float rad) findradius (QUAKE)
3192 NULL,                                                   // #23 void(string s, ...) bprint (QUAKE)
3193 NULL,                                                   // #24 void(entity client, string s, ...) sprint (QUAKE)
3194 VM_dprint,                                              // #25 void(string s, ...) dprint (QUAKE)
3195 VM_ftos,                                                // #26 string(float f) ftos (QUAKE)
3196 VM_vtos,                                                // #27 string(vector v) vtos (QUAKE)
3197 VM_coredump,                                    // #28 void() coredump (QUAKE)
3198 VM_traceon,                                             // #29 void() traceon (QUAKE)
3199 VM_traceoff,                                    // #30 void() traceoff (QUAKE)
3200 VM_eprint,                                              // #31 void(entity e) eprint (QUAKE)
3201 VM_CL_walkmove,                                 // #32 float(float yaw, float dist[, float settrace]) walkmove (QUAKE)
3202 NULL,                                                   // #33 (QUAKE)
3203 VM_CL_droptofloor,                              // #34 float() droptofloor (QUAKE)
3204 VM_CL_lightstyle,                               // #35 void(float style, string value) lightstyle (QUAKE)
3205 VM_rint,                                                // #36 float(float v) rint (QUAKE)
3206 VM_floor,                                               // #37 float(float v) floor (QUAKE)
3207 VM_ceil,                                                // #38 float(float v) ceil (QUAKE)
3208 NULL,                                                   // #39 (QUAKE)
3209 VM_CL_checkbottom,                              // #40 float(entity e) checkbottom (QUAKE)
3210 VM_CL_pointcontents,                    // #41 float(vector v) pointcontents (QUAKE)
3211 NULL,                                                   // #42 (QUAKE)
3212 VM_fabs,                                                // #43 float(float f) fabs (QUAKE)
3213 NULL,                                                   // #44 vector(entity e, float speed) aim (QUAKE)
3214 VM_cvar,                                                // #45 float(string s) cvar (QUAKE)
3215 VM_localcmd,                                    // #46 void(string s) localcmd (QUAKE)
3216 VM_nextent,                                             // #47 entity(entity e) nextent (QUAKE)
3217 VM_CL_particle,                                 // #48 void(vector o, vector d, float color, float count) particle (QUAKE)
3218 VM_changeyaw,                                   // #49 void() ChangeYaw (QUAKE)
3219 NULL,                                                   // #50 (QUAKE)
3220 VM_vectoangles,                                 // #51 vector(vector v) vectoangles (QUAKE)
3221 NULL,                                                   // #52 void(float to, float f) WriteByte (QUAKE)
3222 NULL,                                                   // #53 void(float to, float f) WriteChar (QUAKE)
3223 NULL,                                                   // #54 void(float to, float f) WriteShort (QUAKE)
3224 NULL,                                                   // #55 void(float to, float f) WriteLong (QUAKE)
3225 NULL,                                                   // #56 void(float to, float f) WriteCoord (QUAKE)
3226 NULL,                                                   // #57 void(float to, float f) WriteAngle (QUAKE)
3227 NULL,                                                   // #58 void(float to, string s) WriteString (QUAKE)
3228 NULL,                                                   // #59 (QUAKE)
3229 VM_sin,                                                 // #60 float(float f) sin (DP_QC_SINCOSSQRTPOW)
3230 VM_cos,                                                 // #61 float(float f) cos (DP_QC_SINCOSSQRTPOW)
3231 VM_sqrt,                                                // #62 float(float f) sqrt (DP_QC_SINCOSSQRTPOW)
3232 VM_changepitch,                                 // #63 void(entity ent) changepitch (DP_QC_CHANGEPITCH)
3233 VM_CL_tracetoss,                                // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS)
3234 VM_etos,                                                // #65 string(entity ent) etos (DP_QC_ETOS)
3235 NULL,                                                   // #66 (QUAKE)
3236 NULL,                                                   // #67 void(float step) movetogoal (QUAKE)
3237 VM_precache_file,                               // #68 string(string s) precache_file (QUAKE)
3238 VM_CL_makestatic,                               // #69 void(entity e) makestatic (QUAKE)
3239 NULL,                                                   // #70 void(string s) changelevel (QUAKE)
3240 NULL,                                                   // #71 (QUAKE)
3241 VM_cvar_set,                                    // #72 void(string var, string val) cvar_set (QUAKE)
3242 NULL,                                                   // #73 void(entity client, strings) centerprint (QUAKE)
3243 VM_CL_ambientsound,                             // #74 void(vector pos, string samp, float vol, float atten) ambientsound (QUAKE)
3244 VM_CL_precache_model,                   // #75 string(string s) precache_model2 (QUAKE)
3245 VM_precache_sound,                              // #76 string(string s) precache_sound2 (QUAKE)
3246 VM_precache_file,                               // #77 string(string s) precache_file2 (QUAKE)
3247 NULL,                                                   // #78 void(entity e) setspawnparms (QUAKE)
3248 NULL,                                                   // #79 void(entity killer, entity killee) logfrag (QUAKEWORLD)
3249 NULL,                                                   // #80 string(entity e, string keyname) infokey (QUAKEWORLD)
3250 VM_stof,                                                // #81 float(string s) stof (FRIK_FILE)
3251 NULL,                                                   // #82 void(vector where, float set) multicast (QUAKEWORLD)
3252 NULL,                                                   // #83 (QUAKE)
3253 NULL,                                                   // #84 (QUAKE)
3254 NULL,                                                   // #85 (QUAKE)
3255 NULL,                                                   // #86 (QUAKE)
3256 NULL,                                                   // #87 (QUAKE)
3257 NULL,                                                   // #88 (QUAKE)
3258 NULL,                                                   // #89 (QUAKE)
3259 VM_CL_tracebox,                                 // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
3260 VM_randomvec,                                   // #91 vector() randomvec (DP_QC_RANDOMVEC)
3261 VM_CL_getlight,                                 // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
3262 VM_registercvar,                                // #93 float(string name, string value) registercvar (DP_REGISTERCVAR)
3263 VM_min,                                                 // #94 float(float a, floats) min (DP_QC_MINMAXBOUND)
3264 VM_max,                                                 // #95 float(float a, floats) max (DP_QC_MINMAXBOUND)
3265 VM_bound,                                               // #96 float(float minimum, float val, float maximum) bound (DP_QC_MINMAXBOUND)
3266 VM_pow,                                                 // #97 float(float f, float f) pow (DP_QC_SINCOSSQRTPOW)
3267 VM_findfloat,                                   // #98 entity(entity start, .float fld, float match) findfloat (DP_QC_FINDFLOAT)
3268 VM_checkextension,                              // #99 float(string s) checkextension (the basis of the extension system)
3269 // FrikaC and Telejano range #100-#199
3270 NULL,                                                   // #100
3271 NULL,                                                   // #101
3272 NULL,                                                   // #102
3273 NULL,                                                   // #103
3274 NULL,                                                   // #104
3275 NULL,                                                   // #105
3276 NULL,                                                   // #106
3277 NULL,                                                   // #107
3278 NULL,                                                   // #108
3279 NULL,                                                   // #109
3280 VM_fopen,                                               // #110 float(string filename, float mode) fopen (FRIK_FILE)
3281 VM_fclose,                                              // #111 void(float fhandle) fclose (FRIK_FILE)
3282 VM_fgets,                                               // #112 string(float fhandle) fgets (FRIK_FILE)
3283 VM_fputs,                                               // #113 void(float fhandle, string s) fputs (FRIK_FILE)
3284 VM_strlen,                                              // #114 float(string s) strlen (FRIK_FILE)
3285 VM_strcat,                                              // #115 string(string s1, string s2, ...) strcat (FRIK_FILE)
3286 VM_substring,                                   // #116 string(string s, float start, float length) substring (FRIK_FILE)
3287 VM_stov,                                                // #117 vector(string) stov (FRIK_FILE)
3288 VM_strzone,                                             // #118 string(string s) strzone (FRIK_FILE)
3289 VM_strunzone,                                   // #119 void(string s) strunzone (FRIK_FILE)
3290 NULL,                                                   // #120
3291 NULL,                                                   // #121
3292 NULL,                                                   // #122
3293 NULL,                                                   // #123
3294 NULL,                                                   // #124
3295 NULL,                                                   // #125
3296 NULL,                                                   // #126
3297 NULL,                                                   // #127
3298 NULL,                                                   // #128
3299 NULL,                                                   // #129
3300 NULL,                                                   // #130
3301 NULL,                                                   // #131
3302 NULL,                                                   // #132
3303 NULL,                                                   // #133
3304 NULL,                                                   // #134
3305 NULL,                                                   // #135
3306 NULL,                                                   // #136
3307 NULL,                                                   // #137
3308 NULL,                                                   // #138
3309 NULL,                                                   // #139
3310 NULL,                                                   // #140
3311 NULL,                                                   // #141
3312 NULL,                                                   // #142
3313 NULL,                                                   // #143
3314 NULL,                                                   // #144
3315 NULL,                                                   // #145
3316 NULL,                                                   // #146
3317 NULL,                                                   // #147
3318 NULL,                                                   // #148
3319 NULL,                                                   // #149
3320 NULL,                                                   // #150
3321 NULL,                                                   // #151
3322 NULL,                                                   // #152
3323 NULL,                                                   // #153
3324 NULL,                                                   // #154
3325 NULL,                                                   // #155
3326 NULL,                                                   // #156
3327 NULL,                                                   // #157
3328 NULL,                                                   // #158
3329 NULL,                                                   // #159
3330 NULL,                                                   // #160
3331 NULL,                                                   // #161
3332 NULL,                                                   // #162
3333 NULL,                                                   // #163
3334 NULL,                                                   // #164
3335 NULL,                                                   // #165
3336 NULL,                                                   // #166
3337 NULL,                                                   // #167
3338 NULL,                                                   // #168
3339 NULL,                                                   // #169
3340 NULL,                                                   // #170
3341 NULL,                                                   // #171
3342 NULL,                                                   // #172
3343 NULL,                                                   // #173
3344 NULL,                                                   // #174
3345 NULL,                                                   // #175
3346 NULL,                                                   // #176
3347 NULL,                                                   // #177
3348 NULL,                                                   // #178
3349 NULL,                                                   // #179
3350 NULL,                                                   // #180
3351 NULL,                                                   // #181
3352 NULL,                                                   // #182
3353 NULL,                                                   // #183
3354 NULL,                                                   // #184
3355 NULL,                                                   // #185
3356 NULL,                                                   // #186
3357 NULL,                                                   // #187
3358 NULL,                                                   // #188
3359 NULL,                                                   // #189
3360 NULL,                                                   // #190
3361 NULL,                                                   // #191
3362 NULL,                                                   // #192
3363 NULL,                                                   // #193
3364 NULL,                                                   // #194
3365 NULL,                                                   // #195
3366 NULL,                                                   // #196
3367 NULL,                                                   // #197
3368 NULL,                                                   // #198
3369 NULL,                                                   // #199
3370 // FTEQW range #200-#299
3371 NULL,                                                   // #200
3372 NULL,                                                   // #201
3373 NULL,                                                   // #202
3374 NULL,                                                   // #203
3375 NULL,                                                   // #204
3376 NULL,                                                   // #205
3377 NULL,                                                   // #206
3378 NULL,                                                   // #207
3379 NULL,                                                   // #208
3380 NULL,                                                   // #209
3381 NULL,                                                   // #210
3382 NULL,                                                   // #211
3383 NULL,                                                   // #212
3384 NULL,                                                   // #213
3385 NULL,                                                   // #214
3386 NULL,                                                   // #215
3387 NULL,                                                   // #216
3388 NULL,                                                   // #217
3389 VM_bitshift,                                    // #218 float(float number, float quantity) bitshift (EXT_BITSHIFT)
3390 NULL,                                                   // #219
3391 NULL,                                                   // #220
3392 VM_strstrofs,                                   // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
3393 VM_str2chr,                                             // #222 float(string str, float ofs) str2chr (FTE_STRINGS)
3394 VM_chr2str,                                             // #223 string(float c, ...) chr2str (FTE_STRINGS)
3395 VM_strconv,                                             // #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS)
3396 VM_strpad,                                              // #225 string(float chars, string s, ...) strpad (FTE_STRINGS)
3397 VM_infoadd,                                             // #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS)
3398 VM_infoget,                                             // #227 string(string info, string key) infoget (FTE_STRINGS)
3399 VM_strncmp,                                             // #228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
3400 VM_strncasecmp,                                 // #229 float(string s1, string s2) strcasecmp (FTE_STRINGS)
3401 VM_strncasecmp,                                 // #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS)
3402 NULL,                                                   // #231
3403 NULL,                                                   // #232 void(float index, float type, .void field) SV_AddStat (EXT_CSQC)
3404 NULL,                                                   // #233
3405 NULL,                                                   // #234
3406 NULL,                                                   // #235
3407 NULL,                                                   // #236
3408 NULL,                                                   // #237
3409 NULL,                                                   // #238
3410 NULL,                                                   // #239
3411 VM_CL_checkpvs,                                 // #240
3412 NULL,                                                   // #241
3413 NULL,                                                   // #242
3414 NULL,                                                   // #243
3415 NULL,                                                   // #244
3416 NULL,                                                   // #245
3417 NULL,                                                   // #246
3418 NULL,                                                   // #247
3419 NULL,                                                   // #248
3420 NULL,                                                   // #249
3421 NULL,                                                   // #250
3422 NULL,                                                   // #251
3423 NULL,                                                   // #252
3424 NULL,                                                   // #253
3425 NULL,                                                   // #254
3426 NULL,                                                   // #255
3427 NULL,                                                   // #256
3428 NULL,                                                   // #257
3429 NULL,                                                   // #258
3430 NULL,                                                   // #259
3431 NULL,                                                   // #260
3432 NULL,                                                   // #261
3433 NULL,                                                   // #262
3434 NULL,                                                   // #263
3435 NULL,                                                   // #264
3436 NULL,                                                   // #265
3437 NULL,                                                   // #266
3438 NULL,                                                   // #267
3439 NULL,                                                   // #268
3440 NULL,                                                   // #269
3441 NULL,                                                   // #270
3442 NULL,                                                   // #271
3443 NULL,                                                   // #272
3444 NULL,                                                   // #273
3445 NULL,                                                   // #274
3446 NULL,                                                   // #275
3447 NULL,                                                   // #276
3448 NULL,                                                   // #277
3449 NULL,                                                   // #278
3450 NULL,                                                   // #279
3451 NULL,                                                   // #280
3452 NULL,                                                   // #281
3453 NULL,                                                   // #282
3454 NULL,                                                   // #283
3455 NULL,                                                   // #284
3456 NULL,                                                   // #285
3457 NULL,                                                   // #286
3458 NULL,                                                   // #287
3459 NULL,                                                   // #288
3460 NULL,                                                   // #289
3461 NULL,                                                   // #290
3462 NULL,                                                   // #291
3463 NULL,                                                   // #292
3464 NULL,                                                   // #293
3465 NULL,                                                   // #294
3466 NULL,                                                   // #295
3467 NULL,                                                   // #296
3468 NULL,                                                   // #297
3469 NULL,                                                   // #298
3470 NULL,                                                   // #299
3471 // CSQC range #300-#399
3472 VM_CL_R_ClearScene,                             // #300 void() clearscene (EXT_CSQC)
3473 VM_CL_R_AddEntities,                    // #301 void(float mask) addentities (EXT_CSQC)
3474 VM_CL_R_AddEntity,                              // #302 void(entity ent) addentity (EXT_CSQC)
3475 VM_CL_R_SetView,                                // #303 float(float property, ...) setproperty (EXT_CSQC)
3476 VM_CL_R_RenderScene,                    // #304 void() renderscene (EXT_CSQC)
3477 VM_CL_R_AddDynamicLight,                // #305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
3478 VM_CL_R_PolygonBegin,                   // #306 void(string texturename, float flag[, float is2d, float lines]) R_BeginPolygon
3479 VM_CL_R_PolygonVertex,                  // #307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
3480 VM_CL_R_PolygonEnd,                             // #308 void() R_EndPolygon
3481 NULL /* R_LoadWorldModel in menu VM, should stay unassigned in client*/, // #309
3482 VM_CL_unproject,                                // #310 vector (vector v) cs_unproject (EXT_CSQC)
3483 VM_CL_project,                                  // #311 vector (vector v) cs_project (EXT_CSQC)
3484 NULL,                                                   // #312
3485 NULL,                                                   // #313
3486 NULL,                                                   // #314
3487 VM_drawline,                                    // #315 void(float width, vector pos1, vector pos2, float flag) drawline (EXT_CSQC)
3488 VM_iscachedpic,                                 // #316 float(string name) iscachedpic (EXT_CSQC)
3489 VM_precache_pic,                                // #317 string(string name, float trywad) precache_pic (EXT_CSQC)
3490 VM_getimagesize,                                // #318 vector(string picname) draw_getimagesize (EXT_CSQC)
3491 VM_freepic,                                             // #319 void(string name) freepic (EXT_CSQC)
3492 VM_drawcharacter,                               // #320 float(vector position, float character, vector scale, vector rgb, float alpha, float flag) drawcharacter (EXT_CSQC)
3493 VM_drawstring,                                  // #321 float(vector position, string text, vector scale, vector rgb, float alpha, float flag) drawstring (EXT_CSQC)
3494 VM_drawpic,                                             // #322 float(vector position, string pic, vector size, vector rgb, float alpha, float flag) drawpic (EXT_CSQC)
3495 VM_drawfill,                                    // #323 float(vector position, vector size, vector rgb, float alpha, float flag) drawfill (EXT_CSQC)
3496 VM_drawsetcliparea,                             // #324 void(float x, float y, float width, float height) drawsetcliparea
3497 VM_drawresetcliparea,                   // #325 void(void) drawresetcliparea
3498 VM_drawcolorcodedstring,                // #326 float drawcolorcodedstring(vector position, string text, vector scale, vector rgb, float alpha, float flag) (EXT_CSQC)
3499 VM_stringwidth,                 // #327 // FIXME is this okay?
3500 VM_drawsubpic,                                  // #328 // FIXME is this okay?
3501 VM_drawrotpic,                                  // #329 // FIXME is this okay?
3502 VM_CL_getstatf,                                 // #330 float(float stnum) getstatf (EXT_CSQC)
3503 VM_CL_getstati,                                 // #331 float(float stnum) getstati (EXT_CSQC)
3504 VM_CL_getstats,                                 // #332 string(float firststnum) getstats (EXT_CSQC)
3505 VM_CL_setmodelindex,                    // #333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
3506 VM_CL_modelnameforindex,                // #334 string(float mdlindex) modelnameforindex (EXT_CSQC)
3507 VM_CL_particleeffectnum,                // #335 float(string effectname) particleeffectnum (EXT_CSQC)
3508 VM_CL_trailparticles,                   // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
3509 VM_CL_pointparticles,                   // #337 void(float effectnum, vector origin [, vector dir, float count]) pointparticles (EXT_CSQC)
3510 VM_centerprint,                                 // #338 void(string s, ...) centerprint (EXT_CSQC)
3511 VM_print,                                               // #339 void(string s, ...) print (EXT_CSQC, DP_SV_PRINT)
3512 VM_keynumtostring,                              // #340 string(float keynum) keynumtostring (EXT_CSQC)
3513 VM_stringtokeynum,                              // #341 float(string keyname) stringtokeynum (EXT_CSQC)
3514 VM_CL_getkeybind,                               // #342 string(float keynum) getkeybind (EXT_CSQC)
3515 VM_CL_setcursormode,                    // #343 void(float usecursor) setcursormode (EXT_CSQC)
3516 VM_CL_getmousepos,                              // #344 vector() getmousepos (EXT_CSQC)
3517 VM_CL_getinputstate,                    // #345 float(float framenum) getinputstate (EXT_CSQC)
3518 VM_CL_setsensitivityscale,              // #346 void(float sens) setsensitivityscale (EXT_CSQC)
3519 VM_CL_runplayerphysics,                 // #347 void() runstandardplayerphysics (EXT_CSQC)
3520 VM_CL_getplayerkey,                             // #348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
3521 VM_CL_isdemo,                                   // #349 float() isdemo (EXT_CSQC)
3522 VM_isserver,                                    // #350 float() isserver (EXT_CSQC)
3523 VM_CL_setlistener,                              // #351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
3524 VM_CL_registercmd,                              // #352 void(string cmdname) registercommand (EXT_CSQC)
3525 VM_wasfreed,                                    // #353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
3526 VM_CL_serverkey,                                // #354 string(string key) serverkey (EXT_CSQC)
3527 NULL,                                                   // #355
3528 NULL,                                                   // #356
3529 NULL,                                                   // #357
3530 NULL,                                                   // #358
3531 NULL,                                                   // #359
3532 VM_CL_ReadByte,                                 // #360 float() readbyte (EXT_CSQC)
3533 VM_CL_ReadChar,                                 // #361 float() readchar (EXT_CSQC)
3534 VM_CL_ReadShort,                                // #362 float() readshort (EXT_CSQC)
3535 VM_CL_ReadLong,                                 // #363 float() readlong (EXT_CSQC)
3536 VM_CL_ReadCoord,                                // #364 float() readcoord (EXT_CSQC)
3537 VM_CL_ReadAngle,                                // #365 float() readangle (EXT_CSQC)
3538 VM_CL_ReadString,                               // #366 string() readstring (EXT_CSQC)
3539 VM_CL_ReadFloat,                                // #367 float() readfloat (EXT_CSQC)
3540 NULL,                                           // #368
3541 NULL,                                                   // #369
3542 NULL,                                                   // #370
3543 NULL,                                                   // #371
3544 NULL,                                                   // #372
3545 NULL,                                                   // #373
3546 NULL,                                                   // #374
3547 NULL,                                                   // #375
3548 NULL,                                                   // #376
3549 NULL,                                                   // #377
3550 NULL,                                                   // #378
3551 NULL,                                                   // #379
3552 NULL,                                                   // #380
3553 NULL,                                                   // #381
3554 NULL,                                                   // #382
3555 NULL,                                                   // #383
3556 NULL,                                                   // #384
3557 NULL,                                                   // #385
3558 NULL,                                                   // #386
3559 NULL,                                                   // #387
3560 NULL,                                                   // #388
3561 NULL,                                                   // #389
3562 NULL,                                                   // #390
3563 NULL,                                                   // #391
3564 NULL,                                                   // #392
3565 NULL,                                                   // #393
3566 NULL,                                                   // #394
3567 NULL,                                                   // #395
3568 NULL,                                                   // #396
3569 NULL,                                                   // #397
3570 NULL,                                                   // #398
3571 NULL,                                                   // #399
3572 // LordHavoc's range #400-#499
3573 VM_CL_copyentity,                               // #400 void(entity from, entity to) copyentity (DP_QC_COPYENTITY)
3574 NULL,                                                   // #401 void(entity ent, float colors) setcolor (DP_QC_SETCOLOR)
3575 VM_findchain,                                   // #402 entity(.string fld, string match) findchain (DP_QC_FINDCHAIN)
3576 VM_findchainfloat,                              // #403 entity(.float fld, float match) findchainfloat (DP_QC_FINDCHAINFLOAT)
3577 VM_CL_effect,                                   // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
3578 VM_CL_te_blood,                                 // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
3579 VM_CL_te_bloodshower,                   // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
3580 VM_CL_te_explosionrgb,                  // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
3581 VM_CL_te_particlecube,                  // #408 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color, float gravityflag, float randomveljitter) te_particlecube (DP_TE_PARTICLECUBE)
3582 VM_CL_te_particlerain,                  // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
3583 VM_CL_te_particlesnow,                  // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
3584 VM_CL_te_spark,                                 // #411 void(vector org, vector vel, float howmany) te_spark (DP_TE_SPARK)
3585 VM_CL_te_gunshotquad,                   // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
3586 VM_CL_te_spikequad,                             // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
3587 VM_CL_te_superspikequad,                // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
3588 VM_CL_te_explosionquad,                 // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
3589 VM_CL_te_smallflash,                    // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
3590 VM_CL_te_customflash,                   // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
3591 VM_CL_te_gunshot,                               // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
3592 VM_CL_te_spike,                                 // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
3593 VM_CL_te_superspike,                    // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
3594 VM_CL_te_explosion,                             // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
3595 VM_CL_te_tarexplosion,                  // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
3596 VM_CL_te_wizspike,                              // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
3597 VM_CL_te_knightspike,                   // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
3598 VM_CL_te_lavasplash,                    // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
3599 VM_CL_te_teleport,                              // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
3600 VM_CL_te_explosion2,                    // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
3601 VM_CL_te_lightning1,                    // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)