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