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 r_refdef_view_t csqc_original_r_refdef_view;
  27 r_refdef_view_t csqc_main_r_refdef_view;
  28
  29 // #1 void(vector ang) makevectors
  30 static void VM_CL_makevectors (prvm_prog_t *prog)
  31 {
  32         vec3_t angles, forward, right, up;
  33         VM_SAFEPARMCOUNT(1, VM_CL_makevectors);
  34         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), angles);
  35         AngleVectors(angles, forward, right, up);
  36         VectorCopy(forward, PRVM_clientglobalvector(v_forward));
  37         VectorCopy(right, PRVM_clientglobalvector(v_right));
  38         VectorCopy(up, PRVM_clientglobalvector(v_up));
  39 }
  40
  41 // #2 void(entity e, vector o) setorigin
  42 static void VM_CL_setorigin (prvm_prog_t *prog)
  43 {
  44         prvm_edict_t    *e;
  45         prvm_vec_t      *org;
  46         VM_SAFEPARMCOUNT(2, VM_CL_setorigin);
  47
  48         e = PRVM_G_EDICT(OFS_PARM0);
  49         if (e == prog->edicts)
  50         {
  51                 VM_Warning(prog, "setorigin: can not modify world entity\n");
  52                 return;
  53         }
  54         if (e->priv.required->free)
  55         {
  56                 VM_Warning(prog, "setorigin: can not modify free entity\n");
  57                 return;
  58         }
  59         org = PRVM_G_VECTOR(OFS_PARM1);
  60         VectorCopy (org, PRVM_clientedictvector(e, origin));
  61         if(e->priv.required->mark == PRVM_EDICT_MARK_WAIT_FOR_SETORIGIN)
  62                 e->priv.required->mark = PRVM_EDICT_MARK_SETORIGIN_CAUGHT;
  63         CL_LinkEdict(e);
  64 }
  65
  66 static void SetMinMaxSizePRVM (prvm_prog_t *prog, prvm_edict_t *e, prvm_vec_t *min, prvm_vec_t *max)
  67 {
  68         int             i;
  69
  70         for (i=0 ; i<3 ; i++)
  71                 if (min[i] > max[i])
  72                         prog->error_cmd("SetMinMaxSize: backwards mins/maxs");
  73
  74         // set derived values
  75         VectorCopy (min, PRVM_clientedictvector(e, mins));
  76         VectorCopy (max, PRVM_clientedictvector(e, maxs));
  77         VectorSubtract (max, min, PRVM_clientedictvector(e, size));
  78
  79         CL_LinkEdict (e);
  80 }
  81
  82 static void SetMinMaxSize (prvm_prog_t *prog, prvm_edict_t *e, const vec_t *min, const vec_t *max)
  83 {
  84         prvm_vec3_t mins, maxs;
  85         VectorCopy(min, mins);
  86         VectorCopy(max, maxs);
  87         SetMinMaxSizePRVM(prog, e, mins, maxs);
  88 }
  89
  90 // #3 void(entity e, string m) setmodel
  91 static void VM_CL_setmodel (prvm_prog_t *prog)
  92 {
  93         prvm_edict_t    *e;
  94         const char              *m;
  95         dp_model_t *mod;
  96         int                             i;
  97
  98         VM_SAFEPARMCOUNT(2, VM_CL_setmodel);
  99
 100         e = PRVM_G_EDICT(OFS_PARM0);
 101         PRVM_clientedictfloat(e, modelindex) = 0;
 102         PRVM_clientedictstring(e, model) = 0;
 103
 104         m = PRVM_G_STRING(OFS_PARM1);
 105         mod = NULL;
 106         for (i = 0;i < MAX_MODELS && cl.csqc_model_precache[i];i++)
 107         {
 108                 if (!strcmp(cl.csqc_model_precache[i]->name, m))
 109                 {
 110                         mod = cl.csqc_model_precache[i];
 111                         PRVM_clientedictstring(e, model) = PRVM_SetEngineString(prog, mod->name);
 112                         PRVM_clientedictfloat(e, modelindex) = -(i+1);
 113                         break;
 114                 }
 115         }
 116
 117         if( !mod ) {
 118                 for (i = 0;i < MAX_MODELS;i++)
 119                 {
 120                         mod = cl.model_precache[i];
 121                         if (mod && !strcmp(mod->name, m))
 122                         {
 123                                 PRVM_clientedictstring(e, model) = PRVM_SetEngineString(prog, mod->name);
 124                                 PRVM_clientedictfloat(e, modelindex) = i;
 125                                 break;
 126                         }
 127                 }
 128         }
 129
 130         if( mod ) {
 131                 // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
 132                 // LordHavoc: erm you broke it by commenting this out - setmodel must do setsize or else the qc can't find out the model size, and ssqc does this by necessity, consistency.
 133                 SetMinMaxSize (prog, e, mod->normalmins, mod->normalmaxs);
 134         }
 135         else
 136         {
 137                 SetMinMaxSize (prog, e, vec3_origin, vec3_origin);
 138                 VM_Warning(prog, "setmodel: model '%s' not precached\n", m);
 139         }
 140 }
 141
 142 // #4 void(entity e, vector min, vector max) setsize
 143 static void VM_CL_setsize (prvm_prog_t *prog)
 144 {
 145         prvm_edict_t    *e;
 146         vec3_t          mins, maxs;
 147         VM_SAFEPARMCOUNT(3, VM_CL_setsize);
 148
 149         e = PRVM_G_EDICT(OFS_PARM0);
 150         if (e == prog->edicts)
 151         {
 152                 VM_Warning(prog, "setsize: can not modify world entity\n");
 153                 return;
 154         }
 155         if (e->priv.server->free)
 156         {
 157                 VM_Warning(prog, "setsize: can not modify free entity\n");
 158                 return;
 159         }
 160         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), mins);
 161         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), maxs);
 162
 163         SetMinMaxSize( prog, e, mins, maxs );
 164
 165         CL_LinkEdict(e);
 166 }
 167
 168 // #8 void(entity e, float chan, string samp, float volume, float atten[, float pitchchange[, float flags]]) sound
 169 static void VM_CL_sound (prvm_prog_t *prog)
 170 {
 171         const char                      *sample;
 172         int                                     channel;
 173         prvm_edict_t            *entity;
 174         float                           fvolume;
 175         float                           attenuation;
 176         float pitchchange;
 177         float                           startposition;
 178         int flags;
 179         vec3_t                          org;
 180
 181         VM_SAFEPARMCOUNTRANGE(5, 7, VM_CL_sound);
 182
 183         entity = PRVM_G_EDICT(OFS_PARM0);
 184         channel = (int)PRVM_G_FLOAT(OFS_PARM1);
 185         sample = PRVM_G_STRING(OFS_PARM2);
 186         fvolume = PRVM_G_FLOAT(OFS_PARM3);
 187         attenuation = PRVM_G_FLOAT(OFS_PARM4);
 188
 189         if (fvolume < 0 || fvolume > 1)
 190         {
 191                 VM_Warning(prog, "VM_CL_sound: volume must be in range 0-1\n");
 192                 return;
 193         }
 194
 195         if (attenuation < 0 || attenuation > 4)
 196         {
 197                 VM_Warning(prog, "VM_CL_sound: attenuation must be in range 0-4\n");
 198                 return;
 199         }
 200
 201         if (prog->argc < 6)
 202                 pitchchange = 0;
 203         else
 204                 pitchchange = PRVM_G_FLOAT(OFS_PARM5);
 205
 206         if (prog->argc < 7)
 207                 flags = 0;
 208         else
 209         {
 210                 // LordHavoc: we only let the qc set certain flags, others are off-limits
 211                 flags = (int)PRVM_G_FLOAT(OFS_PARM6) & (CHANNELFLAG_RELIABLE | CHANNELFLAG_FORCELOOP | CHANNELFLAG_PAUSED | CHANNELFLAG_FULLVOLUME);
 212         }
 213
 214         // sound_starttime exists instead of sound_startposition because in a
 215         // networking sense you might not know when something is being received,
 216         // so making sounds match up in sync would be impossible if relative
 217         // position was sent
 218         if (PRVM_clientglobalfloat(sound_starttime))
 219                 startposition = cl.time - PRVM_clientglobalfloat(sound_starttime);
 220         else
 221                 startposition = 0;
 222
 223         channel = CHAN_USER2ENGINE(channel);
 224
 225         if (!IS_CHAN(channel))
 226         {
 227                 VM_Warning(prog, "VM_CL_sound: channel must be in range 0-127\n");
 228                 return;
 229         }
 230
 231         CL_VM_GetEntitySoundOrigin(MAX_EDICTS + PRVM_NUM_FOR_EDICT(entity), org);
 232         S_StartSound_StartPosition_Flags(MAX_EDICTS + PRVM_NUM_FOR_EDICT(entity), channel, S_FindName(sample), org, fvolume, attenuation, startposition, flags, pitchchange > 0.0f ? pitchchange * 0.01f : 1.0f);
 233 }
 234
 235 // #483 void(vector origin, string sample, float volume, float attenuation) pointsound
 236 static void VM_CL_pointsound(prvm_prog_t *prog)
 237 {
 238         const char                      *sample;
 239         float                           fvolume;
 240         float                           attenuation;
 241         vec3_t                          org;
 242
 243         VM_SAFEPARMCOUNT(4, VM_CL_pointsound);
 244
 245         VectorCopy( PRVM_G_VECTOR(OFS_PARM0), org);
 246         sample = PRVM_G_STRING(OFS_PARM1);
 247         fvolume = PRVM_G_FLOAT(OFS_PARM2);
 248         attenuation = PRVM_G_FLOAT(OFS_PARM3);
 249
 250         if (fvolume < 0 || fvolume > 1)
 251         {
 252                 VM_Warning(prog, "VM_CL_pointsound: volume must be in range 0-1\n");
 253                 return;
 254         }
 255
 256         if (attenuation < 0 || attenuation > 4)
 257         {
 258                 VM_Warning(prog, "VM_CL_pointsound: attenuation must be in range 0-4\n");
 259                 return;
 260         }
 261
 262         // Send World Entity as Entity to Play Sound (for CSQC, that is MAX_EDICTS)
 263         S_StartSound(MAX_EDICTS, 0, S_FindName(sample), org, fvolume, attenuation);
 264 }
 265
 266 // #14 entity() spawn
 267 static void VM_CL_spawn (prvm_prog_t *prog)
 268 {
 269         prvm_edict_t *ed;
 270         ed = PRVM_ED_Alloc(prog);
 271         VM_RETURN_EDICT(ed);
 272 }
 273
 274 static void CL_VM_SetTraceGlobals(prvm_prog_t *prog, const trace_t *trace, int svent)
 275 {
 276         VM_SetTraceGlobals(prog, trace);
 277         PRVM_clientglobalfloat(trace_networkentity) = svent;
 278 }
 279
 280 #define CL_HitNetworkBrushModels(move) !((move) == MOVE_WORLDONLY)
 281 #define CL_HitNetworkPlayers(move)     !((move) == MOVE_WORLDONLY || (move) == MOVE_NOMONSTERS)
 282
 283 // #16 void(vector v1, vector v2, float movetype, entity ignore) traceline
 284 static void VM_CL_traceline (prvm_prog_t *prog)
 285 {
 286         vec3_t  v1, v2;
 287         trace_t trace;
 288         int             move, svent;
 289         prvm_edict_t    *ent;
 290
 291 //      R_TimeReport("pretraceline");
 292
 293         VM_SAFEPARMCOUNTRANGE(4, 4, VM_CL_traceline);
 294
 295         prog->xfunction->builtinsprofile += 30;
 296
 297         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), v1);
 298         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), v2);
 299         move = (int)PRVM_G_FLOAT(OFS_PARM2);
 300         ent = PRVM_G_EDICT(OFS_PARM3);
 301
 302         if (VEC_IS_NAN(v1[0]) || VEC_IS_NAN(v1[1]) || VEC_IS_NAN(v1[2]) || VEC_IS_NAN(v2[0]) || VEC_IS_NAN(v2[1]) || VEC_IS_NAN(v2[2]))
 303                 prog->error_cmd("%s: NAN errors detected in traceline('%f %f %f', '%f %f %f', %i, entity %i)\n", prog->name, v1[0], v1[1], v1[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
 304
 305         trace = CL_TraceLine(v1, v2, move, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendtracelinelength.value, CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true, false);
 306
 307         CL_VM_SetTraceGlobals(prog, &trace, svent);
 308 //      R_TimeReport("traceline");
 309 }
 310
 311 /*
 312 =================
 313 VM_CL_tracebox
 314
 315 Used for use tracing and shot targeting
 316 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
 317 if the tryents flag is set.
 318
 319 tracebox (vector1, vector mins, vector maxs, vector2, tryents)
 320 =================
 321 */
 322 // LordHavoc: added this for my own use, VERY useful, similar to traceline
 323 static void VM_CL_tracebox (prvm_prog_t *prog)
 324 {
 325         vec3_t  v1, v2, m1, m2;
 326         trace_t trace;
 327         int             move, svent;
 328         prvm_edict_t    *ent;
 329
 330 //      R_TimeReport("pretracebox");
 331         VM_SAFEPARMCOUNTRANGE(6, 8, VM_CL_tracebox); // allow more parameters for future expansion
 332
 333         prog->xfunction->builtinsprofile += 30;
 334
 335         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), v1);
 336         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), m1);
 337         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), m2);
 338         VectorCopy(PRVM_G_VECTOR(OFS_PARM3), v2);
 339         move = (int)PRVM_G_FLOAT(OFS_PARM4);
 340         ent = PRVM_G_EDICT(OFS_PARM5);
 341
 342         if (VEC_IS_NAN(v1[0]) || VEC_IS_NAN(v1[1]) || VEC_IS_NAN(v1[2]) || VEC_IS_NAN(v2[0]) || VEC_IS_NAN(v2[1]) || VEC_IS_NAN(v2[2]))
 343                 prog->error_cmd("%s: NAN errors detected in tracebox('%f %f %f', '%f %f %f', '%f %f %f', '%f %f %f', %i, entity %i)\n", prog->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));
 344
 345         trace = CL_TraceBox(v1, m1, m2, v2, move, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendtraceboxlength.value, CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
 346
 347         CL_VM_SetTraceGlobals(prog, &trace, svent);
 348 //      R_TimeReport("tracebox");
 349 }
 350
 351 static trace_t CL_Trace_Toss (prvm_prog_t *prog, prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
 352 {
 353         int i;
 354         float gravity;
 355         vec3_t start, end, mins, maxs, move;
 356         vec3_t original_origin;
 357         vec3_t original_velocity;
 358         vec3_t original_angles;
 359         vec3_t original_avelocity;
 360         trace_t trace;
 361
 362         VectorCopy(PRVM_clientedictvector(tossent, origin)   , original_origin   );
 363         VectorCopy(PRVM_clientedictvector(tossent, velocity) , original_velocity );
 364         VectorCopy(PRVM_clientedictvector(tossent, angles)   , original_angles   );
 365         VectorCopy(PRVM_clientedictvector(tossent, avelocity), original_avelocity);
 366
 367         gravity = PRVM_clientedictfloat(tossent, gravity);
 368         if (!gravity)
 369                 gravity = 1.0f;
 370         gravity *= cl.movevars_gravity * 0.05;
 371
 372         for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
 373         {
 374                 PRVM_clientedictvector(tossent, velocity)[2] -= gravity;
 375                 VectorMA (PRVM_clientedictvector(tossent, angles), 0.05, PRVM_clientedictvector(tossent, avelocity), PRVM_clientedictvector(tossent, angles));
 376                 VectorScale (PRVM_clientedictvector(tossent, velocity), 0.05, move);
 377                 VectorAdd (PRVM_clientedictvector(tossent, origin), move, end);
 378                 VectorCopy(PRVM_clientedictvector(tossent, origin), start);
 379                 VectorCopy(PRVM_clientedictvector(tossent, mins), mins);
 380                 VectorCopy(PRVM_clientedictvector(tossent, maxs), maxs);
 381                 trace = CL_TraceBox(start, mins, maxs, end, MOVE_NORMAL, tossent, CL_GenericHitSuperContentsMask(tossent), 0, 0, collision_extendmovelength.value, true, true, NULL, true);
 382                 VectorCopy (trace.endpos, PRVM_clientedictvector(tossent, origin));
 383
 384                 if (trace.fraction < 1)
 385                         break;
 386         }
 387
 388         VectorCopy(original_origin   , PRVM_clientedictvector(tossent, origin)   );
 389         VectorCopy(original_velocity , PRVM_clientedictvector(tossent, velocity) );
 390         VectorCopy(original_angles   , PRVM_clientedictvector(tossent, angles)   );
 391         VectorCopy(original_avelocity, PRVM_clientedictvector(tossent, avelocity));
 392
 393         return trace;
 394 }
 395
 396 static void VM_CL_tracetoss (prvm_prog_t *prog)
 397 {
 398         trace_t trace;
 399         prvm_edict_t    *ent;
 400         prvm_edict_t    *ignore;
 401         int svent = 0;
 402
 403         prog->xfunction->builtinsprofile += 600;
 404
 405         VM_SAFEPARMCOUNT(2, VM_CL_tracetoss);
 406
 407         ent = PRVM_G_EDICT(OFS_PARM0);
 408         if (ent == prog->edicts)
 409         {
 410                 VM_Warning(prog, "tracetoss: can not use world entity\n");
 411                 return;
 412         }
 413         ignore = PRVM_G_EDICT(OFS_PARM1);
 414
 415         trace = CL_Trace_Toss (prog, ent, ignore, &svent);
 416
 417         CL_VM_SetTraceGlobals(prog, &trace, svent);
 418 }
 419
 420
 421 // #20 void(string s) precache_model
 422 static void VM_CL_precache_model (prvm_prog_t *prog)
 423 {
 424         const char      *name;
 425         int                     i;
 426         dp_model_t              *m;
 427
 428         VM_SAFEPARMCOUNT(1, VM_CL_precache_model);
 429
 430         name = PRVM_G_STRING(OFS_PARM0);
 431         for (i = 0;i < MAX_MODELS && cl.csqc_model_precache[i];i++)
 432         {
 433                 if(!strcmp(cl.csqc_model_precache[i]->name, name))
 434                 {
 435                         PRVM_G_FLOAT(OFS_RETURN) = -(i+1);
 436                         return;
 437                 }
 438         }
 439         PRVM_G_FLOAT(OFS_RETURN) = 0;
 440         m = Mod_ForName(name, false, false, name[0] == '*' ? cl.model_name[1] : NULL);
 441         if(m && m->loaded)
 442         {
 443                 for (i = 0;i < MAX_MODELS;i++)
 444                 {
 445                         if (!cl.csqc_model_precache[i])
 446                         {
 447                                 cl.csqc_model_precache[i] = (dp_model_t*)m;
 448                                 PRVM_G_FLOAT(OFS_RETURN) = -(i+1);
 449                                 return;
 450                         }
 451                 }
 452                 VM_Warning(prog, "VM_CL_precache_model: no free models\n");
 453                 return;
 454         }
 455         VM_Warning(prog, "VM_CL_precache_model: model \"%s\" not found\n", name);
 456 }
 457
 458 // #22 entity(vector org, float rad) findradius
 459 static void VM_CL_findradius (prvm_prog_t *prog)
 460 {
 461         prvm_edict_t    *ent, *chain;
 462         vec_t                   radius, radius2;
 463         vec3_t                  org, eorg, mins, maxs;
 464         int                             i, numtouchedicts;
 465         static prvm_edict_t     *touchedicts[MAX_EDICTS];
 466         int             chainfield;
 467
 468         VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_findradius);
 469
 470         if(prog->argc == 3)
 471                 chainfield = PRVM_G_INT(OFS_PARM2);
 472         else
 473                 chainfield = prog->fieldoffsets.chain;
 474         if(chainfield < 0)
 475                 prog->error_cmd("VM_findchain: %s doesnt have the specified chain field !", prog->name);
 476
 477         chain = (prvm_edict_t *)prog->edicts;
 478
 479         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
 480         radius = PRVM_G_FLOAT(OFS_PARM1);
 481         radius2 = radius * radius;
 482
 483         mins[0] = org[0] - (radius + 1);
 484         mins[1] = org[1] - (radius + 1);
 485         mins[2] = org[2] - (radius + 1);
 486         maxs[0] = org[0] + (radius + 1);
 487         maxs[1] = org[1] + (radius + 1);
 488         maxs[2] = org[2] + (radius + 1);
 489         numtouchedicts = World_EntitiesInBox(&cl.world, mins, maxs, MAX_EDICTS, touchedicts);
 490         if (numtouchedicts > MAX_EDICTS)
 491         {
 492                 // this never happens   //[515]: for what then ?
 493                 Con_Printf("CSQC_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
 494                 numtouchedicts = MAX_EDICTS;
 495         }
 496         for (i = 0;i < numtouchedicts;i++)
 497         {
 498                 ent = touchedicts[i];
 499                 // Quake did not return non-solid entities but darkplaces does
 500                 // (note: this is the reason you can't blow up fallen zombies)
 501                 if (PRVM_clientedictfloat(ent, solid) == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
 502                         continue;
 503                 // LordHavoc: compare against bounding box rather than center so it
 504                 // doesn't miss large objects, and use DotProduct instead of Length
 505                 // for a major speedup
 506                 VectorSubtract(org, PRVM_clientedictvector(ent, origin), eorg);
 507                 if (sv_gameplayfix_findradiusdistancetobox.integer)
 508                 {
 509                         eorg[0] -= bound(PRVM_clientedictvector(ent, mins)[0], eorg[0], PRVM_clientedictvector(ent, maxs)[0]);
 510                         eorg[1] -= bound(PRVM_clientedictvector(ent, mins)[1], eorg[1], PRVM_clientedictvector(ent, maxs)[1]);
 511                         eorg[2] -= bound(PRVM_clientedictvector(ent, mins)[2], eorg[2], PRVM_clientedictvector(ent, maxs)[2]);
 512                 }
 513                 else
 514                         VectorMAMAM(1, eorg, -0.5f, PRVM_clientedictvector(ent, mins), -0.5f, PRVM_clientedictvector(ent, maxs), eorg);
 515                 if (DotProduct(eorg, eorg) < radius2)
 516                 {
 517                         PRVM_EDICTFIELDEDICT(ent, chainfield) = PRVM_EDICT_TO_PROG(chain);
 518                         chain = ent;
 519                 }
 520         }
 521
 522         VM_RETURN_EDICT(chain);
 523 }
 524
 525 // #34 float() droptofloor
 526 static void VM_CL_droptofloor (prvm_prog_t *prog)
 527 {
 528         prvm_edict_t            *ent;
 529         vec3_t                          start, end, mins, maxs;
 530         trace_t                         trace;
 531
 532         VM_SAFEPARMCOUNTRANGE(0, 2, VM_CL_droptofloor); // allow 2 parameters because the id1 defs.qc had an incorrect prototype
 533
 534         // assume failure if it returns early
 535         PRVM_G_FLOAT(OFS_RETURN) = 0;
 536
 537         ent = PRVM_PROG_TO_EDICT(PRVM_clientglobaledict(self));
 538         if (ent == prog->edicts)
 539         {
 540                 VM_Warning(prog, "droptofloor: can not modify world entity\n");
 541                 return;
 542         }
 543         if (ent->priv.server->free)
 544         {
 545                 VM_Warning(prog, "droptofloor: can not modify free entity\n");
 546                 return;
 547         }
 548
 549         VectorCopy(PRVM_clientedictvector(ent, origin), start);
 550         VectorCopy(PRVM_clientedictvector(ent, mins), mins);
 551         VectorCopy(PRVM_clientedictvector(ent, maxs), maxs);
 552         VectorCopy(PRVM_clientedictvector(ent, origin), end);
 553         end[2] -= 256;
 554
 555         trace = CL_TraceBox(start, mins, maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, true, true, NULL, true);
 556
 557         if (trace.fraction != 1)
 558         {
 559                 VectorCopy (trace.endpos, PRVM_clientedictvector(ent, origin));
 560                 PRVM_clientedictfloat(ent, flags) = (int)PRVM_clientedictfloat(ent, flags) | FL_ONGROUND;
 561                 PRVM_clientedictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
 562                 PRVM_G_FLOAT(OFS_RETURN) = 1;
 563                 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
 564 //              ent->priv.server->suspendedinairflag = true;
 565         }
 566 }
 567
 568 // #35 void(float style, string value) lightstyle
 569 static void VM_CL_lightstyle (prvm_prog_t *prog)
 570 {
 571         int                     i;
 572         const char      *c;
 573
 574         VM_SAFEPARMCOUNT(2, VM_CL_lightstyle);
 575
 576         i = (int)PRVM_G_FLOAT(OFS_PARM0);
 577         c = PRVM_G_STRING(OFS_PARM1);
 578         if (i >= cl.max_lightstyle)
 579         {
 580                 VM_Warning(prog, "VM_CL_lightstyle >= MAX_LIGHTSTYLES\n");
 581                 return;
 582         }
 583         strlcpy (cl.lightstyle[i].map, c, sizeof (cl.lightstyle[i].map));
 584         cl.lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
 585         cl.lightstyle[i].length = (int)strlen(cl.lightstyle[i].map);
 586 }
 587
 588 // #40 float(entity e) checkbottom
 589 static void VM_CL_checkbottom (prvm_prog_t *prog)
 590 {
 591         static int              cs_yes, cs_no;
 592         prvm_edict_t    *ent;
 593         vec3_t                  mins, maxs, start, stop;
 594         trace_t                 trace;
 595         int                             x, y;
 596         float                   mid, bottom;
 597
 598         VM_SAFEPARMCOUNT(1, VM_CL_checkbottom);
 599         ent = PRVM_G_EDICT(OFS_PARM0);
 600         PRVM_G_FLOAT(OFS_RETURN) = 0;
 601
 602         VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), mins);
 603         VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, maxs), maxs);
 604
 605 // if all of the points under the corners are solid world, don't bother
 606 // with the tougher checks
 607 // the corners must be within 16 of the midpoint
 608         start[2] = mins[2] - 1;
 609         for     (x=0 ; x<=1 ; x++)
 610                 for     (y=0 ; y<=1 ; y++)
 611                 {
 612                         start[0] = x ? maxs[0] : mins[0];
 613                         start[1] = y ? maxs[1] : mins[1];
 614                         if (!(CL_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
 615                                 goto realcheck;
 616                 }
 617
 618         cs_yes++;
 619         PRVM_G_FLOAT(OFS_RETURN) = true;
 620         return;         // we got out easy
 621
 622 realcheck:
 623         cs_no++;
 624 //
 625 // check it for real...
 626 //
 627         start[2] = mins[2];
 628
 629 // the midpoint must be within 16 of the bottom
 630         start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
 631         start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
 632         stop[2] = start[2] - 2*sv_stepheight.value;
 633         trace = CL_TraceLine(start, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, true, true, NULL, true, false);
 634
 635         if (trace.fraction == 1.0)
 636                 return;
 637
 638         mid = bottom = trace.endpos[2];
 639
 640 // the corners must be within 16 of the midpoint
 641         for     (x=0 ; x<=1 ; x++)
 642                 for     (y=0 ; y<=1 ; y++)
 643                 {
 644                         start[0] = stop[0] = x ? maxs[0] : mins[0];
 645                         start[1] = stop[1] = y ? maxs[1] : mins[1];
 646
 647                         trace = CL_TraceLine(start, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, true, true, NULL, true, false);
 648
 649                         if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
 650                                 bottom = trace.endpos[2];
 651                         if (trace.fraction == 1.0 || mid - trace.endpos[2] > sv_stepheight.value)
 652                                 return;
 653                 }
 654
 655         cs_yes++;
 656         PRVM_G_FLOAT(OFS_RETURN) = true;
 657 }
 658
 659 // #41 float(vector v) pointcontents
 660 static void VM_CL_pointcontents (prvm_prog_t *prog)
 661 {
 662         vec3_t point;
 663         VM_SAFEPARMCOUNT(1, VM_CL_pointcontents);
 664         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), point);
 665         PRVM_G_FLOAT(OFS_RETURN) = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, CL_PointSuperContents(point));
 666 }
 667
 668 // #48 void(vector o, vector d, float color, float count) particle
 669 static void VM_CL_particle (prvm_prog_t *prog)
 670 {
 671         vec3_t org, dir;
 672         int             count;
 673         unsigned char   color;
 674         VM_SAFEPARMCOUNT(4, VM_CL_particle);
 675
 676         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
 677         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), dir);
 678         color = (int)PRVM_G_FLOAT(OFS_PARM2);
 679         count = (int)PRVM_G_FLOAT(OFS_PARM3);
 680         CL_ParticleEffect(EFFECT_SVC_PARTICLE, count, org, org, dir, dir, NULL, color);
 681 }
 682
 683 // #74 void(vector pos, string samp, float vol, float atten) ambientsound
 684 static void VM_CL_ambientsound (prvm_prog_t *prog)
 685 {
 686         vec3_t f;
 687         sfx_t   *s;
 688         VM_SAFEPARMCOUNT(4, VM_CL_ambientsound);
 689         s = S_FindName(PRVM_G_STRING(OFS_PARM0));
 690         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f);
 691         S_StaticSound (s, f, PRVM_G_FLOAT(OFS_PARM2), PRVM_G_FLOAT(OFS_PARM3)*64);
 692 }
 693
 694 // #92 vector(vector org[, float lpflag]) getlight (DP_QC_GETLIGHT)
 695 static void VM_CL_getlight (prvm_prog_t *prog)
 696 {
 697         vec3_t ambientcolor, diffusecolor, diffusenormal;
 698         vec3_t p;
 699         int flags = prog->argc >= 2 ? PRVM_G_FLOAT(OFS_PARM1) : LP_LIGHTMAP;
 700
 701         VM_SAFEPARMCOUNTRANGE(1, 3, VM_CL_getlight);
 702
 703         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), p);
 704         R_CompleteLightPoint(ambientcolor, diffusecolor, diffusenormal, p, flags, r_refdef.scene.lightmapintensity, r_refdef.scene.ambientintensity);
 705         VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
 706         if (PRVM_clientglobalvector(getlight_ambient))
 707                 VectorCopy(ambientcolor, PRVM_clientglobalvector(getlight_ambient));
 708         if (PRVM_clientglobalvector(getlight_diffuse))
 709                 VectorCopy(diffusecolor, PRVM_clientglobalvector(getlight_diffuse));
 710         if (PRVM_clientglobalvector(getlight_dir))
 711                 VectorCopy(diffusenormal, PRVM_clientglobalvector(getlight_dir));
 712 }
 713
 714 //============================================================================
 715 //[515]: SCENE MANAGER builtins
 716
 717 extern cvar_t v_yshearing;
 718 void CSQC_R_RecalcView (void)
 719 {
 720         extern matrix4x4_t viewmodelmatrix_nobob;
 721         extern matrix4x4_t viewmodelmatrix_withbob;
 722         Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, cl.csqc_vieworigin[0], cl.csqc_vieworigin[1], cl.csqc_vieworigin[2], cl.csqc_viewangles[0], cl.csqc_viewangles[1], cl.csqc_viewangles[2], 1);
 723         if (v_yshearing.value > 0)
 724                 Matrix4x4_QuakeToDuke3D(&r_refdef.view.matrix, &r_refdef.view.matrix, v_yshearing.value);
 725         Matrix4x4_Copy(&viewmodelmatrix_nobob, &r_refdef.view.matrix);
 726         Matrix4x4_ConcatScale(&viewmodelmatrix_nobob, cl_viewmodel_scale.value);
 727         Matrix4x4_Concat(&viewmodelmatrix_withbob, &r_refdef.view.matrix, &cl.csqc_viewmodelmatrixfromengine);
 728 }
 729
 730 //#300 void() clearscene (EXT_CSQC)
 731 static void VM_CL_R_ClearScene (prvm_prog_t *prog)
 732 {
 733         VM_SAFEPARMCOUNT(0, VM_CL_R_ClearScene);
 734         // clear renderable entity and light lists
 735         r_refdef.scene.numentities = 0;
 736         r_refdef.scene.numlights = 0;
 737         // restore the view settings to the values that VM_CL_UpdateView received from the client code
 738         r_refdef.view = csqc_original_r_refdef_view;
 739         VectorCopy(cl.csqc_vieworiginfromengine, cl.csqc_vieworigin);
 740         VectorCopy(cl.csqc_viewanglesfromengine, cl.csqc_viewangles);
 741         cl.csqc_vidvars.drawworld = r_drawworld.integer != 0;
 742         cl.csqc_vidvars.drawenginesbar = false;
 743         cl.csqc_vidvars.drawcrosshair = false;
 744         CSQC_R_RecalcView();
 745 }
 746
 747 //#301 void(float mask) addentities (EXT_CSQC)
 748 static void VM_CL_R_AddEntities (prvm_prog_t *prog)
 749 {
 750         double t = Sys_DirtyTime();
 751         int                     i, drawmask;
 752         prvm_edict_t *ed;
 753         VM_SAFEPARMCOUNT(1, VM_CL_R_AddEntities);
 754         drawmask = (int)PRVM_G_FLOAT(OFS_PARM0);
 755         CSQC_RelinkAllEntities(drawmask);
 756
 757         PRVM_clientglobalfloat(time) = cl.time;
 758         for(i=1;i<prog->num_edicts;i++)
 759         {
 760                 // so we can easily check if CSQC entity #edictnum is currently drawn
 761                 cl.csqcrenderentities[i].entitynumber = 0;
 762                 ed = &prog->edicts[i];
 763                 if(ed->priv.required->free)
 764                         continue;
 765                 CSQC_Think(ed);
 766                 if(ed->priv.required->free)
 767                         continue;
 768                 // note that for RF_USEAXIS entities, Predraw sets v_forward/v_right/v_up globals that are read by CSQC_AddRenderEdict
 769                 CSQC_Predraw(ed);
 770                 if(ed->priv.required->free)
 771                         continue;
 772                 if(!((int)PRVM_clientedictfloat(ed, drawmask) & drawmask))
 773                         continue;
 774                 CSQC_AddRenderEdict(ed, i);
 775         }
 776
 777         // callprofile fixing hack: do not include this time in what is counted for CSQC_UpdateView
 778         t = Sys_DirtyTime() - t;if (t < 0 || t >= 1800) t = 0;
 779         prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= t;
 780 }
 781
 782 //#302 void(entity ent) addentity (EXT_CSQC)
 783 static void VM_CL_R_AddEntity (prvm_prog_t *prog)
 784 {
 785         double t = Sys_DirtyTime();
 786         VM_SAFEPARMCOUNT(1, VM_CL_R_AddEntity);
 787         CSQC_AddRenderEdict(PRVM_G_EDICT(OFS_PARM0), 0);
 788         t = Sys_DirtyTime() - t;if (t < 0 || t >= 1800) t = 0;
 789         prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= t;
 790 }
 791
 792 //#303 float(float property, ...) setproperty (EXT_CSQC)
 793 //#303 float(float property) getproperty
 794 //#303 vector(float property) getpropertyvec
 795 //#309 float(float property) getproperty
 796 //#309 vector(float property) getpropertyvec
 797 // VorteX: make this function be able to return previously set property if new value is not given
 798 static void VM_CL_R_SetView (prvm_prog_t *prog)
 799 {
 800         int             c;
 801         prvm_vec_t      *f;
 802         float   k;
 803
 804         VM_SAFEPARMCOUNTRANGE(1, 3, VM_CL_R_SetView);
 805
 806         c = (int)PRVM_G_FLOAT(OFS_PARM0);
 807
 808         // return value?
 809         if (prog->argc < 2)
 810         {
 811                 switch(c)
 812                 {
 813                 case VF_MIN:
 814                         VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.x, r_refdef.view.y, 0);
 815                         break;
 816                 case VF_MIN_X:
 817                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.x;
 818                         break;
 819                 case VF_MIN_Y:
 820                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.y;
 821                         break;
 822                 case VF_SIZE:
 823                         VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.width, r_refdef.view.height, 0);
 824                         break;
 825                 case VF_SIZE_X:
 826                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.width;
 827                         break;
 828                 case VF_SIZE_Y:
 829                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.height;
 830                         break;
 831                 case VF_VIEWPORT:
 832                         VM_Warning(prog, "VM_CL_R_GetView : VF_VIEWPORT can't be retrieved, use VF_MIN/VF_SIZE instead\n");
 833                         break;
 834                 case VF_FOV:
 835                         VectorSet(PRVM_G_VECTOR(OFS_RETURN), r_refdef.view.ortho_x, r_refdef.view.ortho_y, 0);
 836                         break;
 837                 case VF_FOVX:
 838                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.ortho_x;
 839                         break;
 840                 case VF_FOVY:
 841                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.ortho_y;
 842                         break;
 843                 case VF_ORIGIN:
 844                         VectorCopy(cl.csqc_vieworigin, PRVM_G_VECTOR(OFS_RETURN));
 845                         break;
 846                 case VF_ORIGIN_X:
 847                         PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vieworigin[0];
 848                         break;
 849                 case VF_ORIGIN_Y:
 850                         PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vieworigin[1];
 851                         break;
 852                 case VF_ORIGIN_Z:
 853                         PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vieworigin[2];
 854                         break;
 855                 case VF_ANGLES:
 856                         VectorCopy(cl.csqc_viewangles, PRVM_G_VECTOR(OFS_RETURN));
 857                         break;
 858                 case VF_ANGLES_X:
 859                         PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_viewangles[0];
 860                         break;
 861                 case VF_ANGLES_Y:
 862                         PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_viewangles[1];
 863                         break;
 864                 case VF_ANGLES_Z:
 865                         PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_viewangles[2];
 866                         break;
 867                 case VF_DRAWWORLD:
 868                         PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vidvars.drawworld;
 869                         break;
 870                 case VF_DRAWENGINESBAR:
 871                         PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vidvars.drawenginesbar;
 872                         break;
 873                 case VF_DRAWCROSSHAIR:
 874                         PRVM_G_FLOAT(OFS_RETURN) = cl.csqc_vidvars.drawcrosshair;
 875                         break;
 876                 case VF_CL_VIEWANGLES:
 877                         VectorCopy(cl.viewangles, PRVM_G_VECTOR(OFS_RETURN));;
 878                         break;
 879                 case VF_CL_VIEWANGLES_X:
 880                         PRVM_G_FLOAT(OFS_RETURN) = cl.viewangles[0];
 881                         break;
 882                 case VF_CL_VIEWANGLES_Y:
 883                         PRVM_G_FLOAT(OFS_RETURN) = cl.viewangles[1];
 884                         break;
 885                 case VF_CL_VIEWANGLES_Z:
 886                         PRVM_G_FLOAT(OFS_RETURN) = cl.viewangles[2];
 887                         break;
 888                 case VF_PERSPECTIVE:
 889                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.useperspective;
 890                         break;
 891                 case VF_CLEARSCREEN:
 892                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.isoverlay;
 893                         break;
 894                 case VF_MAINVIEW:
 895                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.ismain;
 896                         break;
 897                 case VF_FOG_DENSITY:
 898                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.fog_density;
 899                         break;
 900                 case VF_FOG_COLOR:
 901                         PRVM_G_VECTOR(OFS_RETURN)[0] = r_refdef.fog_red;
 902                         PRVM_G_VECTOR(OFS_RETURN)[1] = r_refdef.fog_green;
 903                         PRVM_G_VECTOR(OFS_RETURN)[2] = r_refdef.fog_blue;
 904                         break;
 905                 case VF_FOG_COLOR_R:
 906                         PRVM_G_VECTOR(OFS_RETURN)[0] = r_refdef.fog_red;
 907                         break;
 908                 case VF_FOG_COLOR_G:
 909                         PRVM_G_VECTOR(OFS_RETURN)[1] = r_refdef.fog_green;
 910                         break;
 911                 case VF_FOG_COLOR_B:
 912                         PRVM_G_VECTOR(OFS_RETURN)[2] = r_refdef.fog_blue;
 913                         break;
 914                 case VF_FOG_ALPHA:
 915                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.fog_alpha;
 916                         break;
 917                 case VF_FOG_START:
 918                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.fog_start;
 919                         break;
 920                 case VF_FOG_END:
 921                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.fog_end;
 922                         break;
 923                 case VF_FOG_HEIGHT:
 924                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.fog_height;
 925                         break;
 926                 case VF_FOG_FADEDEPTH:
 927                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.fog_fadedepth;
 928                         break;
 929                 case VF_MINFPS_QUALITY:
 930                         PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.quality;
 931                         break;
 932                 default:
 933                         PRVM_G_FLOAT(OFS_RETURN) = 0;
 934                         VM_Warning(prog, "VM_CL_R_GetView : unknown parm %i\n", c);
 935                         return;
 936                 }
 937                 return;
 938         }
 939
 940         f = PRVM_G_VECTOR(OFS_PARM1);
 941         k = PRVM_G_FLOAT(OFS_PARM1);
 942         switch(c)
 943         {
 944         case VF_MIN:
 945                 r_refdef.view.x = (int)(f[0]);
 946                 r_refdef.view.y = (int)(f[1]);
 947                 DrawQ_RecalcView();
 948                 break;
 949         case VF_MIN_X:
 950                 r_refdef.view.x = (int)(k);
 951                 DrawQ_RecalcView();
 952                 break;
 953         case VF_MIN_Y:
 954                 r_refdef.view.y = (int)(k);
 955                 DrawQ_RecalcView();
 956                 break;
 957         case VF_SIZE:
 958                 r_refdef.view.width = (int)(f[0]);
 959                 r_refdef.view.height = (int)(f[1]);
 960                 DrawQ_RecalcView();
 961                 break;
 962         case VF_SIZE_X:
 963                 r_refdef.view.width = (int)(k);
 964                 DrawQ_RecalcView();
 965                 break;
 966         case VF_SIZE_Y:
 967                 r_refdef.view.height = (int)(k);
 968                 DrawQ_RecalcView();
 969                 break;
 970         case VF_VIEWPORT:
 971                 r_refdef.view.x = (int)(f[0]);
 972                 r_refdef.view.y = (int)(f[1]);
 973                 f = PRVM_G_VECTOR(OFS_PARM2);
 974                 r_refdef.view.width = (int)(f[0]);
 975                 r_refdef.view.height = (int)(f[1]);
 976                 DrawQ_RecalcView();
 977                 break;
 978         case VF_FOV:
 979                 r_refdef.view.frustum_x = tan(f[0] * M_PI / 360.0);r_refdef.view.ortho_x = f[0];
 980                 r_refdef.view.frustum_y = tan(f[1] * M_PI / 360.0);r_refdef.view.ortho_y = f[1];
 981                 break;
 982         case VF_FOVX:
 983                 r_refdef.view.frustum_x = tan(k * M_PI / 360.0);r_refdef.view.ortho_x = k;
 984                 break;
 985         case VF_FOVY:
 986                 r_refdef.view.frustum_y = tan(k * M_PI / 360.0);r_refdef.view.ortho_y = k;
 987                 break;
 988         case VF_ORIGIN:
 989                 VectorCopy(f, cl.csqc_vieworigin);
 990                 CSQC_R_RecalcView();
 991                 break;
 992         case VF_ORIGIN_X:
 993                 cl.csqc_vieworigin[0] = k;
 994                 CSQC_R_RecalcView();
 995                 break;
 996         case VF_ORIGIN_Y:
 997                 cl.csqc_vieworigin[1] = k;
 998                 CSQC_R_RecalcView();
 999                 break;
1000         case VF_ORIGIN_Z:
1001                 cl.csqc_vieworigin[2] = k;
1002                 CSQC_R_RecalcView();
1003                 break;
1004         case VF_ANGLES:
1005                 VectorCopy(f, cl.csqc_viewangles);
1006                 CSQC_R_RecalcView();
1007                 break;
1008         case VF_ANGLES_X:
1009                 cl.csqc_viewangles[0] = k;
1010                 CSQC_R_RecalcView();
1011                 break;
1012         case VF_ANGLES_Y:
1013                 cl.csqc_viewangles[1] = k;
1014                 CSQC_R_RecalcView();
1015                 break;
1016         case VF_ANGLES_Z:
1017                 cl.csqc_viewangles[2] = k;
1018                 CSQC_R_RecalcView();
1019                 break;
1020         case VF_DRAWWORLD:
1021                 cl.csqc_vidvars.drawworld = ((k != 0) && r_drawworld.integer);
1022                 break;
1023         case VF_DRAWENGINESBAR:
1024                 cl.csqc_vidvars.drawenginesbar = k != 0;
1025                 break;
1026         case VF_DRAWCROSSHAIR:
1027                 cl.csqc_vidvars.drawcrosshair = k != 0;
1028                 break;
1029         case VF_CL_VIEWANGLES:
1030                 VectorCopy(f, cl.viewangles);
1031                 break;
1032         case VF_CL_VIEWANGLES_X:
1033                 cl.viewangles[0] = k;
1034                 break;
1035         case VF_CL_VIEWANGLES_Y:
1036                 cl.viewangles[1] = k;
1037                 break;
1038         case VF_CL_VIEWANGLES_Z:
1039                 cl.viewangles[2] = k;
1040                 break;
1041         case VF_PERSPECTIVE:
1042                 r_refdef.view.useperspective = k != 0;
1043                 break;
1044         case VF_CLEARSCREEN:
1045                 r_refdef.view.isoverlay = !k;
1046                 break;
1047         case VF_MAINVIEW:
1048                 PRVM_G_FLOAT(OFS_RETURN) = r_refdef.view.ismain;
1049                 break;
1050         case VF_FOG_DENSITY:
1051                 r_refdef.fog_density = k;
1052                 break;
1053         case VF_FOG_COLOR:
1054                 r_refdef.fog_red = f[0];
1055                 r_refdef.fog_green = f[1];
1056                 r_refdef.fog_blue = f[2];
1057                 break;
1058         case VF_FOG_COLOR_R:
1059                 r_refdef.fog_red = k;
1060                 break;
1061         case VF_FOG_COLOR_G:
1062                 r_refdef.fog_green = k;
1063                 break;
1064         case VF_FOG_COLOR_B:
1065                 r_refdef.fog_blue = k;
1066                 break;
1067         case VF_FOG_ALPHA:
1068                 r_refdef.fog_alpha = k;
1069                 break;
1070         case VF_FOG_START:
1071                 r_refdef.fog_start = k;
1072                 break;
1073         case VF_FOG_END:
1074                 r_refdef.fog_end = k;
1075                 break;
1076         case VF_FOG_HEIGHT:
1077                 r_refdef.fog_height = k;
1078                 break;
1079         case VF_FOG_FADEDEPTH:
1080                 r_refdef.fog_fadedepth = k;
1081                 break;
1082         case VF_MINFPS_QUALITY:
1083                 r_refdef.view.quality = k;
1084                 break;
1085         default:
1086                 PRVM_G_FLOAT(OFS_RETURN) = 0;
1087                 VM_Warning(prog, "VM_CL_R_SetView : unknown parm %i\n", c);
1088                 return;
1089         }
1090         PRVM_G_FLOAT(OFS_RETURN) = 1;
1091 }
1092
1093 //#305 void(vector org, float radius, vector lightcolours[, float style, string cubemapname, float pflags]) adddynamiclight (EXT_CSQC)
1094 static void VM_CL_R_AddDynamicLight (prvm_prog_t *prog)
1095 {
1096         double t = Sys_DirtyTime();
1097         vec3_t org;
1098         float radius = 300;
1099         vec3_t col;
1100         int style = -1;
1101         const char *cubemapname = NULL;
1102         int pflags = PFLAGS_CORONA | PFLAGS_FULLDYNAMIC;
1103         float coronaintensity = 1;
1104         float coronasizescale = 0.25;
1105         qboolean castshadow = true;
1106         float ambientscale = 0;
1107         float diffusescale = 1;
1108         float specularscale = 1;
1109         matrix4x4_t matrix;
1110         vec3_t forward, left, up;
1111         VM_SAFEPARMCOUNTRANGE(3, 8, VM_CL_R_AddDynamicLight);
1112
1113         // if we've run out of dlights, just return
1114         if (r_refdef.scene.numlights >= MAX_DLIGHTS)
1115                 return;
1116
1117         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
1118         radius = PRVM_G_FLOAT(OFS_PARM1);
1119         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), col);
1120         if (prog->argc >= 4)
1121         {
1122                 style = (int)PRVM_G_FLOAT(OFS_PARM3);
1123                 if (style >= MAX_LIGHTSTYLES)
1124                 {
1125                         Con_DPrintf("VM_CL_R_AddDynamicLight: out of bounds lightstyle index %i\n", style);
1126                         style = -1;
1127                 }
1128         }
1129         if (prog->argc >= 5)
1130                 cubemapname = PRVM_G_STRING(OFS_PARM4);
1131         if (prog->argc >= 6)
1132                 pflags = (int)PRVM_G_FLOAT(OFS_PARM5);
1133         coronaintensity = (pflags & PFLAGS_CORONA) != 0;
1134         castshadow = (pflags & PFLAGS_NOSHADOW) == 0;
1135
1136         VectorScale(PRVM_clientglobalvector(v_forward), radius, forward);
1137         VectorScale(PRVM_clientglobalvector(v_right), -radius, left);
1138         VectorScale(PRVM_clientglobalvector(v_up), radius, up);
1139         Matrix4x4_FromVectors(&matrix, forward, left, up, org);
1140
1141         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);
1142         r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights];r_refdef.scene.numlights++;
1143         t = Sys_DirtyTime() - t;if (t < 0 || t >= 1800) t = 0;
1144         prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= t;
1145 }
1146
1147 //============================================================================
1148
1149 //#310 vector (vector v) cs_unproject (EXT_CSQC)
1150 static void VM_CL_unproject (prvm_prog_t *prog)
1151 {
1152         vec3_t f;
1153         vec3_t temp;
1154         vec3_t result;
1155
1156         VM_SAFEPARMCOUNT(1, VM_CL_unproject);
1157         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), f);
1158         VectorSet(temp,
1159                 f[2],
1160                 (-1.0 + 2.0 * (f[0] / vid_conwidth.integer)) * f[2] * -r_refdef.view.frustum_x,
1161                 (-1.0 + 2.0 * (f[1] / vid_conheight.integer)) * f[2] * -r_refdef.view.frustum_y);
1162         if(v_flipped.integer)
1163                 temp[1] = -temp[1];
1164         Matrix4x4_Transform(&r_refdef.view.matrix, temp, result);
1165         VectorCopy(result, PRVM_G_VECTOR(OFS_RETURN));
1166 }
1167
1168 //#311 vector (vector v) cs_project (EXT_CSQC)
1169 static void VM_CL_project (prvm_prog_t *prog)
1170 {
1171         vec3_t f;
1172         vec3_t v;
1173         matrix4x4_t m;
1174
1175         VM_SAFEPARMCOUNT(1, VM_CL_project);
1176         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), f);
1177         Matrix4x4_Invert_Full(&m, &r_refdef.view.matrix);
1178         Matrix4x4_Transform(&m, f, v);
1179         if(v_flipped.integer)
1180                 v[1] = -v[1];
1181         VectorSet(PRVM_G_VECTOR(OFS_RETURN),
1182                 vid_conwidth.integer * (0.5*(1.0+v[1]/v[0]/-r_refdef.view.frustum_x)),
1183                 vid_conheight.integer * (0.5*(1.0+v[2]/v[0]/-r_refdef.view.frustum_y)),
1184                 v[0]);
1185         // explanation:
1186         // after transforming, relative position to viewport (0..1) = 0.5 * (1 + v[2]/v[0]/-frustum_{x \or y})
1187         // as 2D drawing honors the viewport too, to get the same pixel, we simply multiply this by conwidth/height
1188 }
1189
1190 //#330 float(float stnum) getstatf (EXT_CSQC)
1191 static void VM_CL_getstatf (prvm_prog_t *prog)
1192 {
1193         int i;
1194         union
1195         {
1196                 float f;
1197                 int l;
1198         }dat;
1199         VM_SAFEPARMCOUNT(1, VM_CL_getstatf);
1200         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1201         if(i < 0 || i >= MAX_CL_STATS)
1202         {
1203                 VM_Warning(prog, "VM_CL_getstatf: index>=MAX_CL_STATS or index<0\n");
1204                 return;
1205         }
1206         dat.l = cl.stats[i];
1207         PRVM_G_FLOAT(OFS_RETURN) =  dat.f;
1208 }
1209
1210 //#331 float(float stnum) getstati (EXT_CSQC)
1211 static void VM_CL_getstati (prvm_prog_t *prog)
1212 {
1213         int i, index;
1214         int firstbit, bitcount;
1215
1216         VM_SAFEPARMCOUNTRANGE(1, 3, VM_CL_getstati);
1217
1218         index = (int)PRVM_G_FLOAT(OFS_PARM0);
1219         if (prog->argc > 1)
1220         {
1221                 firstbit = (int)PRVM_G_FLOAT(OFS_PARM1);
1222                 if (prog->argc > 2)
1223                         bitcount = (int)PRVM_G_FLOAT(OFS_PARM2);
1224                 else
1225                         bitcount = 1;
1226         }
1227         else
1228         {
1229                 firstbit = 0;
1230                 bitcount = 32;
1231         }
1232
1233         if(index < 0 || index >= MAX_CL_STATS)
1234         {
1235                 VM_Warning(prog, "VM_CL_getstati: index>=MAX_CL_STATS or index<0\n");
1236                 return;
1237         }
1238         i = cl.stats[index];
1239         if (bitcount != 32)     //32 causes the mask to overflow, so there's nothing to subtract from.
1240                 i = (((unsigned int)i)&(((1<<bitcount)-1)<<firstbit))>>firstbit;
1241         PRVM_G_FLOAT(OFS_RETURN) = i;
1242 }
1243
1244 //#332 string(float firststnum) getstats (EXT_CSQC)
1245 static void VM_CL_getstats (prvm_prog_t *prog)
1246 {
1247         int i;
1248         char t[17];
1249         VM_SAFEPARMCOUNT(1, VM_CL_getstats);
1250         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1251         if(i < 0 || i > MAX_CL_STATS-4)
1252         {
1253                 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1254                 VM_Warning(prog, "VM_CL_getstats: index>MAX_CL_STATS-4 or index<0\n");
1255                 return;
1256         }
1257         strlcpy(t, (char*)&cl.stats[i], sizeof(t));
1258         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, t);
1259 }
1260
1261 //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
1262 static void VM_CL_setmodelindex (prvm_prog_t *prog)
1263 {
1264         int                             i;
1265         prvm_edict_t    *t;
1266         struct model_s  *model;
1267
1268         VM_SAFEPARMCOUNT(2, VM_CL_setmodelindex);
1269
1270         t = PRVM_G_EDICT(OFS_PARM0);
1271
1272         i = (int)PRVM_G_FLOAT(OFS_PARM1);
1273
1274         PRVM_clientedictstring(t, model) = 0;
1275         PRVM_clientedictfloat(t, modelindex) = 0;
1276
1277         if (!i)
1278                 return;
1279
1280         model = CL_GetModelByIndex(i);
1281         if (!model)
1282         {
1283                 VM_Warning(prog, "VM_CL_setmodelindex: null model\n");
1284                 return;
1285         }
1286         PRVM_clientedictstring(t, model) = PRVM_SetEngineString(prog, model->name);
1287         PRVM_clientedictfloat(t, modelindex) = i;
1288
1289         // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
1290         if (model)
1291         {
1292                 SetMinMaxSize (prog, t, model->normalmins, model->normalmaxs);
1293         }
1294         else
1295                 SetMinMaxSize (prog, t, vec3_origin, vec3_origin);
1296 }
1297
1298 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
1299 static void VM_CL_modelnameforindex (prvm_prog_t *prog)
1300 {
1301         dp_model_t *model;
1302
1303         VM_SAFEPARMCOUNT(1, VM_CL_modelnameforindex);
1304
1305         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1306         model = CL_GetModelByIndex((int)PRVM_G_FLOAT(OFS_PARM0));
1307         PRVM_G_INT(OFS_RETURN) = model ? PRVM_SetEngineString(prog, model->name) : 0;
1308 }
1309
1310 //#335 float(string effectname) particleeffectnum (EXT_CSQC)
1311 static void VM_CL_particleeffectnum (prvm_prog_t *prog)
1312 {
1313         int                     i;
1314         VM_SAFEPARMCOUNT(1, VM_CL_particleeffectnum);
1315         i = CL_ParticleEffectIndexForName(PRVM_G_STRING(OFS_PARM0));
1316         if (i == 0)
1317                 i = -1;
1318         PRVM_G_FLOAT(OFS_RETURN) = i;
1319 }
1320
1321 // #336 void(entity ent, float effectnum, vector start, vector end[, float color]) trailparticles (EXT_CSQC)
1322 static void VM_CL_trailparticles (prvm_prog_t *prog)
1323 {
1324         int                             i;
1325         vec3_t                  start, end, velocity;
1326         prvm_edict_t    *t;
1327         VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_trailparticles);
1328
1329         t = PRVM_G_EDICT(OFS_PARM0);
1330         i               = (int)PRVM_G_FLOAT(OFS_PARM1);
1331         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), start);
1332         VectorCopy(PRVM_G_VECTOR(OFS_PARM3), end);
1333         VectorCopy(PRVM_clientedictvector(t, velocity), velocity);
1334
1335         if (i < 0)
1336                 return;
1337         CL_ParticleTrail(i, 1, start, end, velocity, velocity, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0, true, true, NULL, NULL, 1);
1338 }
1339
1340 //#337 void(float effectnum, vector origin, vector dir, float count[, float color]) pointparticles (EXT_CSQC)
1341 static void VM_CL_pointparticles (prvm_prog_t *prog)
1342 {
1343         int                     i;
1344         float n;
1345         vec3_t f, v;
1346         VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_pointparticles);
1347         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1348         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), f);
1349         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), v);
1350         n = PRVM_G_FLOAT(OFS_PARM3);
1351         if (i < 0)
1352                 return;
1353         CL_ParticleEffect(i, n, f, f, v, v, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
1354 }
1355
1356 //#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)
1357 static void VM_CL_boxparticles (prvm_prog_t *prog)
1358 {
1359         int effectnum;
1360         // prvm_edict_t *own;
1361         vec3_t origin_from, origin_to, dir_from, dir_to;
1362         float count;
1363         int flags;
1364         qboolean istrail;
1365         float tintmins[4], tintmaxs[4], fade;
1366         VM_SAFEPARMCOUNTRANGE(7, 8, VM_CL_boxparticles);
1367
1368         effectnum = (int)PRVM_G_FLOAT(OFS_PARM0);
1369         if (effectnum < 0)
1370                 return;
1371         // own = PRVM_G_EDICT(OFS_PARM1); // TODO find use for this
1372         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin_from);
1373         VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin_to  );
1374         VectorCopy(PRVM_G_VECTOR(OFS_PARM4), dir_from   );
1375         VectorCopy(PRVM_G_VECTOR(OFS_PARM5), dir_to     );
1376         count = PRVM_G_FLOAT(OFS_PARM6);
1377         if(prog->argc >= 8)
1378                 flags = PRVM_G_FLOAT(OFS_PARM7);
1379         else
1380                 flags = 0;
1381
1382         Vector4Set(tintmins, 1, 1, 1, 1);
1383         Vector4Set(tintmaxs, 1, 1, 1, 1);
1384         fade = 1;
1385         istrail = false;
1386
1387         if(flags & 1) // read alpha
1388         {
1389                 tintmins[3] = PRVM_clientglobalfloat(particles_alphamin);
1390                 tintmaxs[3] = PRVM_clientglobalfloat(particles_alphamax);
1391         }
1392         if(flags & 2) // read color
1393         {
1394                 VectorCopy(PRVM_clientglobalvector(particles_colormin), tintmins);
1395                 VectorCopy(PRVM_clientglobalvector(particles_colormax), tintmaxs);
1396         }
1397         if(flags & 4) // read fade
1398         {
1399                 fade = PRVM_clientglobalfloat(particles_fade);
1400         }
1401         if(flags & 128) // draw as trail
1402         {
1403                 istrail = true;
1404         }
1405
1406         if (istrail)
1407                 CL_ParticleTrail(effectnum, count, origin_from, origin_to, dir_from, dir_to, NULL, 0, true, true, tintmins, tintmaxs, fade);
1408         else
1409                 CL_ParticleBox(effectnum, count, origin_from, origin_to, dir_from, dir_to, NULL, 0, true, true, tintmins, tintmaxs, fade);
1410 }
1411
1412 //#531 void(float pause) setpause
1413 static void VM_CL_setpause(prvm_prog_t *prog)
1414 {
1415         VM_SAFEPARMCOUNT(1, VM_CL_setpause);
1416         if ((int)PRVM_G_FLOAT(OFS_PARM0) != 0)
1417                 cl.csqc_paused = true;
1418         else
1419                 cl.csqc_paused = false;
1420 }
1421
1422 //#343 void(float usecursor) setcursormode (DP_CSQC)
1423 static void VM_CL_setcursormode (prvm_prog_t *prog)
1424 {
1425         VM_SAFEPARMCOUNT(1, VM_CL_setcursormode);
1426         cl.csqc_wantsmousemove = PRVM_G_FLOAT(OFS_PARM0) != 0;
1427         cl_ignoremousemoves = 2;
1428 }
1429
1430 //#344 vector() getmousepos (DP_CSQC)
1431 static void VM_CL_getmousepos(prvm_prog_t *prog)
1432 {
1433         VM_SAFEPARMCOUNT(0,VM_CL_getmousepos);
1434
1435         if (key_consoleactive || key_dest != key_game)
1436                 VectorSet(PRVM_G_VECTOR(OFS_RETURN), 0, 0, 0);
1437         else if (cl.csqc_wantsmousemove)
1438                 VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_windowmouse_x * vid_conwidth.integer / vid.width, in_windowmouse_y * vid_conheight.integer / vid.height, 0);
1439         else
1440                 VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_mouse_x * vid_conwidth.integer / vid.width, in_mouse_y * vid_conheight.integer / vid.height, 0);
1441 }
1442
1443 //#345 float(float framenum) getinputstate (EXT_CSQC)
1444 static void VM_CL_getinputstate (prvm_prog_t *prog)
1445 {
1446         unsigned int i, frame;
1447         VM_SAFEPARMCOUNT(1, VM_CL_getinputstate);
1448         frame = (unsigned int)PRVM_G_FLOAT(OFS_PARM0);
1449         PRVM_G_FLOAT(OFS_RETURN) = false;
1450         for (i = 0;i < CL_MAX_USERCMDS;i++)
1451         {
1452                 if (cl.movecmd[i].sequence == frame)
1453                 {
1454                         VectorCopy(cl.movecmd[i].viewangles, PRVM_clientglobalvector(input_angles));
1455                         PRVM_clientglobalfloat(input_buttons) = cl.movecmd[i].buttons; // FIXME: this should not be directly exposed to csqc (translation layer needed?)
1456                         PRVM_clientglobalvector(input_movevalues)[0] = cl.movecmd[i].forwardmove;
1457                         PRVM_clientglobalvector(input_movevalues)[1] = cl.movecmd[i].sidemove;
1458                         PRVM_clientglobalvector(input_movevalues)[2] = cl.movecmd[i].upmove;
1459                         PRVM_clientglobalfloat(input_timelength) = cl.movecmd[i].frametime;
1460                         // this probably shouldn't be here
1461                         if(cl.movecmd[i].crouch)
1462                         {
1463                                 VectorCopy(cl.playercrouchmins, PRVM_clientglobalvector(pmove_mins));
1464                                 VectorCopy(cl.playercrouchmaxs, PRVM_clientglobalvector(pmove_maxs));
1465                         }
1466                         else
1467                         {
1468                                 VectorCopy(cl.playerstandmins, PRVM_clientglobalvector(pmove_mins));
1469                                 VectorCopy(cl.playerstandmaxs, PRVM_clientglobalvector(pmove_maxs));
1470                         }
1471                         PRVM_G_FLOAT(OFS_RETURN) = true;
1472                 }
1473         }
1474 }
1475
1476 //#346 void(float sens) setsensitivityscaler (EXT_CSQC)
1477 static void VM_CL_setsensitivityscale (prvm_prog_t *prog)
1478 {
1479         VM_SAFEPARMCOUNT(1, VM_CL_setsensitivityscale);
1480         cl.sensitivityscale = PRVM_G_FLOAT(OFS_PARM0);
1481 }
1482
1483 //#347 void() runstandardplayerphysics (EXT_CSQC)
1484 #define PMF_JUMP_HELD 1 // matches FTEQW
1485 #define PMF_LADDER 2 // not used by DP, FTEQW sets this in runplayerphysics but does not read it
1486 #define PMF_DUCKED 4 // FIXME FTEQW doesn't have this for Q1 like movement because Q1 cannot crouch
1487 #define PMF_ONGROUND 8 // FIXME FTEQW doesn't have this for Q1 like movement and expects CSQC code to do its own trace, this is stupid CPU waste
1488 static void VM_CL_runplayerphysics (prvm_prog_t *prog)
1489 {
1490         cl_clientmovement_state_t s;
1491         prvm_edict_t *ent;
1492
1493         memset(&s, 0, sizeof(s));
1494
1495         VM_SAFEPARMCOUNTRANGE(0, 1, VM_CL_runplayerphysics);
1496
1497         ent = (prog->argc == 1 ? PRVM_G_EDICT(OFS_PARM0) : prog->edicts);
1498         if(ent == prog->edicts)
1499         {
1500                 // deprecated use
1501                 s.self = NULL;
1502                 VectorCopy(PRVM_clientglobalvector(pmove_org), s.origin);
1503                 VectorCopy(PRVM_clientglobalvector(pmove_vel), s.velocity);
1504                 VectorCopy(PRVM_clientglobalvector(pmove_mins), s.mins);
1505                 VectorCopy(PRVM_clientglobalvector(pmove_maxs), s.maxs);
1506                 s.crouched = 0;
1507                 s.waterjumptime = PRVM_clientglobalfloat(pmove_waterjumptime);
1508                 s.cmd.canjump = (int)PRVM_clientglobalfloat(pmove_jump_held) == 0;
1509         }
1510         else
1511         {
1512                 // new use
1513                 s.self = ent;
1514                 VectorCopy(PRVM_clientedictvector(ent, origin), s.origin);
1515                 VectorCopy(PRVM_clientedictvector(ent, velocity), s.velocity);
1516                 VectorCopy(PRVM_clientedictvector(ent, mins), s.mins);
1517                 VectorCopy(PRVM_clientedictvector(ent, maxs), s.maxs);
1518                 s.crouched = ((int)PRVM_clientedictfloat(ent, pmove_flags) & PMF_DUCKED) != 0;
1519                 s.waterjumptime = 0; // FIXME where do we get this from? FTEQW lacks support for this too
1520                 s.cmd.canjump = ((int)PRVM_clientedictfloat(ent, pmove_flags) & PMF_JUMP_HELD) == 0;
1521         }
1522
1523         VectorCopy(PRVM_clientglobalvector(input_angles), s.cmd.viewangles);
1524         s.cmd.forwardmove = PRVM_clientglobalvector(input_movevalues)[0];
1525         s.cmd.sidemove = PRVM_clientglobalvector(input_movevalues)[1];
1526         s.cmd.upmove = PRVM_clientglobalvector(input_movevalues)[2];
1527         s.cmd.buttons = PRVM_clientglobalfloat(input_buttons);
1528         s.cmd.frametime = PRVM_clientglobalfloat(input_timelength);
1529         s.cmd.jump = (s.cmd.buttons & 2) != 0;
1530         s.cmd.crouch = (s.cmd.buttons & 16) != 0;
1531
1532         CL_ClientMovement_PlayerMove_Frame(&s);
1533
1534         if(ent == prog->edicts)
1535         {
1536                 // deprecated use
1537                 VectorCopy(s.origin, PRVM_clientglobalvector(pmove_org));
1538                 VectorCopy(s.velocity, PRVM_clientglobalvector(pmove_vel));
1539                 PRVM_clientglobalfloat(pmove_jump_held) = !s.cmd.canjump;
1540                 PRVM_clientglobalfloat(pmove_waterjumptime) = s.waterjumptime;
1541         }
1542         else
1543         {
1544                 // new use
1545                 VectorCopy(s.origin, PRVM_clientedictvector(ent, origin));
1546                 VectorCopy(s.velocity, PRVM_clientedictvector(ent, velocity));
1547                 PRVM_clientedictfloat(ent, pmove_flags) =
1548                         (s.crouched ? PMF_DUCKED : 0) |
1549                         (s.cmd.canjump ? 0 : PMF_JUMP_HELD) |
1550                         (s.onground ? PMF_ONGROUND : 0);
1551         }
1552 }
1553
1554 //#348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
1555 static void VM_CL_getplayerkey (prvm_prog_t *prog)
1556 {
1557         int                     i;
1558         char            t[128];
1559         const char      *c;
1560
1561         VM_SAFEPARMCOUNT(2, VM_CL_getplayerkey);
1562
1563         i = (int)PRVM_G_FLOAT(OFS_PARM0);
1564         c = PRVM_G_STRING(OFS_PARM1);
1565         PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1566         Sbar_SortFrags();
1567
1568         if (i < 0)
1569                 i = Sbar_GetSortedPlayerIndex(-1-i);
1570         if(i < 0 || i >= cl.maxclients)
1571                 return;
1572
1573         t[0] = 0;
1574
1575         if(!strcasecmp(c, "name"))
1576                 strlcpy(t, cl.scores[i].name, sizeof(t));
1577         else
1578                 if(!strcasecmp(c, "frags"))
1579                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].frags);
1580         else
1581                 if(!strcasecmp(c, "ping"))
1582                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_ping);
1583         else
1584                 if(!strcasecmp(c, "pl"))
1585                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_packetloss);
1586         else
1587                 if(!strcasecmp(c, "movementloss"))
1588                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_movementloss);
1589         else
1590                 if(!strcasecmp(c, "entertime"))
1591                         dpsnprintf(t, sizeof(t), "%f", cl.scores[i].qw_entertime);
1592         else
1593                 if(!strcasecmp(c, "colors"))
1594                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].colors);
1595         else
1596                 if(!strcasecmp(c, "topcolor"))
1597                         dpsnprintf(t, sizeof(t), "%i", cl.scores[i].colors & 0xf0);
1598         else
1599                 if(!strcasecmp(c, "bottomcolor"))
1600                         dpsnprintf(t, sizeof(t), "%i", (cl.scores[i].colors &15)<<4);
1601         else
1602                 if(!strcasecmp(c, "viewentity"))
1603                         dpsnprintf(t, sizeof(t), "%i", i+1);
1604         if(!t[0])
1605                 return;
1606         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, t);
1607 }
1608
1609 //#351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
1610 static void VM_CL_setlistener (prvm_prog_t *prog)
1611 {
1612         vec3_t origin, forward, left, up;
1613         VM_SAFEPARMCOUNT(4, VM_CL_setlistener);
1614         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), origin);
1615         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), forward);
1616         VectorNegate(PRVM_G_VECTOR(OFS_PARM2), left);
1617         VectorCopy(PRVM_G_VECTOR(OFS_PARM3), up);
1618         Matrix4x4_FromVectors(&cl.csqc_listenermatrix, forward, left, up, origin);
1619         cl.csqc_usecsqclistener = true; //use csqc listener at this frame
1620 }
1621
1622 //#352 void(string cmdname) registercommand (EXT_CSQC)
1623 static void VM_CL_registercmd (prvm_prog_t *prog)
1624 {
1625         char *t;
1626         VM_SAFEPARMCOUNT(1, VM_CL_registercmd);
1627         if(!Cmd_Exists(PRVM_G_STRING(OFS_PARM0)))
1628         {
1629                 size_t alloclen;
1630
1631                 alloclen = strlen(PRVM_G_STRING(OFS_PARM0)) + 1;
1632                 t = (char *)Z_Malloc(alloclen);
1633                 memcpy(t, PRVM_G_STRING(OFS_PARM0), alloclen);
1634                 Cmd_AddCommand(t, NULL, "console command created by QuakeC");
1635         }
1636         else
1637                 Cmd_AddCommand(PRVM_G_STRING(OFS_PARM0), NULL, "console command created by QuakeC");
1638
1639 }
1640
1641 //#360 float() readbyte (EXT_CSQC)
1642 static void VM_CL_ReadByte (prvm_prog_t *prog)
1643 {
1644         VM_SAFEPARMCOUNT(0, VM_CL_ReadByte);
1645         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadByte(&cl_message);
1646 }
1647
1648 //#361 float() readchar (EXT_CSQC)
1649 static void VM_CL_ReadChar (prvm_prog_t *prog)
1650 {
1651         VM_SAFEPARMCOUNT(0, VM_CL_ReadChar);
1652         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadChar(&cl_message);
1653 }
1654
1655 //#362 float() readshort (EXT_CSQC)
1656 static void VM_CL_ReadShort (prvm_prog_t *prog)
1657 {
1658         VM_SAFEPARMCOUNT(0, VM_CL_ReadShort);
1659         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadShort(&cl_message);
1660 }
1661
1662 //#363 float() readlong (EXT_CSQC)
1663 static void VM_CL_ReadLong (prvm_prog_t *prog)
1664 {
1665         VM_SAFEPARMCOUNT(0, VM_CL_ReadLong);
1666         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadLong(&cl_message);
1667 }
1668
1669 //#364 float() readcoord (EXT_CSQC)
1670 static void VM_CL_ReadCoord (prvm_prog_t *prog)
1671 {
1672         VM_SAFEPARMCOUNT(0, VM_CL_ReadCoord);
1673         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadCoord(&cl_message, cls.protocol);
1674 }
1675
1676 //#365 float() readangle (EXT_CSQC)
1677 static void VM_CL_ReadAngle (prvm_prog_t *prog)
1678 {
1679         VM_SAFEPARMCOUNT(0, VM_CL_ReadAngle);
1680         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadAngle(&cl_message, cls.protocol);
1681 }
1682
1683 //#366 string() readstring (EXT_CSQC)
1684 static void VM_CL_ReadString (prvm_prog_t *prog)
1685 {
1686         VM_SAFEPARMCOUNT(0, VM_CL_ReadString);
1687         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring)));
1688 }
1689
1690 //#367 float() readfloat (EXT_CSQC)
1691 static void VM_CL_ReadFloat (prvm_prog_t *prog)
1692 {
1693         VM_SAFEPARMCOUNT(0, VM_CL_ReadFloat);
1694         PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadFloat(&cl_message);
1695 }
1696
1697 //#501 string() readpicture (DP_CSQC_READWRITEPICTURE)
1698 extern cvar_t cl_readpicture_force;
1699 static void VM_CL_ReadPicture (prvm_prog_t *prog)
1700 {
1701         const char *name;
1702         unsigned char *data;
1703         unsigned char *buf;
1704         unsigned short size;
1705         int i;
1706         cachepic_t *pic;
1707
1708         VM_SAFEPARMCOUNT(0, VM_CL_ReadPicture);
1709
1710         name = MSG_ReadString(&cl_message, cl_readstring, sizeof(cl_readstring));
1711         size = (unsigned short) MSG_ReadShort(&cl_message);
1712
1713         // check if a texture of that name exists
1714         // if yes, it is used and the data is discarded
1715         // if not, the (low quality) data is used to build a new texture, whose name will get returned
1716
1717         pic = Draw_CachePic_Flags (name, CACHEPICFLAG_NOTPERSISTENT);
1718
1719         if(size)
1720         {
1721                 if(pic->tex == r_texture_notexture)
1722                         pic->tex = NULL; // don't overwrite the notexture by Draw_NewPic
1723                 if(pic->tex && !cl_readpicture_force.integer)
1724                 {
1725                         // texture found and loaded
1726                         // skip over the jpeg as we don't need it
1727                         for(i = 0; i < size; ++i)
1728                                 (void) MSG_ReadByte(&cl_message);
1729                 }
1730                 else
1731                 {
1732                         // texture not found
1733                         // use the attached jpeg as texture
1734                         buf = (unsigned char *) Mem_Alloc(tempmempool, size);
1735                         MSG_ReadBytes(&cl_message, size, buf);
1736                         data = JPEG_LoadImage_BGRA(buf, size, NULL);
1737                         Mem_Free(buf);
1738                         Draw_NewPic(name, image_width, image_height, false, data);
1739                         Mem_Free(data);
1740                 }
1741         }
1742
1743         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, name);
1744 }
1745
1746 //////////////////////////////////////////////////////////
1747
1748 static void VM_CL_makestatic (prvm_prog_t *prog)
1749 {
1750         prvm_edict_t *ent;
1751
1752         VM_SAFEPARMCOUNT(1, VM_CL_makestatic);
1753
1754         ent = PRVM_G_EDICT(OFS_PARM0);
1755         if (ent == prog->edicts)
1756         {
1757                 VM_Warning(prog, "makestatic: can not modify world entity\n");
1758                 return;
1759         }
1760         if (ent->priv.server->free)
1761         {
1762                 VM_Warning(prog, "makestatic: can not modify free entity\n");
1763                 return;
1764         }
1765
1766         if (cl.num_static_entities < cl.max_static_entities)
1767         {
1768                 int renderflags;
1769                 entity_t *staticent = &cl.static_entities[cl.num_static_entities++];
1770
1771                 // copy it to the current state
1772                 memset(staticent, 0, sizeof(*staticent));
1773                 staticent->render.model = CL_GetModelByIndex((int)PRVM_clientedictfloat(ent, modelindex));
1774                 staticent->render.framegroupblend[0].frame = (int)PRVM_clientedictfloat(ent, frame);
1775                 staticent->render.framegroupblend[0].lerp = 1;
1776                 // make torchs play out of sync
1777                 staticent->render.framegroupblend[0].start = lhrandom(-10, -1);
1778                 staticent->render.skinnum = (int)PRVM_clientedictfloat(ent, skin);
1779                 staticent->render.effects = (int)PRVM_clientedictfloat(ent, effects);
1780                 staticent->render.alpha = PRVM_clientedictfloat(ent, alpha);
1781                 staticent->render.scale = PRVM_clientedictfloat(ent, scale);
1782                 VectorCopy(PRVM_clientedictvector(ent, colormod), staticent->render.colormod);
1783                 VectorCopy(PRVM_clientedictvector(ent, glowmod), staticent->render.glowmod);
1784
1785                 // sanitize values
1786                 if (!staticent->render.alpha)
1787                         staticent->render.alpha = 1.0f;
1788                 if (!staticent->render.scale)
1789                         staticent->render.scale = 1.0f;
1790                 if (!VectorLength2(staticent->render.colormod))
1791                         VectorSet(staticent->render.colormod, 1, 1, 1);
1792                 if (!VectorLength2(staticent->render.glowmod))
1793                         VectorSet(staticent->render.glowmod, 1, 1, 1);
1794
1795                 renderflags = (int)PRVM_clientedictfloat(ent, renderflags);
1796                 if (renderflags & RF_USEAXIS)
1797                 {
1798                         vec3_t forward, left, up, origin;
1799                         VectorCopy(PRVM_clientglobalvector(v_forward), forward);
1800                         VectorNegate(PRVM_clientglobalvector(v_right), left);
1801                         VectorCopy(PRVM_clientglobalvector(v_up), up);
1802                         VectorCopy(PRVM_clientedictvector(ent, origin), origin);
1803                         Matrix4x4_FromVectors(&staticent->render.matrix, forward, left, up, origin);
1804                         Matrix4x4_Scale(&staticent->render.matrix, staticent->render.scale, 1);
1805                 }
1806                 else
1807                         Matrix4x4_CreateFromQuakeEntity(&staticent->render.matrix, PRVM_clientedictvector(ent, origin)[0], PRVM_clientedictvector(ent, origin)[1], PRVM_clientedictvector(ent, origin)[2], PRVM_clientedictvector(ent, angles)[0], PRVM_clientedictvector(ent, angles)[1], PRVM_clientedictvector(ent, angles)[2], staticent->render.scale);
1808
1809                 // either fullbright or lit
1810                 if(!r_fullbright.integer)
1811                 {
1812                         if (!(staticent->render.effects & EF_FULLBRIGHT))
1813                                 staticent->render.flags |= RENDER_LIGHT;
1814                         else if(r_equalize_entities_fullbright.integer)
1815                                 staticent->render.flags |= RENDER_LIGHT | RENDER_EQUALIZE;
1816                 }
1817                 // turn off shadows from transparent objects
1818                 if (!(staticent->render.effects & (EF_NOSHADOW | EF_ADDITIVE | EF_NODEPTHTEST)) && (staticent->render.alpha >= 1))
1819                         staticent->render.flags |= RENDER_SHADOW;
1820                 if (staticent->render.effects & EF_NODEPTHTEST)
1821                         staticent->render.flags |= RENDER_NODEPTHTEST;
1822                 if (staticent->render.effects & EF_ADDITIVE)
1823                         staticent->render.flags |= RENDER_ADDITIVE;
1824                 if (staticent->render.effects & EF_DOUBLESIDED)
1825                         staticent->render.flags |= RENDER_DOUBLESIDED;
1826
1827                 staticent->render.allowdecals = true;
1828                 CL_UpdateRenderEntity(&staticent->render);
1829         }
1830         else
1831                 Con_Printf("Too many static entities");
1832
1833 // throw the entity away now
1834         PRVM_ED_Free(prog, ent);
1835 }
1836
1837 //=================================================================//
1838
1839 /*
1840 =================
1841 VM_CL_copyentity
1842
1843 copies data from one entity to another
1844
1845 copyentity(src, dst)
1846 =================
1847 */
1848 static void VM_CL_copyentity (prvm_prog_t *prog)
1849 {
1850         prvm_edict_t *in, *out;
1851         VM_SAFEPARMCOUNT(2, VM_CL_copyentity);
1852         in = PRVM_G_EDICT(OFS_PARM0);
1853         if (in == prog->edicts)
1854         {
1855                 VM_Warning(prog, "copyentity: can not read world entity\n");
1856                 return;
1857         }
1858         if (in->priv.server->free)
1859         {
1860                 VM_Warning(prog, "copyentity: can not read free entity\n");
1861                 return;
1862         }
1863         out = PRVM_G_EDICT(OFS_PARM1);
1864         if (out == prog->edicts)
1865         {
1866                 VM_Warning(prog, "copyentity: can not modify world entity\n");
1867                 return;
1868         }
1869         if (out->priv.server->free)
1870         {
1871                 VM_Warning(prog, "copyentity: can not modify free entity\n");
1872                 return;
1873         }
1874         memcpy(out->fields.fp, in->fields.fp, prog->entityfields * sizeof(prvm_vec_t));
1875         CL_LinkEdict(out);
1876 }
1877
1878 //=================================================================//
1879
1880 // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
1881 static void VM_CL_effect (prvm_prog_t *prog)
1882 {
1883 #if 1
1884         Con_Printf("WARNING: VM_CL_effect not implemented\n"); // FIXME: this needs to take modelname not modelindex, the csqc defs has it as string and so it shall be
1885 #else
1886         vec3_t org;
1887         VM_SAFEPARMCOUNT(5, VM_CL_effect);
1888         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
1889         CL_Effect(org, (int)PRVM_G_FLOAT(OFS_PARM1), (int)PRVM_G_FLOAT(OFS_PARM2), (int)PRVM_G_FLOAT(OFS_PARM3), PRVM_G_FLOAT(OFS_PARM4));
1890 #endif
1891 }
1892
1893 // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
1894 static void VM_CL_te_blood (prvm_prog_t *prog)
1895 {
1896         vec3_t pos, vel, pos2;
1897         VM_SAFEPARMCOUNT(3, VM_CL_te_blood);
1898         if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1899                 return;
1900         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
1901         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), vel);
1902         CL_FindNonSolidLocation(pos, pos2, 4);
1903         CL_ParticleEffect(EFFECT_TE_BLOOD, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, vel, vel, NULL, 0);
1904 }
1905
1906 // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
1907 static void VM_CL_te_bloodshower (prvm_prog_t *prog)
1908 {
1909         vec_t speed;
1910         vec3_t mincorner, maxcorner, vel1, vel2;
1911         VM_SAFEPARMCOUNT(4, VM_CL_te_bloodshower);
1912         if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1913                 return;
1914         speed = PRVM_G_FLOAT(OFS_PARM2);
1915         vel1[0] = -speed;
1916         vel1[1] = -speed;
1917         vel1[2] = -speed;
1918         vel2[0] = speed;
1919         vel2[1] = speed;
1920         vel2[2] = speed;
1921         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), mincorner);
1922         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), maxcorner);
1923         CL_ParticleEffect(EFFECT_TE_BLOOD, PRVM_G_FLOAT(OFS_PARM3), mincorner, maxcorner, vel1, vel2, NULL, 0);
1924 }
1925
1926 // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
1927 static void VM_CL_te_explosionrgb (prvm_prog_t *prog)
1928 {
1929         vec3_t          pos;
1930         vec3_t          pos2;
1931         matrix4x4_t     tempmatrix;
1932         VM_SAFEPARMCOUNT(2, VM_CL_te_explosionrgb);
1933         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
1934         CL_FindNonSolidLocation(pos, pos2, 10);
1935         CL_ParticleExplosion(pos2);
1936         Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1937         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);
1938 }
1939
1940 // #408 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color, float gravityflag, float randomveljitter) te_particlecube (DP_TE_PARTICLECUBE)
1941 static void VM_CL_te_particlecube (prvm_prog_t *prog)
1942 {
1943         vec3_t mincorner, maxcorner, vel;
1944         VM_SAFEPARMCOUNT(7, VM_CL_te_particlecube);
1945         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), mincorner);
1946         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), maxcorner);
1947         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), vel);
1948         CL_ParticleCube(mincorner, maxcorner, vel, (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), PRVM_G_FLOAT(OFS_PARM5), PRVM_G_FLOAT(OFS_PARM6));
1949 }
1950
1951 // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
1952 static void VM_CL_te_particlerain (prvm_prog_t *prog)
1953 {
1954         vec3_t mincorner, maxcorner, vel;
1955         VM_SAFEPARMCOUNT(5, VM_CL_te_particlerain);
1956         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), mincorner);
1957         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), maxcorner);
1958         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), vel);
1959         CL_ParticleRain(mincorner, maxcorner, vel, (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), 0);
1960 }
1961
1962 // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
1963 static void VM_CL_te_particlesnow (prvm_prog_t *prog)
1964 {
1965         vec3_t mincorner, maxcorner, vel;
1966         VM_SAFEPARMCOUNT(5, VM_CL_te_particlesnow);
1967         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), mincorner);
1968         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), maxcorner);
1969         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), vel);
1970         CL_ParticleRain(mincorner, maxcorner, vel, (int)PRVM_G_FLOAT(OFS_PARM3), (int)PRVM_G_FLOAT(OFS_PARM4), 1);
1971 }
1972
1973 // #411 void(vector org, vector vel, float howmany) te_spark
1974 static void VM_CL_te_spark (prvm_prog_t *prog)
1975 {
1976         vec3_t pos, pos2, vel;
1977         VM_SAFEPARMCOUNT(3, VM_CL_te_spark);
1978
1979         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
1980         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), vel);
1981         CL_FindNonSolidLocation(pos, pos2, 4);
1982         CL_ParticleEffect(EFFECT_TE_SPARK, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, vel, vel, NULL, 0);
1983 }
1984
1985 extern cvar_t cl_sound_ric_gunshot;
1986 // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
1987 static void VM_CL_te_gunshotquad (prvm_prog_t *prog)
1988 {
1989         vec3_t          pos, pos2;
1990         int                     rnd;
1991         VM_SAFEPARMCOUNT(1, VM_CL_te_gunshotquad);
1992
1993         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
1994         CL_FindNonSolidLocation(pos, pos2, 4);
1995         CL_ParticleEffect(EFFECT_TE_GUNSHOTQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1996         if(cl_sound_ric_gunshot.integer >= 2)
1997         {
1998                 if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1999                 else
2000                 {
2001                         rnd = rand() & 3;
2002                         if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
2003                         else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
2004                         else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
2005                 }
2006         }
2007 }
2008
2009 // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
2010 static void VM_CL_te_spikequad (prvm_prog_t *prog)
2011 {
2012         vec3_t          pos, pos2;
2013         int                     rnd;
2014         VM_SAFEPARMCOUNT(1, VM_CL_te_spikequad);
2015
2016         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2017         CL_FindNonSolidLocation(pos, pos2, 4);
2018         CL_ParticleEffect(EFFECT_TE_SPIKEQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2019         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
2020         else
2021         {
2022                 rnd = rand() & 3;
2023                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
2024                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
2025                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
2026         }
2027 }
2028
2029 // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
2030 static void VM_CL_te_superspikequad (prvm_prog_t *prog)
2031 {
2032         vec3_t          pos, pos2;
2033         int                     rnd;
2034         VM_SAFEPARMCOUNT(1, VM_CL_te_superspikequad);
2035
2036         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2037         CL_FindNonSolidLocation(pos, pos2, 4);
2038         CL_ParticleEffect(EFFECT_TE_SUPERSPIKEQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2039         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos, 1, 1);
2040         else
2041         {
2042                 rnd = rand() & 3;
2043                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
2044                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
2045                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
2046         }
2047 }
2048
2049 // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
2050 static void VM_CL_te_explosionquad (prvm_prog_t *prog)
2051 {
2052         vec3_t          pos, pos2;
2053         VM_SAFEPARMCOUNT(1, VM_CL_te_explosionquad);
2054
2055         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2056         CL_FindNonSolidLocation(pos, pos2, 10);
2057         CL_ParticleEffect(EFFECT_TE_EXPLOSIONQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2058         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
2059 }
2060
2061 // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
2062 static void VM_CL_te_smallflash (prvm_prog_t *prog)
2063 {
2064         vec3_t          pos, pos2;
2065         VM_SAFEPARMCOUNT(1, VM_CL_te_smallflash);
2066
2067         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2068         CL_FindNonSolidLocation(pos, pos2, 10);
2069         CL_ParticleEffect(EFFECT_TE_SMALLFLASH, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2070 }
2071
2072 // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
2073 static void VM_CL_te_customflash (prvm_prog_t *prog)
2074 {
2075         vec3_t          pos, pos2;
2076         matrix4x4_t     tempmatrix;
2077         VM_SAFEPARMCOUNT(4, VM_CL_te_customflash);
2078
2079         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2080         CL_FindNonSolidLocation(pos, pos2, 4);
2081         Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
2082         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);
2083 }
2084
2085 // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
2086 static void VM_CL_te_gunshot (prvm_prog_t *prog)
2087 {
2088         vec3_t          pos, pos2;
2089         int                     rnd;
2090         VM_SAFEPARMCOUNT(1, VM_CL_te_gunshot);
2091
2092         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2093         CL_FindNonSolidLocation(pos, pos2, 4);
2094         CL_ParticleEffect(EFFECT_TE_GUNSHOT, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2095         if(cl_sound_ric_gunshot.integer == 1 || cl_sound_ric_gunshot.integer == 3)
2096         {
2097                 if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
2098                 else
2099                 {
2100                         rnd = rand() & 3;
2101                         if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
2102                         else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
2103                         else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
2104                 }
2105         }
2106 }
2107
2108 // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
2109 static void VM_CL_te_spike (prvm_prog_t *prog)
2110 {
2111         vec3_t          pos, pos2;
2112         int                     rnd;
2113         VM_SAFEPARMCOUNT(1, VM_CL_te_spike);
2114
2115         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2116         CL_FindNonSolidLocation(pos, pos2, 4);
2117         CL_ParticleEffect(EFFECT_TE_SPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2118         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
2119         else
2120         {
2121                 rnd = rand() & 3;
2122                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
2123                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
2124                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
2125         }
2126 }
2127
2128 // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
2129 static void VM_CL_te_superspike (prvm_prog_t *prog)
2130 {
2131         vec3_t          pos, pos2;
2132         int                     rnd;
2133         VM_SAFEPARMCOUNT(1, VM_CL_te_superspike);
2134
2135         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2136         CL_FindNonSolidLocation(pos, pos2, 4);
2137         CL_ParticleEffect(EFFECT_TE_SUPERSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2138         if (rand() % 5)                 S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
2139         else
2140         {
2141                 rnd = rand() & 3;
2142                 if (rnd == 1)           S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
2143                 else if (rnd == 2)      S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
2144                 else                            S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
2145         }
2146 }
2147
2148 // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
2149 static void VM_CL_te_explosion (prvm_prog_t *prog)
2150 {
2151         vec3_t          pos, pos2;
2152         VM_SAFEPARMCOUNT(1, VM_CL_te_explosion);
2153
2154         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2155         CL_FindNonSolidLocation(pos, pos2, 10);
2156         CL_ParticleEffect(EFFECT_TE_EXPLOSION, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2157         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
2158 }
2159
2160 // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
2161 static void VM_CL_te_tarexplosion (prvm_prog_t *prog)
2162 {
2163         vec3_t          pos, pos2;
2164         VM_SAFEPARMCOUNT(1, VM_CL_te_tarexplosion);
2165
2166         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2167         CL_FindNonSolidLocation(pos, pos2, 10);
2168         CL_ParticleEffect(EFFECT_TE_TAREXPLOSION, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2169         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
2170 }
2171
2172 // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
2173 static void VM_CL_te_wizspike (prvm_prog_t *prog)
2174 {
2175         vec3_t          pos, pos2;
2176         VM_SAFEPARMCOUNT(1, VM_CL_te_wizspike);
2177
2178         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2179         CL_FindNonSolidLocation(pos, pos2, 4);
2180         CL_ParticleEffect(EFFECT_TE_WIZSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2181         S_StartSound(-1, 0, cl.sfx_wizhit, pos2, 1, 1);
2182 }
2183
2184 // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
2185 static void VM_CL_te_knightspike (prvm_prog_t *prog)
2186 {
2187         vec3_t          pos, pos2;
2188         VM_SAFEPARMCOUNT(1, VM_CL_te_knightspike);
2189
2190         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2191         CL_FindNonSolidLocation(pos, pos2, 4);
2192         CL_ParticleEffect(EFFECT_TE_KNIGHTSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2193         S_StartSound(-1, 0, cl.sfx_knighthit, pos2, 1, 1);
2194 }
2195
2196 // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
2197 static void VM_CL_te_lavasplash (prvm_prog_t *prog)
2198 {
2199         vec3_t          pos;
2200         VM_SAFEPARMCOUNT(1, VM_CL_te_lavasplash);
2201         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2202         CL_ParticleEffect(EFFECT_TE_LAVASPLASH, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
2203 }
2204
2205 // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
2206 static void VM_CL_te_teleport (prvm_prog_t *prog)
2207 {
2208         vec3_t          pos;
2209         VM_SAFEPARMCOUNT(1, VM_CL_te_teleport);
2210         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2211         CL_ParticleEffect(EFFECT_TE_TELEPORT, 1, pos, pos, vec3_origin, vec3_origin, NULL, 0);
2212 }
2213
2214 // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
2215 static void VM_CL_te_explosion2 (prvm_prog_t *prog)
2216 {
2217         vec3_t          pos, pos2, color;
2218         matrix4x4_t     tempmatrix;
2219         int                     colorStart, colorLength;
2220         unsigned char           *tempcolor;
2221         VM_SAFEPARMCOUNT(3, VM_CL_te_explosion2);
2222
2223         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2224         colorStart = (int)PRVM_G_FLOAT(OFS_PARM1);
2225         colorLength = (int)PRVM_G_FLOAT(OFS_PARM2);
2226         CL_FindNonSolidLocation(pos, pos2, 10);
2227         CL_ParticleExplosion2(pos2, colorStart, colorLength);
2228         tempcolor = palette_rgb[(rand()%colorLength) + colorStart];
2229         color[0] = tempcolor[0] * (2.0f / 255.0f);
2230         color[1] = tempcolor[1] * (2.0f / 255.0f);
2231         color[2] = tempcolor[2] * (2.0f / 255.0f);
2232         Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
2233         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);
2234         S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
2235 }
2236
2237
2238 // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
2239 static void VM_CL_te_lightning1 (prvm_prog_t *prog)
2240 {
2241         vec3_t          start, end;
2242         VM_SAFEPARMCOUNT(3, VM_CL_te_lightning1);
2243         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), start);
2244         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), end);
2245         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), start, end, cl.model_bolt, true);
2246 }
2247
2248 // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
2249 static void VM_CL_te_lightning2 (prvm_prog_t *prog)
2250 {
2251         vec3_t          start, end;
2252         VM_SAFEPARMCOUNT(3, VM_CL_te_lightning2);
2253         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), start);
2254         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), end);
2255         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), start, end, cl.model_bolt2, true);
2256 }
2257
2258 // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
2259 static void VM_CL_te_lightning3 (prvm_prog_t *prog)
2260 {
2261         vec3_t          start, end;
2262         VM_SAFEPARMCOUNT(3, VM_CL_te_lightning3);
2263         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), start);
2264         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), end);
2265         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), start, end, cl.model_bolt3, false);
2266 }
2267
2268 // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
2269 static void VM_CL_te_beam (prvm_prog_t *prog)
2270 {
2271         vec3_t          start, end;
2272         VM_SAFEPARMCOUNT(3, VM_CL_te_beam);
2273         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), start);
2274         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), end);
2275         CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), start, end, cl.model_beam, false);
2276 }
2277
2278 // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
2279 static void VM_CL_te_plasmaburn (prvm_prog_t *prog)
2280 {
2281         vec3_t          pos, pos2;
2282         VM_SAFEPARMCOUNT(1, VM_CL_te_plasmaburn);
2283
2284         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2285         CL_FindNonSolidLocation(pos, pos2, 4);
2286         CL_ParticleEffect(EFFECT_TE_PLASMABURN, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
2287 }
2288
2289 // #457 void(vector org, vector velocity, float howmany) te_flamejet (DP_TE_FLAMEJET)
2290 static void VM_CL_te_flamejet (prvm_prog_t *prog)
2291 {
2292         vec3_t          pos, pos2, vel;
2293         VM_SAFEPARMCOUNT(3, VM_CL_te_flamejet);
2294         if (PRVM_G_FLOAT(OFS_PARM2) < 1)
2295                 return;
2296         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), pos);
2297         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), vel);
2298         CL_FindNonSolidLocation(pos, pos2, 4);
2299         CL_ParticleEffect(EFFECT_TE_FLAMEJET, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, vel, vel, NULL, 0);
2300 }
2301
2302
2303 // #443 void(entity e, entity tagentity, string tagname) setattachment
2304 static void VM_CL_setattachment (prvm_prog_t *prog)
2305 {
2306         prvm_edict_t *e;
2307         prvm_edict_t *tagentity;
2308         const char *tagname;
2309         int modelindex;
2310         int tagindex;
2311         dp_model_t *model;
2312         VM_SAFEPARMCOUNT(3, VM_CL_setattachment);
2313
2314         e = PRVM_G_EDICT(OFS_PARM0);
2315         tagentity = PRVM_G_EDICT(OFS_PARM1);
2316         tagname = PRVM_G_STRING(OFS_PARM2);
2317
2318         if (e == prog->edicts)
2319         {
2320                 VM_Warning(prog, "setattachment: can not modify world entity\n");
2321                 return;
2322         }
2323         if (e->priv.server->free)
2324         {
2325                 VM_Warning(prog, "setattachment: can not modify free entity\n");
2326                 return;
2327         }
2328
2329         if (tagentity == NULL)
2330                 tagentity = prog->edicts;
2331
2332         tagindex = 0;
2333         if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
2334         {
2335                 modelindex = (int)PRVM_clientedictfloat(tagentity, modelindex);
2336                 model = CL_GetModelByIndex(modelindex);
2337                 if (model)
2338                 {
2339                         tagindex = Mod_Alias_GetTagIndexForName(model, (int)PRVM_clientedictfloat(tagentity, skin), tagname);
2340                         if (tagindex == 0)
2341                                 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);
2342                 }
2343                 else
2344                         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));
2345         }
2346
2347         PRVM_clientedictedict(e, tag_entity) = PRVM_EDICT_TO_PROG(tagentity);
2348         PRVM_clientedictfloat(e, tag_index) = tagindex;
2349 }
2350
2351 /////////////////////////////////////////
2352 // DP_MD3_TAGINFO extension coded by VorteX
2353
2354 static int CL_GetTagIndex (prvm_prog_t *prog, prvm_edict_t *e, const char *tagname)
2355 {
2356         dp_model_t *model = CL_GetModelFromEdict(e);
2357         if (model)
2358                 return Mod_Alias_GetTagIndexForName(model, (int)PRVM_clientedictfloat(e, skin), tagname);
2359         else
2360                 return -1;
2361 }
2362
2363 static int CL_GetExtendedTagInfo (prvm_prog_t *prog, prvm_edict_t *e, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)
2364 {
2365         int r;
2366         dp_model_t *model;
2367
2368         *tagname = NULL;
2369         *parentindex = 0;
2370         Matrix4x4_CreateIdentity(tag_localmatrix);
2371
2372         if (tagindex >= 0
2373          && (model = CL_GetModelFromEdict(e))
2374          && model->animscenes)
2375         {
2376                 r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)PRVM_clientedictfloat(e, skin), e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);
2377
2378                 if(!r) // success?
2379                         *parentindex += 1;
2380
2381                 return r;
2382         }
2383
2384         return 1;
2385 }
2386
2387 int CL_GetPitchSign(prvm_prog_t *prog, prvm_edict_t *ent)
2388 {
2389         dp_model_t *model;
2390         if ((model = CL_GetModelFromEdict(ent)) && model->type == mod_alias)
2391                 return -1;
2392         return 1;
2393 }
2394
2395 void CL_GetEntityMatrix (prvm_prog_t *prog, prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
2396 {
2397         float scale;
2398         float pitchsign = 1;
2399
2400         scale = PRVM_clientedictfloat(ent, scale);
2401         if (!scale)
2402                 scale = 1.0f;
2403
2404         if(viewmatrix)
2405                 *out = r_refdef.view.matrix;
2406         else if ((int)PRVM_clientedictfloat(ent, renderflags) & RF_USEAXIS)
2407         {
2408                 vec3_t forward;
2409                 vec3_t left;
2410                 vec3_t up;
2411                 vec3_t origin;
2412                 VectorScale(PRVM_clientglobalvector(v_forward), scale, forward);
2413                 VectorScale(PRVM_clientglobalvector(v_right), -scale, left);
2414                 VectorScale(PRVM_clientglobalvector(v_up), scale, up);
2415                 VectorCopy(PRVM_clientedictvector(ent, origin), origin);
2416                 Matrix4x4_FromVectors(out, forward, left, up, origin);
2417         }
2418         else
2419         {
2420                 pitchsign = CL_GetPitchSign(prog, ent);
2421                 Matrix4x4_CreateFromQuakeEntity(out, PRVM_clientedictvector(ent, origin)[0], PRVM_clientedictvector(ent, origin)[1], PRVM_clientedictvector(ent, origin)[2], pitchsign * PRVM_clientedictvector(ent, angles)[0], PRVM_clientedictvector(ent, angles)[1], PRVM_clientedictvector(ent, angles)[2], scale);
2422         }
2423 }
2424
2425 static int CL_GetEntityLocalTagMatrix(prvm_prog_t *prog, prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
2426 {
2427         dp_model_t *model;
2428         if (tagindex >= 0
2429          && (model = CL_GetModelFromEdict(ent))
2430          && model->animscenes)
2431         {
2432                 VM_GenerateFrameGroupBlend(prog, ent->priv.server->framegroupblend, ent);
2433                 VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model, cl.time);
2434                 VM_UpdateEdictSkeleton(prog, ent, model, ent->priv.server->frameblend);
2435                 return Mod_Alias_GetTagMatrix(model, ent->priv.server->frameblend, &ent->priv.server->skeleton, tagindex, out);
2436         }
2437         *out = identitymatrix;
2438         return 0;
2439 }
2440
2441 // Warnings/errors code:
2442 // 0 - normal (everything all-right)
2443 // 1 - world entity
2444 // 2 - free entity
2445 // 3 - null or non-precached model
2446 // 4 - no tags with requested index
2447 // 5 - runaway loop at attachment chain
2448 extern cvar_t cl_bob;
2449 extern cvar_t cl_bobcycle;
2450 extern cvar_t cl_bobup;
2451 int CL_GetTagMatrix (prvm_prog_t *prog, matrix4x4_t *out, prvm_edict_t *ent, int tagindex, prvm_vec_t *shadingorigin)
2452 {
2453         int ret;
2454         int attachloop;
2455         matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
2456         dp_model_t *model;
2457
2458         *out = identitymatrix; // warnings and errors return identical matrix
2459
2460         if (ent == prog->edicts)
2461                 return 1;
2462         if (ent->priv.server->free)
2463                 return 2;
2464
2465         model = CL_GetModelFromEdict(ent);
2466         if(!model)
2467                 return 3;
2468
2469         tagmatrix = identitymatrix;
2470         attachloop = 0;
2471         for(;;)
2472         {
2473                 if(attachloop >= 256)
2474                         return 5;
2475                 // apply transformation by child's tagindex on parent entity and then
2476                 // by parent entity itself
2477                 ret = CL_GetEntityLocalTagMatrix(prog, ent, tagindex - 1, &attachmatrix);
2478                 if(ret && attachloop == 0)
2479                         return ret;
2480                 CL_GetEntityMatrix(prog, ent, &entitymatrix, false);
2481                 Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
2482                 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2483                 // next iteration we process the parent entity
2484                 if (PRVM_clientedictedict(ent, tag_entity))
2485                 {
2486                         tagindex = (int)PRVM_clientedictfloat(ent, tag_index);
2487                         ent = PRVM_EDICT_NUM(PRVM_clientedictedict(ent, tag_entity));
2488                 }
2489                 else
2490                         break;
2491                 attachloop++;
2492         }
2493
2494         // RENDER_VIEWMODEL magic
2495         if ((int)PRVM_clientedictfloat(ent, renderflags) & RF_VIEWMODEL)
2496         {
2497                 Matrix4x4_Copy(&tagmatrix, out);
2498
2499                 CL_GetEntityMatrix(prog, prog->edicts, &entitymatrix, true);
2500                 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2501
2502                 /*
2503                 // Cl_bob, ported from rendering code
2504                 if (PRVM_clientedictfloat(ent, health) > 0 && cl_bob.value && cl_bobcycle.value)
2505                 {
2506                         double bob, cycle;
2507                         // LordHavoc: this code is *weird*, but not replacable (I think it
2508                         // should be done in QC on the server, but oh well, quake is quake)
2509                         // LordHavoc: figured out bobup: the time at which the sin is at 180
2510                         // degrees (which allows lengthening or squishing the peak or valley)
2511                         cycle = cl.time/cl_bobcycle.value;
2512                         cycle -= (int)cycle;
2513                         if (cycle < cl_bobup.value)
2514                                 cycle = sin(M_PI * cycle / cl_bobup.value);
2515                         else
2516                                 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
2517                         // bob is proportional to velocity in the xy plane
2518                         // (don't count Z, or jumping messes it up)
2519                         bob = sqrt(PRVM_clientedictvector(ent, velocity)[0]*PRVM_clientedictvector(ent, velocity)[0] + PRVM_clientedictvector(ent, velocity)[1]*PRVM_clientedictvector(ent, velocity)[1])*cl_bob.value;
2520                         bob = bob*0.3 + bob*0.7*cycle;
2521                         Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
2522                 }
2523                 */
2524
2525                 // return the origin of the view
2526                 if (shadingorigin)
2527                         Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, shadingorigin);
2528         }
2529         else
2530         {
2531                 // return the origin of the root entity in the chain
2532                 if (shadingorigin)
2533                         Matrix4x4_OriginFromMatrix(out, shadingorigin);
2534         }
2535         return 0;
2536 }
2537
2538 // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
2539 static void VM_CL_gettagindex (prvm_prog_t *prog)
2540 {
2541         prvm_edict_t *ent;
2542         const char *tag_name;
2543         int tag_index;
2544
2545         VM_SAFEPARMCOUNT(2, VM_CL_gettagindex);
2546
2547         ent = PRVM_G_EDICT(OFS_PARM0);
2548         tag_name = PRVM_G_STRING(OFS_PARM1);
2549         if (ent == prog->edicts)
2550         {
2551                 VM_Warning(prog, "VM_CL_gettagindex(entity #%i): can't affect world entity\n", PRVM_NUM_FOR_EDICT(ent));
2552                 return;
2553         }
2554         if (ent->priv.server->free)
2555         {
2556                 VM_Warning(prog, "VM_CL_gettagindex(entity #%i): can't affect free entity\n", PRVM_NUM_FOR_EDICT(ent));
2557                 return;
2558         }
2559
2560         tag_index = 0;
2561         if (!CL_GetModelFromEdict(ent))
2562                 Con_DPrintf("VM_CL_gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
2563         else
2564         {
2565                 tag_index = CL_GetTagIndex(prog, ent, tag_name);
2566                 if (tag_index == 0)
2567                         if(developer_extra.integer)
2568                                 Con_DPrintf("VM_CL_gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
2569         }
2570         PRVM_G_FLOAT(OFS_RETURN) = tag_index;
2571 }
2572
2573 // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
2574 static void VM_CL_gettaginfo (prvm_prog_t *prog)
2575 {
2576         prvm_edict_t *e;
2577         int tagindex;
2578         matrix4x4_t tag_matrix;
2579         matrix4x4_t tag_localmatrix;
2580         int parentindex;
2581         const char *tagname;
2582         int returncode;
2583         vec3_t forward, left, up, origin;
2584         const dp_model_t *model;
2585
2586         VM_SAFEPARMCOUNT(2, VM_CL_gettaginfo);
2587
2588         e = PRVM_G_EDICT(OFS_PARM0);
2589         tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
2590         returncode = CL_GetTagMatrix(prog, &tag_matrix, e, tagindex, NULL);
2591         Matrix4x4_ToVectors(&tag_matrix, forward, left, up, origin);
2592         VectorCopy(forward, PRVM_clientglobalvector(v_forward));
2593         VectorScale(left, -1, PRVM_clientglobalvector(v_right));
2594         VectorCopy(up, PRVM_clientglobalvector(v_up));
2595         VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
2596         model = CL_GetModelFromEdict(e);
2597         VM_GenerateFrameGroupBlend(prog, e->priv.server->framegroupblend, e);
2598         VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model, cl.time);
2599         VM_UpdateEdictSkeleton(prog, e, model, e->priv.server->frameblend);
2600         CL_GetExtendedTagInfo(prog, e, tagindex, &parentindex, &tagname, &tag_localmatrix);
2601         Matrix4x4_ToVectors(&tag_localmatrix, forward, left, up, origin);
2602
2603         PRVM_clientglobalfloat(gettaginfo_parent) = parentindex;
2604         PRVM_clientglobalstring(gettaginfo_name) = tagname ? PRVM_SetTempString(prog, tagname) : 0;
2605         VectorCopy(forward, PRVM_clientglobalvector(gettaginfo_forward));
2606         VectorScale(left, -1, PRVM_clientglobalvector(gettaginfo_right));
2607         VectorCopy(up, PRVM_clientglobalvector(gettaginfo_up));
2608         VectorCopy(origin, PRVM_clientglobalvector(gettaginfo_offset));
2609
2610         switch(returncode)
2611         {
2612                 case 1:
2613                         VM_Warning(prog, "gettagindex: can't affect world entity\n");
2614                         break;
2615                 case 2:
2616                         VM_Warning(prog, "gettagindex: can't affect free entity\n");
2617                         break;
2618                 case 3:
2619                         Con_DPrintf("CL_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
2620                         break;
2621                 case 4:
2622                         Con_DPrintf("CL_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", PRVM_NUM_FOR_EDICT(e), tagindex);
2623                         break;
2624                 case 5:
2625                         Con_DPrintf("CL_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", PRVM_NUM_FOR_EDICT(e));
2626                         break;
2627         }
2628 }
2629
2630 //============================================================================
2631
2632 //====================
2633 // DP_CSQC_SPAWNPARTICLE
2634 // a QC hook to engine's CL_NewParticle
2635 //====================
2636
2637 // particle theme struct
2638 typedef struct vmparticletheme_s
2639 {
2640         unsigned short typeindex;
2641         qboolean initialized;
2642         pblend_t blendmode;
2643         porientation_t orientation;
2644         int color1;
2645         int color2;
2646         int tex;
2647         float size;
2648         float sizeincrease;
2649         float alpha;
2650         float alphafade;
2651         float gravity;
2652         float bounce;
2653         float airfriction;
2654         float liquidfriction;
2655         float originjitter;
2656         float velocityjitter;
2657         qboolean qualityreduction;
2658         float lifetime;
2659         float stretch;
2660         int staincolor1;
2661         int staincolor2;
2662         int staintex;
2663         float stainalpha;
2664         float stainsize;
2665         float delayspawn;
2666         float delaycollision;
2667         float angle;
2668         float spin;
2669 }vmparticletheme_t;
2670
2671 // particle spawner
2672 typedef struct vmparticlespawner_s
2673 {
2674         mempool_t                       *pool;
2675         qboolean                        initialized;
2676         qboolean                        verified;
2677         vmparticletheme_t       *themes;
2678         int                                     max_themes;
2679 }vmparticlespawner_t;
2680
2681 vmparticlespawner_t vmpartspawner;
2682
2683 // TODO: automatic max_themes grow
2684 static void VM_InitParticleSpawner (prvm_prog_t *prog, int maxthemes)
2685 {
2686         // bound max themes to not be an insane value
2687         if (maxthemes < 4)
2688                 maxthemes = 4;
2689         if (maxthemes > 2048)
2690                 maxthemes = 2048;
2691         // allocate and set up structure
2692         if (vmpartspawner.initialized) // reallocate
2693         {
2694                 Mem_FreePool(&vmpartspawner.pool);
2695                 memset(&vmpartspawner, 0, sizeof(vmparticlespawner_t));
2696         }
2697         vmpartspawner.pool = Mem_AllocPool("VMPARTICLESPAWNER", 0, NULL);
2698         vmpartspawner.themes = (vmparticletheme_t *)Mem_Alloc(vmpartspawner.pool, sizeof(vmparticletheme_t)*maxthemes);
2699         vmpartspawner.max_themes = maxthemes;
2700         vmpartspawner.initialized = true;
2701         vmpartspawner.verified = true;
2702 }
2703
2704 // reset particle theme to default values
2705 static void VM_ResetParticleTheme (vmparticletheme_t *theme)
2706 {
2707         theme->initialized = true;
2708         theme->typeindex = pt_static;
2709         theme->blendmode = PBLEND_ADD;
2710         theme->orientation = PARTICLE_BILLBOARD;
2711         theme->color1 = 0x808080;
2712         theme->color2 = 0xFFFFFF;
2713         theme->tex = 63;
2714         theme->size = 2;
2715         theme->sizeincrease = 0;
2716         theme->alpha = 256;
2717         theme->alphafade = 512;
2718         theme->gravity = 0.0f;
2719         theme->bounce = 0.0f;
2720         theme->airfriction = 1.0f;
2721         theme->liquidfriction = 4.0f;
2722         theme->originjitter = 0.0f;
2723         theme->velocityjitter = 0.0f;
2724         theme->qualityreduction = false;
2725         theme->lifetime = 4;
2726         theme->stretch = 1;
2727         theme->staincolor1 = -1;
2728         theme->staincolor2 = -1;
2729         theme->staintex = -1;
2730         theme->delayspawn = 0.0f;
2731         theme->delaycollision = 0.0f;
2732         theme->angle = 0.0f;
2733         theme->spin = 0.0f;
2734 }
2735
2736 // particle theme -> QC globals
2737 static void VM_CL_ParticleThemeToGlobals(vmparticletheme_t *theme, prvm_prog_t *prog)
2738 {
2739         PRVM_clientglobalfloat(particle_type) = theme->typeindex;
2740         PRVM_clientglobalfloat(particle_blendmode) = theme->blendmode;
2741         PRVM_clientglobalfloat(particle_orientation) = theme->orientation;
2742         // VorteX: int only can store 0-255, not 0-256 which means 0 - 0,99609375...
2743         VectorSet(PRVM_clientglobalvector(particle_color1), (theme->color1 >> 16) & 0xFF, (theme->color1 >> 8) & 0xFF, (theme->color1 >> 0) & 0xFF);
2744         VectorSet(PRVM_clientglobalvector(particle_color2), (theme->color2 >> 16) & 0xFF, (theme->color2 >> 8) & 0xFF, (theme->color2 >> 0) & 0xFF);
2745         PRVM_clientglobalfloat(particle_tex) = (prvm_vec_t)theme->tex;
2746         PRVM_clientglobalfloat(particle_size) = theme->size;
2747         PRVM_clientglobalfloat(particle_sizeincrease) = theme->sizeincrease;
2748         PRVM_clientglobalfloat(particle_alpha) = theme->alpha/256;
2749         PRVM_clientglobalfloat(particle_alphafade) = theme->alphafade/256;
2750         PRVM_clientglobalfloat(particle_time) = theme->lifetime;
2751         PRVM_clientglobalfloat(particle_gravity) = theme->gravity;
2752         PRVM_clientglobalfloat(particle_bounce) = theme->bounce;
2753         PRVM_clientglobalfloat(particle_airfriction) = theme->airfriction;
2754         PRVM_clientglobalfloat(particle_liquidfriction) = theme->liquidfriction;
2755         PRVM_clientglobalfloat(particle_originjitter) = theme->originjitter;
2756         PRVM_clientglobalfloat(particle_velocityjitter) = theme->velocityjitter;
2757         PRVM_clientglobalfloat(particle_qualityreduction) = theme->qualityreduction;
2758         PRVM_clientglobalfloat(particle_stretch) = theme->stretch;
2759         VectorSet(PRVM_clientglobalvector(particle_staincolor1), ((int)theme->staincolor1 >> 16) & 0xFF, ((int)theme->staincolor1 >> 8) & 0xFF, ((int)theme->staincolor1 >> 0) & 0xFF);
2760         VectorSet(PRVM_clientglobalvector(particle_staincolor2), ((int)theme->staincolor2 >> 16) & 0xFF, ((int)theme->staincolor2 >> 8) & 0xFF, ((int)theme->staincolor2 >> 0) & 0xFF);
2761         PRVM_clientglobalfloat(particle_staintex) = (prvm_vec_t)theme->staintex;
2762         PRVM_clientglobalfloat(particle_stainalpha) = (prvm_vec_t)theme->stainalpha/256;
2763         PRVM_clientglobalfloat(particle_stainsize) = (prvm_vec_t)theme->stainsize;
2764         PRVM_clientglobalfloat(particle_delayspawn) = theme->delayspawn;
2765         PRVM_clientglobalfloat(particle_delaycollision) = theme->delaycollision;
2766         PRVM_clientglobalfloat(particle_angle) = theme->angle;
2767         PRVM_clientglobalfloat(particle_spin) = theme->spin;
2768 }
2769
2770 // QC globals ->  particle theme
2771 static void VM_CL_ParticleThemeFromGlobals(vmparticletheme_t *theme, prvm_prog_t *prog)
2772 {
2773         theme->typeindex = (unsigned short)PRVM_clientglobalfloat(particle_type);
2774         theme->blendmode = (pblend_t)(int)PRVM_clientglobalfloat(particle_blendmode);
2775         theme->orientation = (porientation_t)(int)PRVM_clientglobalfloat(particle_orientation);
2776         theme->color1 = ((int)PRVM_clientglobalvector(particle_color1)[0] << 16) + ((int)PRVM_clientglobalvector(particle_color1)[1] << 8) + ((int)PRVM_clientglobalvector(particle_color1)[2]);
2777         theme->color2 = ((int)PRVM_clientglobalvector(particle_color2)[0] << 16) + ((int)PRVM_clientglobalvector(particle_color2)[1] << 8) + ((int)PRVM_clientglobalvector(particle_color2)[2]);
2778         theme->tex = (int)PRVM_clientglobalfloat(particle_tex);
2779         theme->size = PRVM_clientglobalfloat(particle_size);
2780         theme->sizeincrease = PRVM_clientglobalfloat(particle_sizeincrease);
2781         theme->alpha = PRVM_clientglobalfloat(particle_alpha)*256;
2782         theme->alphafade = PRVM_clientglobalfloat(particle_alphafade)*256;
2783         theme->lifetime = PRVM_clientglobalfloat(particle_time);
2784         theme->gravity = PRVM_clientglobalfloat(particle_gravity);
2785         theme->bounce = PRVM_clientglobalfloat(particle_bounce);
2786         theme->airfriction = PRVM_clientglobalfloat(particle_airfriction);
2787         theme->liquidfriction = PRVM_clientglobalfloat(particle_liquidfriction);
2788         theme->originjitter = PRVM_clientglobalfloat(particle_originjitter);
2789         theme->velocityjitter = PRVM_clientglobalfloat(particle_velocityjitter);
2790         theme->qualityreduction = PRVM_clientglobalfloat(particle_qualityreduction) != 0 ? true : false;
2791         theme->stretch = PRVM_clientglobalfloat(particle_stretch);
2792         theme->staincolor1 = ((int)PRVM_clientglobalvector(particle_staincolor1)[0])*65536 + (int)(PRVM_clientglobalvector(particle_staincolor1)[1])*256 + (int)(PRVM_clientglobalvector(particle_staincolor1)[2]);
2793         theme->staincolor2 = (int)(PRVM_clientglobalvector(particle_staincolor2)[0])*65536 + (int)(PRVM_clientglobalvector(particle_staincolor2)[1])*256 + (int)(PRVM_clientglobalvector(particle_staincolor2)[2]);
2794         theme->staintex =(int)PRVM_clientglobalfloat(particle_staintex);
2795         theme->stainalpha = PRVM_clientglobalfloat(particle_stainalpha)*256;
2796         theme->stainsize = PRVM_clientglobalfloat(particle_stainsize);
2797         theme->delayspawn = PRVM_clientglobalfloat(particle_delayspawn);
2798         theme->delaycollision = PRVM_clientglobalfloat(particle_delaycollision);
2799         theme->angle = PRVM_clientglobalfloat(particle_angle);
2800         theme->spin = PRVM_clientglobalfloat(particle_spin);
2801 }
2802
2803 // init particle spawner interface
2804 // # float(float max_themes) initparticlespawner
2805 static void VM_CL_InitParticleSpawner (prvm_prog_t *prog)
2806 {
2807         VM_SAFEPARMCOUNTRANGE(0, 1, VM_CL_InitParticleSpawner);
2808         VM_InitParticleSpawner(prog, (int)PRVM_G_FLOAT(OFS_PARM0));
2809         vmpartspawner.themes[0].initialized = true;
2810         VM_ResetParticleTheme(&vmpartspawner.themes[0]);
2811         PRVM_G_FLOAT(OFS_RETURN) = (vmpartspawner.verified == true) ? 1 : 0;
2812 }
2813
2814 // void() resetparticle
2815 static void VM_CL_ResetParticle (prvm_prog_t *prog)
2816 {
2817         VM_SAFEPARMCOUNT(0, VM_CL_ResetParticle);
2818         if (vmpartspawner.verified == false)
2819         {
2820                 VM_Warning(prog, "VM_CL_ResetParticle: particle spawner not initialized\n");
2821                 return;
2822         }
2823         VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0], prog);
2824 }
2825
2826 // void(float themenum) particletheme
2827 static void VM_CL_ParticleTheme (prvm_prog_t *prog)
2828 {
2829         int themenum;
2830
2831         VM_SAFEPARMCOUNT(1, VM_CL_ParticleTheme);
2832         if (vmpartspawner.verified == false)
2833         {
2834                 VM_Warning(prog, "VM_CL_ParticleTheme: particle spawner not initialized\n");
2835                 return;
2836         }
2837         themenum = (int)PRVM_G_FLOAT(OFS_PARM0);
2838         if (themenum < 0 || themenum >= vmpartspawner.max_themes)
2839         {
2840                 VM_Warning(prog, "VM_CL_ParticleTheme: bad theme number %i\n", themenum);
2841                 VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0], prog);
2842                 return;
2843         }
2844         if (vmpartspawner.themes[themenum].initialized == false)
2845         {
2846                 VM_Warning(prog, "VM_CL_ParticleTheme: theme #%i not exists\n", themenum);
2847                 VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0], prog);
2848                 return;
2849         }
2850         // load particle theme into globals
2851         VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[themenum], prog);
2852 }
2853
2854 // float() saveparticletheme
2855 // void(float themenum) updateparticletheme
2856 static void VM_CL_ParticleThemeSave (prvm_prog_t *prog)
2857 {
2858         int themenum;
2859
2860         VM_SAFEPARMCOUNTRANGE(0, 1, VM_CL_ParticleThemeSave);
2861         if (vmpartspawner.verified == false)
2862         {
2863                 VM_Warning(prog, "VM_CL_ParticleThemeSave: particle spawner not initialized\n");
2864                 return;
2865         }
2866         // allocate new theme, save it and return
2867         if (prog->argc < 1)
2868         {
2869                 for (themenum = 0; themenum < vmpartspawner.max_themes; themenum++)
2870                         if (vmpartspawner.themes[themenum].initialized == false)
2871                                 break;
2872                 if (themenum >= vmpartspawner.max_themes)
2873                 {
2874                         if (vmpartspawner.max_themes == 2048)
2875                                 VM_Warning(prog, "VM_CL_ParticleThemeSave: no free theme slots\n");
2876                         else
2877                                 VM_Warning(prog, "VM_CL_ParticleThemeSave: no free theme slots, try initparticlespawner() with highter max_themes\n");
2878                         PRVM_G_FLOAT(OFS_RETURN) = -1;
2879                         return;
2880                 }
2881                 vmpartspawner.themes[themenum].initialized = true;
2882                 VM_CL_ParticleThemeFromGlobals(&vmpartspawner.themes[themenum], prog);
2883                 PRVM_G_FLOAT(OFS_RETURN) = themenum;
2884                 return;
2885         }
2886         // update existing theme
2887         themenum = (int)PRVM_G_FLOAT(OFS_PARM0);
2888         if (themenum < 0 || themenum >= vmpartspawner.max_themes)
2889         {
2890                 VM_Warning(prog, "VM_CL_ParticleThemeSave: bad theme number %i\n", themenum);
2891                 return;
2892         }
2893         vmpartspawner.themes[themenum].initialized = true;
2894         VM_CL_ParticleThemeFromGlobals(&vmpartspawner.themes[themenum], prog);
2895 }
2896
2897 // void(float themenum) freeparticletheme
2898 static void VM_CL_ParticleThemeFree (prvm_prog_t *prog)
2899 {
2900         int themenum;
2901
2902         VM_SAFEPARMCOUNT(1, VM_CL_ParticleThemeFree);
2903         if (vmpartspawner.verified == false)
2904         {
2905                 VM_Warning(prog, "VM_CL_ParticleThemeFree: particle spawner not initialized\n");
2906                 return;
2907         }
2908         themenum = (int)PRVM_G_FLOAT(OFS_PARM0);
2909         // check parms
2910         if (themenum <= 0 || themenum >= vmpartspawner.max_themes)
2911         {
2912                 VM_Warning(prog, "VM_CL_ParticleThemeFree: bad theme number %i\n", themenum);
2913                 return;
2914         }
2915         if (vmpartspawner.themes[themenum].initialized == false)
2916         {
2917                 VM_Warning(prog, "VM_CL_ParticleThemeFree: theme #%i already freed\n", themenum);
2918                 VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0], prog);
2919                 return;
2920         }
2921         // free theme
2922         VM_ResetParticleTheme(&vmpartspawner.themes[themenum]);
2923         vmpartspawner.themes[themenum].initialized = false;
2924 }
2925
2926 // float(vector org, vector dir, [float theme]) particle
2927 // returns 0 if failed, 1 if succesful
2928 static void VM_CL_SpawnParticle (prvm_prog_t *prog)
2929 {
2930         vec3_t org, dir;
2931         vmparticletheme_t *theme;
2932         particle_t *part;
2933         int themenum;
2934
2935         VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_SpawnParticle2);
2936         if (vmpartspawner.verified == false)
2937         {
2938                 VM_Warning(prog, "VM_CL_SpawnParticle: particle spawner not initialized\n");
2939                 PRVM_G_FLOAT(OFS_RETURN) = 0;
2940                 return;
2941         }
2942         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
2943         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), dir);
2944
2945         if (prog->argc < 3) // global-set particle
2946         {
2947                 part = CL_NewParticle(org,
2948                         (unsigned short)PRVM_clientglobalfloat(particle_type),
2949                         ((int)PRVM_clientglobalvector(particle_color1)[0] << 16) + ((int)PRVM_clientglobalvector(particle_color1)[1] << 8) + ((int)PRVM_clientglobalvector(particle_color1)[2]),
2950                         ((int)PRVM_clientglobalvector(particle_color2)[0] << 16) + ((int)PRVM_clientglobalvector(particle_color2)[1] << 8) + ((int)PRVM_clientglobalvector(particle_color2)[2]),
2951                         (int)PRVM_clientglobalfloat(particle_tex),
2952                         PRVM_clientglobalfloat(particle_size),
2953                         PRVM_clientglobalfloat(particle_sizeincrease),
2954                         PRVM_clientglobalfloat(particle_alpha)*256,
2955                         PRVM_clientglobalfloat(particle_alphafade)*256,
2956                         PRVM_clientglobalfloat(particle_gravity),
2957                         PRVM_clientglobalfloat(particle_bounce),
2958                         org[0],
2959                         org[1],
2960                         org[2],
2961                         dir[0],
2962                         dir[1],
2963                         dir[2],
2964                         PRVM_clientglobalfloat(particle_airfriction),
2965                         PRVM_clientglobalfloat(particle_liquidfriction),
2966                         PRVM_clientglobalfloat(particle_originjitter),
2967                         PRVM_clientglobalfloat(particle_velocityjitter),
2968                         (PRVM_clientglobalfloat(particle_qualityreduction)) ? true : false,
2969                         PRVM_clientglobalfloat(particle_time),
2970                         PRVM_clientglobalfloat(particle_stretch),
2971                         (pblend_t)(int)PRVM_clientglobalfloat(particle_blendmode),
2972                         (porientation_t)(int)PRVM_clientglobalfloat(particle_orientation),
2973                         (int)(PRVM_clientglobalvector(particle_staincolor1)[0])*65536 + (int)(PRVM_clientglobalvector(particle_staincolor1)[1])*256 + (int)(PRVM_clientglobalvector(particle_staincolor1)[2]),
2974                         (int)(PRVM_clientglobalvector(particle_staincolor2)[0])*65536 + (int)(PRVM_clientglobalvector(particle_staincolor2)[1])*256 + (int)(PRVM_clientglobalvector(particle_staincolor2)[2]),
2975                         (int)PRVM_clientglobalfloat(particle_staintex),
2976                         PRVM_clientglobalfloat(particle_stainalpha)*256,
2977                         PRVM_clientglobalfloat(particle_stainsize),
2978                         PRVM_clientglobalfloat(particle_angle),
2979                         PRVM_clientglobalfloat(particle_spin),
2980                         NULL);
2981                 if (!part)
2982                 {
2983                         PRVM_G_FLOAT(OFS_RETURN) = 0;
2984                         return;
2985                 }
2986                 if (PRVM_clientglobalfloat(particle_delayspawn))
2987                         part->delayedspawn = cl.time + PRVM_clientglobalfloat(particle_delayspawn);
2988                 //if (PRVM_clientglobalfloat(particle_delaycollision))
2989                 //      part->delayedcollisions = cl.time + PRVM_clientglobalfloat(particle_delaycollision);
2990         }
2991         else // quick themed particle
2992         {
2993                 themenum = (int)PRVM_G_FLOAT(OFS_PARM2);
2994                 if (themenum <= 0 || themenum >= vmpartspawner.max_themes)
2995                 {
2996                         VM_Warning(prog, "VM_CL_SpawnParticle: bad theme number %i\n", themenum);
2997                         PRVM_G_FLOAT(OFS_RETURN) = 0;
2998                         return;
2999                 }
3000                 theme = &vmpartspawner.themes[themenum];
3001                 part = CL_NewParticle(org,
3002                         theme->typeindex,
3003                         theme->color1,
3004                         theme->color2,
3005                         theme->tex,
3006                         theme->size,
3007                         theme->sizeincrease,
3008                         theme->alpha,
3009                         theme->alphafade,
3010                         theme->gravity,
3011                         theme->bounce,
3012                         org[0],
3013                         org[1],
3014                         org[2],
3015                         dir[0],
3016                         dir[1],
3017                         dir[2],
3018                         theme->airfriction,
3019                         theme->liquidfriction,
3020                         theme->originjitter,
3021                         theme->velocityjitter,
3022                         theme->qualityreduction,
3023                         theme->lifetime,
3024                         theme->stretch,
3025                         theme->blendmode,
3026                         theme->orientation,
3027                         theme->staincolor1,
3028                         theme->staincolor2,
3029                         theme->staintex,
3030                         theme->stainalpha,
3031                         theme->stainsize,
3032                         theme->angle,
3033                         theme->spin,
3034                         NULL);
3035                 if (!part)
3036                 {
3037                         PRVM_G_FLOAT(OFS_RETURN) = 0;
3038                         return;
3039                 }
3040                 if (theme->delayspawn)
3041                         part->delayedspawn = cl.time + theme->delayspawn;
3042                 //if (theme->delaycollision)
3043                 //      part->delayedcollisions = cl.time + theme->delaycollision;
3044         }
3045         PRVM_G_FLOAT(OFS_RETURN) = 1;
3046 }
3047
3048 // float(vector org, vector dir, float spawndelay, float collisiondelay, [float theme]) delayedparticle
3049 // returns 0 if failed, 1 if success
3050 static void VM_CL_SpawnParticleDelayed (prvm_prog_t *prog)
3051 {
3052         vec3_t org, dir;
3053         vmparticletheme_t *theme;
3054         particle_t *part;
3055         int themenum;
3056
3057         VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_SpawnParticle2);
3058         if (vmpartspawner.verified == false)
3059         {
3060                 VM_Warning(prog, "VM_CL_SpawnParticle: particle spawner not initialized\n");
3061                 PRVM_G_FLOAT(OFS_RETURN) = 0;
3062                 return;
3063         }
3064         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
3065         VectorCopy(PRVM_G_VECTOR(OFS_PARM1), dir);
3066         if (prog->argc < 5) // global-set particle
3067                 part = CL_NewParticle(org,
3068                         (unsigned short)PRVM_clientglobalfloat(particle_type),
3069                         ((int)PRVM_clientglobalvector(particle_color1)[0] << 16) + ((int)PRVM_clientglobalvector(particle_color1)[1] << 8) + ((int)PRVM_clientglobalvector(particle_color1)[2]),
3070                         ((int)PRVM_clientglobalvector(particle_color2)[0] << 16) + ((int)PRVM_clientglobalvector(particle_color2)[1] << 8) + ((int)PRVM_clientglobalvector(particle_color2)[2]),
3071                         (int)PRVM_clientglobalfloat(particle_tex),
3072                         PRVM_clientglobalfloat(particle_size),
3073                         PRVM_clientglobalfloat(particle_sizeincrease),
3074                         PRVM_clientglobalfloat(particle_alpha)*256,
3075                         PRVM_clientglobalfloat(particle_alphafade)*256,
3076                         PRVM_clientglobalfloat(particle_gravity),
3077                         PRVM_clientglobalfloat(particle_bounce),
3078                         org[0],
3079                         org[1],
3080                         org[2],
3081                         dir[0],
3082                         dir[1],
3083                         dir[2],
3084                         PRVM_clientglobalfloat(particle_airfriction),
3085                         PRVM_clientglobalfloat(particle_liquidfriction),
3086                         PRVM_clientglobalfloat(particle_originjitter),
3087                         PRVM_clientglobalfloat(particle_velocityjitter),
3088                         (PRVM_clientglobalfloat(particle_qualityreduction)) ? true : false,
3089                         PRVM_clientglobalfloat(particle_time),
3090                         PRVM_clientglobalfloat(particle_stretch),
3091                         (pblend_t)(int)PRVM_clientglobalfloat(particle_blendmode),
3092                         (porientation_t)(int)PRVM_clientglobalfloat(particle_orientation),
3093                         ((int)PRVM_clientglobalvector(particle_staincolor1)[0] << 16) + ((int)PRVM_clientglobalvector(particle_staincolor1)[1] << 8) + ((int)PRVM_clientglobalvector(particle_staincolor1)[2]),
3094                         ((int)PRVM_clientglobalvector(particle_staincolor2)[0] << 16) + ((int)PRVM_clientglobalvector(particle_staincolor2)[1] << 8) + ((int)PRVM_clientglobalvector(particle_staincolor2)[2]),
3095                         (int)PRVM_clientglobalfloat(particle_staintex),
3096                         PRVM_clientglobalfloat(particle_stainalpha)*256,
3097                         PRVM_clientglobalfloat(particle_stainsize),
3098                         PRVM_clientglobalfloat(particle_angle),
3099                         PRVM_clientglobalfloat(particle_spin),
3100                         NULL);
3101         else // themed particle
3102         {
3103                 themenum = (int)PRVM_G_FLOAT(OFS_PARM4);
3104                 if (themenum <= 0 || themenum >= vmpartspawner.max_themes)
3105                 {
3106                         VM_Warning(prog, "VM_CL_SpawnParticle: bad theme number %i\n", themenum);
3107                         PRVM_G_FLOAT(OFS_RETURN) = 0;
3108                         return;
3109                 }
3110                 theme = &vmpartspawner.themes[themenum];
3111                 part = CL_NewParticle(org,
3112                         theme->typeindex,
3113                         theme->color1,
3114                         theme->color2,
3115                         theme->tex,
3116                         theme->size,
3117                         theme->sizeincrease,
3118                         theme->alpha,
3119                         theme->alphafade,
3120                         theme->gravity,
3121                         theme->bounce,
3122                         org[0],
3123                         org[1],
3124                         org[2],
3125                         dir[0],
3126                         dir[1],
3127                         dir[2],
3128                         theme->airfriction,
3129                         theme->liquidfriction,
3130                         theme->originjitter,
3131                         theme->velocityjitter,
3132                         theme->qualityreduction,
3133                         theme->lifetime,
3134                         theme->stretch,
3135                         theme->blendmode,
3136                         theme->orientation,
3137                         theme->staincolor1,
3138                         theme->staincolor2,
3139                         theme->staintex,
3140                         theme->stainalpha,
3141                         theme->stainsize,
3142                         theme->angle,
3143                         theme->spin,
3144                         NULL);
3145         }
3146         if (!part)
3147         {
3148                 PRVM_G_FLOAT(OFS_RETURN) = 0;
3149                 return;
3150         }
3151         part->delayedspawn = cl.time + PRVM_G_FLOAT(OFS_PARM2);
3152         //part->delayedcollisions = cl.time + PRVM_G_FLOAT(OFS_PARM3);
3153         PRVM_G_FLOAT(OFS_RETURN) = 0;
3154 }
3155
3156 //====================
3157 //CSQC engine entities query
3158 //====================
3159
3160 // float(float entitynum, float whatfld) getentity;
3161 // vector(float entitynum, float whatfld) getentityvec;
3162 // querying engine-drawn entity
3163 // VorteX: currently it's only tested with whatfld = 1..7
3164 static void VM_CL_GetEntity (prvm_prog_t *prog)
3165 {
3166         int entnum, fieldnum;
3167         vec3_t forward, left, up, org;
3168         VM_SAFEPARMCOUNT(2, VM_CL_GetEntityVec);
3169
3170         entnum = PRVM_G_FLOAT(OFS_PARM0);
3171         if (entnum < 0 || entnum >= cl.num_entities)
3172         {
3173                 PRVM_G_FLOAT(OFS_RETURN) = 0;
3174                 return;
3175         }
3176         fieldnum = PRVM_G_FLOAT(OFS_PARM1);
3177         switch(fieldnum)
3178         {
3179                 case 0: // active state
3180                         PRVM_G_FLOAT(OFS_RETURN) = cl.entities_active[entnum];
3181                         break;
3182                 case 1: // origin
3183                         Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, org);
3184                         VectorCopy(org, PRVM_G_VECTOR(OFS_RETURN));
3185                         break;
3186                 case 2: // forward
3187                         Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, forward, left, up, org);
3188                         VectorCopy(forward, PRVM_G_VECTOR(OFS_RETURN));
3189                         break;
3190                 case 3: // right
3191                         Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, forward, left, up, org);
3192                         VectorNegate(left, PRVM_G_VECTOR(OFS_RETURN));
3193                         break;
3194                 case 4: // up
3195                         Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, forward, left, up, org);
3196                         VectorCopy(up, PRVM_G_VECTOR(OFS_RETURN));
3197                         break;
3198                 case 5: // scale
3199                         PRVM_G_FLOAT(OFS_RETURN) = Matrix4x4_ScaleFromMatrix(&cl.entities[entnum].render.matrix);
3200                         break;
3201                 case 6: // origin + v_forward, v_right, v_up
3202                         Matrix4x4_ToVectors(&cl.entities[entnum].render.matrix, forward, left, up, org);
3203                         VectorCopy(forward, PRVM_clientglobalvector(v_forward));
3204                         VectorNegate(left, PRVM_clientglobalvector(v_right));
3205                         VectorCopy(up, PRVM_clientglobalvector(v_up));
3206                         VectorCopy(org, PRVM_G_VECTOR(OFS_RETURN));
3207                         break;
3208                 case 7: // alpha
3209                         PRVM_G_FLOAT(OFS_RETURN) = cl.entities[entnum].render.alpha;
3210                         break;
3211                 case 8: // colormor
3212                         VectorCopy(cl.entities[entnum].render.colormod, PRVM_G_VECTOR(OFS_RETURN));
3213                         break;
3214                 case 9: // pants colormod
3215                         VectorCopy(cl.entities[entnum].render.colormap_pantscolor, PRVM_G_VECTOR(OFS_RETURN));
3216                         break;
3217                 case 10: // shirt colormod
3218                         VectorCopy(cl.entities[entnum].render.colormap_shirtcolor, PRVM_G_VECTOR(OFS_RETURN));
3219                         break;
3220                 case 11: // skinnum
3221                         PRVM_G_FLOAT(OFS_RETURN) = cl.entities[entnum].render.skinnum;
3222                         break;
3223                 case 12: // mins
3224                         VectorCopy(cl.entities[entnum].render.mins, PRVM_G_VECTOR(OFS_RETURN));
3225                         break;
3226                 case 13: // maxs
3227                         VectorCopy(cl.entities[entnum].render.maxs, PRVM_G_VECTOR(OFS_RETURN));
3228                         break;
3229                 case 14: // absmin
3230                         Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, org);
3231                         VectorAdd(cl.entities[entnum].render.mins, org, PRVM_G_VECTOR(OFS_RETURN));
3232                         break;
3233                 case 15: // absmax
3234                         Matrix4x4_OriginFromMatrix(&cl.entities[entnum].render.matrix, org);
3235                         VectorAdd(cl.entities[entnum].render.maxs, org, PRVM_G_VECTOR(OFS_RETURN));
3236                         break;
3237                 case 16: // light
3238                         VectorMA(cl.entities[entnum].render.render_modellight_ambient, 0.5, cl.entities[entnum].render.render_modellight_diffuse, PRVM_G_VECTOR(OFS_RETURN));
3239                         break;
3240                 default:
3241                         PRVM_G_FLOAT(OFS_RETURN) = 0;
3242                         break;
3243         }
3244 }
3245
3246 //====================
3247 //QC POLYGON functions
3248 //====================
3249
3250 //#304 void() renderscene (EXT_CSQC)
3251 // moved that here to reset the polygons,
3252 // resetting them earlier causes R_Mesh_Draw to be called with numvertices = 0
3253 // --blub
3254 static void VM_CL_R_RenderScene (prvm_prog_t *prog)
3255 {
3256         double t = Sys_DirtyTime();
3257         vmpolygons_t *polys = &prog->vmpolygons;
3258         VM_SAFEPARMCOUNT(0, VM_CL_R_RenderScene);
3259
3260         // update the views
3261         if(r_refdef.view.ismain)
3262         {
3263                 // set the main view
3264                 csqc_main_r_refdef_view = r_refdef.view;
3265
3266                 // clear the flags so no other view becomes "main" unless CSQC sets VF_MAINVIEW
3267                 r_refdef.view.ismain = false;
3268                 csqc_original_r_refdef_view.ismain = false;
3269         }
3270
3271         // we need to update any RENDER_VIEWMODEL entities at this point because
3272         // csqc supplies its own view matrix
3273         CL_UpdateViewEntities();
3274         CL_UpdateEntityShading();
3275
3276         // now draw stuff!
3277         R_RenderView();
3278
3279         polys->num_vertices = polys->num_triangles = 0;
3280
3281         // callprofile fixing hack: do not include this time in what is counted for CSQC_UpdateView
3282         t = Sys_DirtyTime() - t;if (t < 0 || t >= 1800) t = 0;
3283         prog->functions[PRVM_clientfunction(CSQC_UpdateView)].totaltime -= t;
3284 }
3285
3286 static void VM_ResizePolygons(vmpolygons_t *polys)
3287 {
3288         float *oldvertex3f = polys->data_vertex3f;
3289         float *oldcolor4f = polys->data_color4f;
3290         float *oldtexcoord2f = polys->data_texcoord2f;
3291         vmpolygons_triangle_t *oldtriangles = polys->data_triangles;
3292         unsigned short *oldsortedelement3s = polys->data_sortedelement3s;
3293         polys->max_vertices = min(polys->max_triangles*3, 65536);
3294         polys->data_vertex3f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[3]));
3295         polys->data_color4f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[4]));
3296         polys->data_texcoord2f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[2]));
3297         polys->data_triangles = (vmpolygons_triangle_t *)Mem_Alloc(polys->pool, polys->max_triangles*sizeof(vmpolygons_triangle_t));
3298         polys->data_sortedelement3s = (unsigned short *)Mem_Alloc(polys->pool, polys->max_triangles*sizeof(unsigned short[3]));
3299         if (polys->num_vertices)
3300         {
3301                 memcpy(polys->data_vertex3f, oldvertex3f, polys->num_vertices*sizeof(float[3]));
3302                 memcpy(polys->data_color4f, oldcolor4f, polys->num_vertices*sizeof(float[4]));
3303                 memcpy(polys->data_texcoord2f, oldtexcoord2f, polys->num_vertices*sizeof(float[2]));
3304         }
3305         if (polys->num_triangles)
3306         {
3307                 memcpy(polys->data_triangles, oldtriangles, polys->num_triangles*sizeof(vmpolygons_triangle_t));
3308                 memcpy(polys->data_sortedelement3s, oldsortedelement3s, polys->num_triangles*sizeof(unsigned short[3]));
3309         }
3310         if (oldvertex3f)
3311                 Mem_Free(oldvertex3f);
3312         if (oldcolor4f)
3313                 Mem_Free(oldcolor4f);
3314         if (oldtexcoord2f)
3315                 Mem_Free(oldtexcoord2f);
3316         if (oldtriangles)
3317                 Mem_Free(oldtriangles);
3318         if (oldsortedelement3s)
3319                 Mem_Free(oldsortedelement3s);
3320 }
3321
3322 static void VM_InitPolygons (vmpolygons_t* polys)
3323 {
3324         memset(polys, 0, sizeof(*polys));
3325         polys->pool = Mem_AllocPool("VMPOLY", 0, NULL);
3326         polys->max_triangles = 1024;
3327         VM_ResizePolygons(polys);
3328         polys->initialized = true;
3329 }
3330
3331 static void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3332 {
3333         int surfacelistindex;
3334         vmpolygons_t *polys = (vmpolygons_t *)ent;
3335 //      R_Mesh_ResetTextureState();
3336         R_EntityMatrix(&identitymatrix);
3337         GL_CullFace(GL_NONE);
3338         GL_DepthTest(true); // polys in 3D space shall always have depth test
3339         GL_DepthRange(0, 1);
3340         R_Mesh_PrepareVertices_Generic_Arrays(polys->num_vertices, polys->data_vertex3f, polys->data_color4f, polys->data_texcoord2f);
3341
3342         for (surfacelistindex = 0;surfacelistindex < numsurfaces;)
3343         {
3344                 int numtriangles = 0;
3345                 rtexture_t *tex = polys->data_triangles[surfacelist[surfacelistindex]].texture;
3346                 int drawflag = polys->data_triangles[surfacelist[surfacelistindex]].drawflag;
3347                 DrawQ_ProcessDrawFlag(drawflag, polys->data_triangles[surfacelist[surfacelistindex]].hasalpha);
3348                 R_SetupShader_Generic(tex, NULL, GL_MODULATE, 1, false, false, false);
3349                 numtriangles = 0;
3350                 for (;surfacelistindex < numsurfaces;surfacelistindex++)
3351                 {
3352                         if (polys->data_triangles[surfacelist[surfacelistindex]].texture != tex || polys->data_triangles[surfacelist[surfacelistindex]].drawflag != drawflag)
3353                                 break;
3354                         VectorCopy(polys->data_triangles[surfacelist[surfacelistindex]].elements, polys->data_sortedelement3s + 3*numtriangles);
3355                         numtriangles++;
3356                 }
3357                 R_Mesh_Draw(0, polys->num_vertices, 0, numtriangles, NULL, NULL, 0, polys->data_sortedelement3s, NULL, 0);
3358         }
3359 }
3360
3361 static void VMPolygons_Store(vmpolygons_t *polys)
3362 {
3363         qboolean hasalpha;
3364         int i;
3365
3366         // detect if we have alpha
3367         hasalpha = polys->begin_texture_hasalpha;
3368         for(i = 0; !hasalpha && (i < polys->begin_vertices); ++i)
3369                 if(polys->begin_color[i][3] < 1)
3370                         hasalpha = true;
3371
3372         if (polys->begin_draw2d)
3373         {
3374                 // draw the polygon as 2D immediately
3375                 drawqueuemesh_t mesh;
3376                 mesh.texture = polys->begin_texture;
3377                 mesh.num_vertices = polys->begin_vertices;
3378                 mesh.num_triangles = polys->begin_vertices-2;
3379                 mesh.data_element3i = polygonelement3i;
3380                 mesh.data_element3s = polygonelement3s;
3381                 mesh.data_vertex3f = polys->begin_vertex[0];
3382                 mesh.data_color4f = polys->begin_color[0];
3383                 mesh.data_texcoord2f = polys->begin_texcoord[0];
3384                 DrawQ_Mesh(&mesh, polys->begin_drawflag, hasalpha);
3385         }
3386         else
3387         {
3388                 // queue the polygon as 3D for sorted transparent rendering later
3389                 if (polys->max_triangles < polys->num_triangles + polys->begin_vertices-2)
3390                 {
3391                         while (polys->max_triangles < polys->num_triangles + polys->begin_vertices-2)
3392                                 polys->max_triangles *= 2;
3393                         VM_ResizePolygons(polys);
3394                 }
3395                 if (polys->num_vertices + polys->begin_vertices <= polys->max_vertices)
3396                 {
3397                         // needle in a haystack!
3398                         // polys->num_vertices was used for copying where we actually want to copy begin_vertices
3399                         // that also caused it to not render the first polygon that is added
3400                         // --blub
3401                         memcpy(polys->data_vertex3f + polys->num_vertices * 3, polys->begin_vertex[0], polys->begin_vertices * sizeof(float[3]));
3402                         memcpy(polys->data_color4f + polys->num_vertices * 4, polys->begin_color[0], polys->begin_vertices * sizeof(float[4]));
3403                         memcpy(polys->data_texcoord2f + polys->num_vertices * 2, polys->begin_texcoord[0], polys->begin_vertices * sizeof(float[2]));
3404                         for (i = 0;i < polys->begin_vertices-2;i++)
3405                         {
3406                                 polys->data_triangles[polys->num_triangles].texture = polys->begin_texture;
3407                                 polys->data_triangles[polys->num_triangles].drawflag = polys->begin_drawflag;
3408                                 polys->data_triangles[polys->num_triangles].elements[0] = polys->num_vertices;
3409                                 polys->data_triangles[polys->num_triangles].elements[1] = polys->num_vertices + i+1;
3410                                 polys->data_triangles[polys->num_triangles].elements[2] = polys->num_vertices + i+2;
3411                                 polys->data_triangles[polys->num_triangles].hasalpha = hasalpha;
3412                                 polys->num_triangles++;
3413                         }
3414                         polys->num_vertices += polys->begin_vertices;
3415                 }
3416         }
3417         polys->begin_active = false;
3418 }
3419
3420 // TODO: move this into the client code and clean-up everything else, too! [1/6/2008 Black]
3421 // LordHavoc: agreed, this is a mess
3422 void VM_CL_AddPolygonsToMeshQueue (prvm_prog_t *prog)
3423 {
3424         int i;
3425         vmpolygons_t *polys = &prog->vmpolygons;
3426         vec3_t center;
3427
3428         // only add polygons of the currently active prog to the queue - if there is none, we're done
3429         if( !prog )
3430                 return;
3431
3432         if (!polys->num_triangles)
3433                 return;
3434
3435         for (i = 0;i < polys->num_triangles;i++)
3436         {
3437                 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);
3438                 R_MeshQueue_AddTransparent(TRANSPARENTSORT_DISTANCE, center, VM_DrawPolygonCallback, (entity_render_t *)polys, i, NULL);
3439         }
3440
3441         /*polys->num_triangles = 0; // now done after rendering the scene,
3442           polys->num_vertices = 0;  // otherwise it's not rendered at all and prints an error message --blub */
3443 }
3444
3445 //void(string texturename, float flag[, float is2d]) R_BeginPolygon
3446 static void VM_CL_R_PolygonBegin (prvm_prog_t *prog)
3447 {
3448         const char              *picname;
3449         skinframe_t     *sf;
3450         vmpolygons_t *polys = &prog->vmpolygons;
3451         int tf;
3452
3453         // TODO instead of using skinframes here (which provides the benefit of
3454         // better management of flags, and is more suited for 3D rendering), what
3455         // about supporting Q3 shaders?
3456
3457         VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_R_PolygonBegin);
3458
3459         if (!polys->initialized)
3460                 VM_InitPolygons(polys);
3461         if (polys->begin_active)
3462         {
3463                 VM_Warning(prog, "VM_CL_R_PolygonBegin: called twice without VM_CL_R_PolygonBegin after first\n");
3464                 return;
3465         }
3466         picname = PRVM_G_STRING(OFS_PARM0);
3467
3468         sf = NULL;
3469         if(*picname)
3470         {
3471                 tf = TEXF_ALPHA;
3472                 if((int)PRVM_G_FLOAT(OFS_PARM1) & DRAWFLAG_MIPMAP)
3473                         tf |= TEXF_MIPMAP;
3474
3475                 do
3476                 {
3477                         sf = R_SkinFrame_FindNextByName(sf, picname);
3478                 }
3479                 while(sf && sf->textureflags != tf);
3480
3481                 if(!sf || !sf->base)
3482                         sf = R_SkinFrame_LoadExternal(picname, tf, true);
3483
3484                 if(sf)
3485                         R_SkinFrame_MarkUsed(sf);
3486         }
3487
3488         polys->begin_texture = (sf && sf->base) ? sf->base : r_texture_white;
3489         polys->begin_texture_hasalpha = (sf && sf->base) ? sf->hasalpha : false;
3490         polys->begin_drawflag = (int)PRVM_G_FLOAT(OFS_PARM1) & DRAWFLAG_MASK;
3491         polys->begin_vertices = 0;
3492         polys->begin_active = true;
3493         polys->begin_draw2d = (prog->argc >= 3 ? (int)PRVM_G_FLOAT(OFS_PARM2) : r_refdef.draw2dstage);
3494 }
3495
3496 //void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
3497 static void VM_CL_R_PolygonVertex (prvm_prog_t *prog)
3498 {
3499         vmpolygons_t *polys = &prog->vmpolygons;
3500
3501         VM_SAFEPARMCOUNT(4, VM_CL_R_PolygonVertex);
3502
3503         if (!polys->begin_active)
3504         {
3505                 VM_Warning(prog, "VM_CL_R_PolygonVertex: VM_CL_R_PolygonBegin wasn't called\n");
3506                 return;
3507         }
3508
3509         if (polys->begin_vertices >= VMPOLYGONS_MAXPOINTS)
3510         {
3511                 VM_Warning(prog, "VM_CL_R_PolygonVertex: may have %i vertices max\n", VMPOLYGONS_MAXPOINTS);
3512                 return;
3513         }
3514
3515         polys->begin_vertex[polys->begin_vertices][0] = PRVM_G_VECTOR(OFS_PARM0)[0];
3516         polys->begin_vertex[polys->begin_vertices][1] = PRVM_G_VECTOR(OFS_PARM0)[1];
3517         polys->begin_vertex[polys->begin_vertices][2] = PRVM_G_VECTOR(OFS_PARM0)[2];
3518         polys->begin_texcoord[polys->begin_vertices][0] = PRVM_G_VECTOR(OFS_PARM1)[0];
3519         polys->begin_texcoord[polys->begin_vertices][1] = PRVM_G_VECTOR(OFS_PARM1)[1];
3520         polys->begin_color[polys->begin_vertices][0] = PRVM_G_VECTOR(OFS_PARM2)[0];
3521         polys->begin_color[polys->begin_vertices][1] = PRVM_G_VECTOR(OFS_PARM2)[1];
3522         polys->begin_color[polys->begin_vertices][2] = PRVM_G_VECTOR(OFS_PARM2)[2];
3523         polys->begin_color[polys->begin_vertices][3] = PRVM_G_FLOAT(OFS_PARM3);
3524         polys->begin_vertices++;
3525 }
3526
3527 //void() R_EndPolygon
3528 static void VM_CL_R_PolygonEnd (prvm_prog_t *prog)
3529 {
3530         vmpolygons_t *polys = &prog->vmpolygons;
3531
3532         VM_SAFEPARMCOUNT(0, VM_CL_R_PolygonEnd);
3533         if (!polys->begin_active)
3534         {
3535                 VM_Warning(prog, "VM_CL_R_PolygonEnd: VM_CL_R_PolygonBegin wasn't called\n");
3536                 return;
3537         }
3538         polys->begin_active = false;
3539         if (polys->begin_vertices >= 3)
3540                 VMPolygons_Store(polys);
3541         else
3542                 VM_Warning(prog, "VM_CL_R_PolygonEnd: %i vertices isn't a good choice\n", polys->begin_vertices);
3543 }
3544
3545 /*
3546 =============
3547 CL_CheckBottom
3548
3549 Returns false if any part of the bottom of the entity is off an edge that
3550 is not a staircase.
3551
3552 =============
3553 */
3554 static qboolean CL_CheckBottom (prvm_edict_t *ent)
3555 {
3556         prvm_prog_t *prog = CLVM_prog;
3557         vec3_t  mins, maxs, start, stop;
3558         trace_t trace;
3559         int             x, y;
3560         float   mid, bottom;
3561
3562         VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, mins), mins);
3563         VectorAdd (PRVM_clientedictvector(ent, origin), PRVM_clientedictvector(ent, maxs), maxs);
3564
3565 // if all of the points under the corners are solid world, don't bother
3566 // with the tougher checks
3567 // the corners must be within 16 of the midpoint
3568         start[2] = mins[2] - 1;
3569         for     (x=0 ; x<=1 ; x++)
3570                 for     (y=0 ; y<=1 ; y++)
3571                 {
3572                         start[0] = x ? maxs[0] : mins[0];
3573                         start[1] = y ? maxs[1] : mins[1];
3574                         if (!(CL_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
3575                                 goto realcheck;
3576                 }
3577
3578         return true;            // we got out easy
3579
3580 realcheck:
3581 //
3582 // check it for real...
3583 //
3584         start[2] = mins[2];
3585
3586 // the midpoint must be within 16 of the bottom
3587         start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
3588         start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
3589         stop[2] = start[2] - 2*sv_stepheight.value;
3590         trace = CL_TraceLine(start, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, true, false, NULL, true, false);
3591
3592         if (trace.fraction == 1.0)
3593                 return false;
3594         mid = bottom = trace.endpos[2];
3595
3596 // the corners must be within 16 of the midpoint
3597         for     (x=0 ; x<=1 ; x++)
3598                 for     (y=0 ; y<=1 ; y++)
3599                 {
3600                         start[0] = stop[0] = x ? maxs[0] : mins[0];
3601                         start[1] = stop[1] = y ? maxs[1] : mins[1];
3602
3603                         trace = CL_TraceLine(start, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, true, false, NULL, true, false);
3604
3605                         if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
3606                                 bottom = trace.endpos[2];
3607                         if (trace.fraction == 1.0 || mid - trace.endpos[2] > sv_stepheight.value)
3608                                 return false;
3609                 }
3610
3611         return true;
3612 }
3613
3614 /*
3615 =============
3616 CL_movestep
3617
3618 Called by monster program code.
3619 The move will be adjusted for slopes and stairs, but if the move isn't
3620 possible, no move is done and false is returned
3621 =============
3622 */
3623 static qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean noenemy, qboolean settrace)
3624 {
3625         prvm_prog_t *prog = CLVM_prog;
3626         float           dz;
3627         vec3_t          oldorg, neworg, end, traceendpos;
3628         vec3_t          mins, maxs, start;
3629         trace_t         trace;
3630         int                     i, svent;
3631         prvm_edict_t            *enemy;
3632
3633 // try the move
3634         VectorCopy(PRVM_clientedictvector(ent, mins), mins);
3635         VectorCopy(PRVM_clientedictvector(ent, maxs), maxs);
3636         VectorCopy (PRVM_clientedictvector(ent, origin), oldorg);
3637         VectorAdd (PRVM_clientedictvector(ent, origin), move, neworg);
3638
3639 // flying monsters don't step up
3640         if ( (int)PRVM_clientedictfloat(ent, flags) & (FL_SWIM | FL_FLY) )
3641         {
3642         // try one move with vertical motion, then one without
3643                 for (i=0 ; i<2 ; i++)
3644                 {
3645                         VectorAdd (PRVM_clientedictvector(ent, origin), move, neworg);
3646                         enemy = PRVM_PROG_TO_EDICT(PRVM_clientedictedict(ent, enemy));
3647                         if (i == 0 && enemy != prog->edicts)
3648                         {
3649                                 dz = PRVM_clientedictvector(ent, origin)[2] - PRVM_clientedictvector(PRVM_PROG_TO_EDICT(PRVM_clientedictedict(ent, enemy)), origin)[2];
3650                                 if (dz > 40)
3651                                         neworg[2] -= 8;
3652                                 if (dz < 30)
3653                                         neworg[2] += 8;
3654                         }
3655                         VectorCopy(PRVM_clientedictvector(ent, origin), start);
3656                         trace = CL_TraceBox(start, mins, maxs, neworg, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, true, true, &svent, true);
3657                         if (settrace)
3658                                 CL_VM_SetTraceGlobals(prog, &trace, svent);
3659
3660                         if (trace.fraction == 1)
3661                         {
3662                                 VectorCopy(trace.endpos, traceendpos);
3663                                 if (((int)PRVM_clientedictfloat(ent, flags) & FL_SWIM) && !(CL_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
3664                                         return false;   // swim monster left water
3665
3666                                 VectorCopy (traceendpos, PRVM_clientedictvector(ent, origin));
3667                                 if (relink)
3668                                         CL_LinkEdict(ent);
3669                                 return true;
3670                         }
3671
3672                         if (enemy == prog->edicts)
3673                                 break;
3674                 }
3675
3676                 return false;
3677         }
3678
3679 // push down from a step height above the wished position
3680         neworg[2] += sv_stepheight.value;
3681         VectorCopy (neworg, end);
3682         end[2] -= sv_stepheight.value*2;
3683
3684         trace = CL_TraceBox(neworg, mins, maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, true, true, &svent, true);
3685         if (settrace)
3686                 CL_VM_SetTraceGlobals(prog, &trace, svent);
3687
3688         if (trace.startsolid)
3689         {
3690                 neworg[2] -= sv_stepheight.value;
3691                 trace = CL_TraceBox(neworg, mins, maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), 0, 0, collision_extendmovelength.value, true, true, &svent, true);
3692                 if (settrace)
3693                         CL_VM_SetTraceGlobals(prog, &trace, svent);
3694                 if (trace.startsolid)
3695                         return false;
3696         }
3697         if (trace.fraction == 1)
3698         {
3699         // if monster had the ground pulled out, go ahead and fall
3700                 if ( (int)PRVM_clientedictfloat(ent, flags) & FL_PARTIALGROUND )
3701                 {
3702                         VectorAdd (PRVM_clientedictvector(ent, origin), move, PRVM_clientedictvector(ent, origin));
3703                         if (relink)
3704                                 CL_LinkEdict(ent);
3705                         PRVM_clientedictfloat(ent, flags) = (int)PRVM_clientedictfloat(ent, flags) & ~FL_ONGROUND;
3706                         return true;
3707                 }
3708
3709                 return false;           // walked off an edge
3710         }
3711
3712 // check point traces down for dangling corners
3713         VectorCopy (trace.endpos, PRVM_clientedictvector(ent, origin));
3714
3715         if (!CL_CheckBottom (ent))
3716         {
3717                 if ( (int)PRVM_clientedictfloat(ent, flags) & FL_PARTIALGROUND )
3718                 {       // entity had floor mostly pulled out from underneath it
3719                         // and is trying to correct
3720                         if (relink)
3721                                 CL_LinkEdict(ent);
3722                         return true;
3723                 }
3724                 VectorCopy (oldorg, PRVM_clientedictvector(ent, origin));
3725                 return false;
3726         }
3727
3728         if ( (int)PRVM_clientedictfloat(ent, flags) & FL_PARTIALGROUND )
3729                 PRVM_clientedictfloat(ent, flags) = (int)PRVM_clientedictfloat(ent, flags) & ~FL_PARTIALGROUND;
3730
3731         PRVM_clientedictedict(ent, groundentity) = PRVM_EDICT_TO_PROG(trace.ent);
3732
3733 // the move is ok
3734         if (relink)
3735                 CL_LinkEdict(ent);
3736         return true;
3737 }
3738
3739 /*
3740 ===============
3741 VM_CL_walkmove
3742
3743 float(float yaw, float dist[, settrace]) walkmove
3744 ===============
3745 */
3746 static void VM_CL_walkmove (prvm_prog_t *prog)
3747 {
3748         prvm_edict_t    *ent;
3749         float   yaw, dist;
3750         vec3_t  move;
3751         mfunction_t     *oldf;
3752         int     oldself;
3753         qboolean        settrace;
3754
3755         VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_walkmove);
3756
3757         // assume failure if it returns early
3758         PRVM_G_FLOAT(OFS_RETURN) = 0;
3759
3760         ent = PRVM_PROG_TO_EDICT(PRVM_clientglobaledict(self));
3761         if (ent == prog->edicts)
3762         {
3763                 VM_Warning(prog, "walkmove: can not modify world entity\n");
3764                 return;
3765         }
3766         if (ent->priv.server->free)
3767         {
3768                 VM_Warning(prog, "walkmove: can not modify free entity\n");
3769                 return;
3770         }
3771         yaw = PRVM_G_FLOAT(OFS_PARM0);
3772         dist = PRVM_G_FLOAT(OFS_PARM1);
3773         settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
3774
3775         if ( !( (int)PRVM_clientedictfloat(ent, flags) & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
3776                 return;
3777
3778         yaw = yaw*M_PI*2 / 360;
3779
3780         move[0] = cos(yaw)*dist;
3781         move[1] = sin(yaw)*dist;
3782         move[2] = 0;
3783
3784 // save program state, because CL_movestep may call other progs
3785         oldf = prog->xfunction;
3786         oldself = PRVM_clientglobaledict(self);
3787
3788         PRVM_G_FLOAT(OFS_RETURN) = CL_movestep(ent, move, true, false, settrace);
3789
3790
3791 // restore program state
3792         prog->xfunction = oldf;
3793         PRVM_clientglobaledict(self) = oldself;
3794 }
3795
3796 /*
3797 ===============
3798 VM_CL_serverkey
3799
3800 string(string key) serverkey
3801 ===============
3802 */
3803 static void VM_CL_serverkey(prvm_prog_t *prog)
3804 {
3805         char string[VM_STRINGTEMP_LENGTH];
3806         VM_SAFEPARMCOUNT(1, VM_CL_serverkey);
3807         InfoString_GetValue(cl.qw_serverinfo, PRVM_G_STRING(OFS_PARM0), string, sizeof(string));
3808         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, string);
3809 }
3810
3811 /*
3812 =================
3813 VM_CL_checkpvs
3814
3815 Checks if an entity is in a point's PVS.
3816 Should be fast but can be inexact.
3817
3818 float checkpvs(vector viewpos, entity viewee) = #240;
3819 =================
3820 */
3821 static void VM_CL_checkpvs (prvm_prog_t *prog)
3822 {
3823         vec3_t viewpos;
3824         prvm_edict_t *viewee;
3825         vec3_t mi, ma;
3826 #if 1
3827         unsigned char *pvs;
3828 #else
3829         int fatpvsbytes;
3830         unsigned char fatpvs[MAX_MAP_LEAFS/8];
3831 #endif
3832
3833         VM_SAFEPARMCOUNT(2, VM_SV_checkpvs);
3834         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), viewpos);
3835         viewee = PRVM_G_EDICT(OFS_PARM1);
3836
3837         if(viewee->priv.required->free)
3838         {
3839                 VM_Warning(prog, "checkpvs: can not check free entity\n");
3840                 PRVM_G_FLOAT(OFS_RETURN) = 4;
3841                 return;
3842         }
3843
3844         VectorAdd(PRVM_serveredictvector(viewee, origin), PRVM_serveredictvector(viewee, mins), mi);
3845         VectorAdd(PRVM_serveredictvector(viewee, origin), PRVM_serveredictvector(viewee, maxs), ma);
3846
3847 #if 1
3848         if(!cl.worldmodel || !cl.worldmodel->brush.GetPVS || !cl.worldmodel->brush.BoxTouchingPVS)
3849         {
3850                 // no PVS support on this worldmodel... darn
3851                 PRVM_G_FLOAT(OFS_RETURN) = 3;
3852                 return;
3853         }
3854         pvs = cl.worldmodel->brush.GetPVS(cl.worldmodel, viewpos);
3855         if(!pvs)
3856         {
3857                 // viewpos isn't in any PVS... darn
3858                 PRVM_G_FLOAT(OFS_RETURN) = 2;
3859                 return;
3860         }
3861         PRVM_G_FLOAT(OFS_RETURN) = cl.worldmodel->brush.BoxTouchingPVS(cl.worldmodel, pvs, mi, ma);
3862 #else
3863         // using fat PVS like FTEQW does (slow)
3864         if(!cl.worldmodel || !cl.worldmodel->brush.FatPVS || !cl.worldmodel->brush.BoxTouchingPVS)
3865         {
3866                 // no PVS support on this worldmodel... darn
3867                 PRVM_G_FLOAT(OFS_RETURN) = 3;
3868                 return;
3869         }
3870         fatpvsbytes = cl.worldmodel->brush.FatPVS(cl.worldmodel, viewpos, 8, fatpvs, sizeof(fatpvs), false);
3871         if(!fatpvsbytes)
3872         {
3873                 // viewpos isn't in any PVS... darn
3874                 PRVM_G_FLOAT(OFS_RETURN) = 2;
3875                 return;
3876         }
3877         PRVM_G_FLOAT(OFS_RETURN) = cl.worldmodel->brush.BoxTouchingPVS(cl.worldmodel, fatpvs, mi, ma);
3878 #endif
3879 }
3880
3881 // #263 float(float modlindex) skel_create = #263; // (FTE_CSQC_SKELETONOBJECTS) create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure  (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex.
3882 static void VM_CL_skel_create(prvm_prog_t *prog)
3883 {
3884         int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
3885         dp_model_t *model = CL_GetModelByIndex(modelindex);
3886         skeleton_t *skeleton;
3887         int i;
3888         PRVM_G_FLOAT(OFS_RETURN) = 0;
3889         if (!model || !model->num_bones)
3890                 return;
3891         for (i = 0;i < MAX_EDICTS;i++)
3892                 if (!prog->skeletons[i])
3893                         break;
3894         if (i == MAX_EDICTS)
3895                 return;
3896         prog->skeletons[i] = skeleton = (skeleton_t *)Mem_Alloc(cls.levelmempool, sizeof(skeleton_t) + model->num_bones * sizeof(matrix4x4_t));
3897         PRVM_G_FLOAT(OFS_RETURN) = i + 1;
3898         skeleton->model = model;
3899         skeleton->relativetransforms = (matrix4x4_t *)(skeleton+1);
3900         // initialize to identity matrices
3901         for (i = 0;i < skeleton->model->num_bones;i++)
3902                 skeleton->relativetransforms[i] = identitymatrix;
3903 }
3904
3905 // #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
3906 static void VM_CL_skel_build(prvm_prog_t *prog)
3907 {
3908         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3909         skeleton_t *skeleton;
3910         prvm_edict_t *ed = PRVM_G_EDICT(OFS_PARM1);
3911         int modelindex = (int)PRVM_G_FLOAT(OFS_PARM2);
3912         float retainfrac = PRVM_G_FLOAT(OFS_PARM3);
3913         int firstbone = PRVM_G_FLOAT(OFS_PARM4) - 1;
3914         int lastbone = PRVM_G_FLOAT(OFS_PARM5) - 1;
3915         dp_model_t *model = CL_GetModelByIndex(modelindex);
3916         int numblends;
3917         int bonenum;
3918         int blendindex;
3919         framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
3920         frameblend_t frameblend[MAX_FRAMEBLENDS];
3921         matrix4x4_t bonematrix;
3922         matrix4x4_t matrix;
3923         PRVM_G_FLOAT(OFS_RETURN) = 0;
3924         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3925                 return;
3926         firstbone = max(0, firstbone);
3927         lastbone = min(lastbone, model->num_bones - 1);
3928         lastbone = min(lastbone, skeleton->model->num_bones - 1);
3929         VM_GenerateFrameGroupBlend(prog, framegroupblend, ed);
3930         VM_FrameBlendFromFrameGroupBlend(frameblend, framegroupblend, model, cl.time);
3931         for (numblends = 0;numblends < MAX_FRAMEBLENDS && frameblend[numblends].lerp;numblends++)
3932                 ;
3933         for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
3934         {
3935                 memset(&bonematrix, 0, sizeof(bonematrix));
3936                 for (blendindex = 0;blendindex < numblends;blendindex++)
3937                 {
3938                         Matrix4x4_FromBonePose7s(&matrix, model->num_posescale, model->data_poses7s + 7 * (frameblend[blendindex].subframe * model->num_bones + bonenum));
3939                         Matrix4x4_Accumulate(&bonematrix, &matrix, frameblend[blendindex].lerp);
3940                 }
3941                 Matrix4x4_Normalize3(&bonematrix, &bonematrix);
3942                 Matrix4x4_Interpolate(&skeleton->relativetransforms[bonenum], &bonematrix, &skeleton->relativetransforms[bonenum], retainfrac);
3943         }
3944         PRVM_G_FLOAT(OFS_RETURN) = skeletonindex + 1;
3945 }
3946
3947 // #265 float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS) returns how many bones exist in the created skeleton
3948 static void VM_CL_skel_get_numbones(prvm_prog_t *prog)
3949 {
3950         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3951         skeleton_t *skeleton;
3952         PRVM_G_FLOAT(OFS_RETURN) = 0;
3953         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3954                 return;
3955         PRVM_G_FLOAT(OFS_RETURN) = skeleton->model->num_bones;
3956 }
3957
3958 // #266 string(float skel, float bonenum) skel_get_bonename = #266; // (FTE_CSQC_SKELETONOBJECTS) returns name of bone (as a tempstring)
3959 static void VM_CL_skel_get_bonename(prvm_prog_t *prog)
3960 {
3961         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3962         int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3963         skeleton_t *skeleton;
3964         PRVM_G_INT(OFS_RETURN) = 0;
3965         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3966                 return;
3967         if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3968                 return;
3969         PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, skeleton->model->data_bones[bonenum].name);
3970 }
3971
3972 // #267 float(float skel, float bonenum) skel_get_boneparent = #267; // (FTE_CSQC_SKELETONOBJECTS) returns parent num for supplied bonenum, 0 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this)
3973 static void VM_CL_skel_get_boneparent(prvm_prog_t *prog)
3974 {
3975         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3976         int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3977         skeleton_t *skeleton;
3978         PRVM_G_FLOAT(OFS_RETURN) = 0;
3979         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3980                 return;
3981         if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3982                 return;
3983         PRVM_G_FLOAT(OFS_RETURN) = skeleton->model->data_bones[bonenum].parent + 1;
3984 }
3985
3986 // #268 float(float skel, string tagname) skel_find_bone = #268; // (FTE_CSQC_SKELETONOBJECTS) get number of bone with specified name, 0 on failure, tagindex (bonenum+1) on success, same as using gettagindex on the modelindex
3987 static void VM_CL_skel_find_bone(prvm_prog_t *prog)
3988 {
3989         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3990         const char *tagname = PRVM_G_STRING(OFS_PARM1);
3991         skeleton_t *skeleton;
3992         PRVM_G_FLOAT(OFS_RETURN) = 0;
3993         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3994                 return;
3995         PRVM_G_FLOAT(OFS_RETURN) = Mod_Alias_GetTagIndexForName(skeleton->model, 0, tagname);
3996 }
3997
3998 // #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
3999 static void VM_CL_skel_get_bonerel(prvm_prog_t *prog)
4000 {
4001         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
4002         int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
4003         skeleton_t *skeleton;
4004         matrix4x4_t matrix;
4005         vec3_t forward, left, up, origin;
4006         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
4007         VectorClear(PRVM_clientglobalvector(v_forward));
4008         VectorClear(PRVM_clientglobalvector(v_right));
4009         VectorClear(PRVM_clientglobalvector(v_up));
4010         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
4011                 return;
4012         if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
4013                 return;
4014         matrix = skeleton->relativetransforms[bonenum];
4015         Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
4016         VectorCopy(forward, PRVM_clientglobalvector(v_forward));
4017         VectorNegate(left, PRVM_clientglobalvector(v_right));
4018         VectorCopy(up, PRVM_clientglobalvector(v_up));
4019         VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
4020 }
4021
4022 // #270 vector(float skel, float bonenum) skel_get_boneabs = #270; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity)
4023 static void VM_CL_skel_get_boneabs(prvm_prog_t *prog)
4024 {
4025         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
4026         int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
4027         skeleton_t *skeleton;
4028         matrix4x4_t matrix;
4029         matrix4x4_t temp;
4030         vec3_t forward, left, up, origin;
4031         VectorClear(PRVM_G_VECTOR(OFS_RETURN));
4032         VectorClear(PRVM_clientglobalvector(v_forward));
4033         VectorClear(PRVM_clientglobalvector(v_right));
4034         VectorClear(PRVM_clientglobalvector(v_up));
4035         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
4036                 return;
4037         if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
4038                 return;
4039         matrix = skeleton->relativetransforms[bonenum];
4040         // convert to absolute
4041         while ((bonenum = skeleton->model->data_bones[bonenum].parent) >= 0)
4042         {
4043                 temp = matrix;
4044                 Matrix4x4_Concat(&matrix, &skeleton->relativetransforms[bonenum], &temp);
4045         }
4046         Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
4047         VectorCopy(forward, PRVM_clientglobalvector(v_forward));
4048         VectorNegate(left, PRVM_clientglobalvector(v_right));
4049         VectorCopy(up, PRVM_clientglobalvector(v_up));
4050         VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
4051 }
4052
4053 // #271 void(float skel, float bonenum, vector org) skel_set_bone = #271; // (FTE_CSQC_SKELETONOBJECTS) set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
4054 static void VM_CL_skel_set_bone(prvm_prog_t *prog)
4055 {
4056         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
4057         int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
4058         vec3_t forward, left, up, origin;
4059         skeleton_t *skeleton;
4060         matrix4x4_t matrix;
4061         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
4062                 return;
4063         if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
4064                 return;
4065         VectorCopy(PRVM_clientglobalvector(v_forward), forward);
4066         VectorNegate(PRVM_clientglobalvector(v_right), left);
4067         VectorCopy(PRVM_clientglobalvector(v_up), up);
4068         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
4069         Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
4070         skeleton->relativetransforms[bonenum] = matrix;
4071 }
4072
4073 // #272 void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
4074 static void VM_CL_skel_mul_bone(prvm_prog_t *prog)
4075 {
4076         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
4077         int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
4078         vec3_t forward, left, up, origin;
4079         skeleton_t *skeleton;
4080         matrix4x4_t matrix;
4081         matrix4x4_t temp;
4082         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
4083                 return;
4084         if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
4085                 return;
4086         VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
4087         VectorCopy(PRVM_clientglobalvector(v_forward), forward);
4088         VectorNegate(PRVM_clientglobalvector(v_right), left);
4089         VectorCopy(PRVM_clientglobalvector(v_up), up);
4090         Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
4091         temp = skeleton->relativetransforms[bonenum];
4092         Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
4093 }
4094
4095 // #273 void(float skel, float startbone, float endbone, vector org) skel_mul_bones = #273; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones)
4096 static void VM_CL_skel_mul_bones(prvm_prog_t *prog)
4097 {
4098         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
4099         int firstbone = PRVM_G_FLOAT(OFS_PARM1) - 1;
4100         int lastbone = PRVM_G_FLOAT(OFS_PARM2) - 1;
4101         int bonenum;
4102         vec3_t forward, left, up, origin;
4103         skeleton_t *skeleton;
4104         matrix4x4_t matrix;
4105         matrix4x4_t temp;
4106         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
4107                 return;
4108         VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin);
4109         VectorCopy(PRVM_clientglobalvector(v_forward), forward);
4110         VectorNegate(PRVM_clientglobalvector(v_right), left);
4111         VectorCopy(PRVM_clientglobalvector(v_up), up);
4112         Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
4113         firstbone = max(0, firstbone);
4114         lastbone = min(lastbone, skeleton->model->num_bones - 1);
4115         for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
4116         {
4117                 temp = skeleton->relativetransforms[bonenum];
4118                 Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
4119         }
4120 }
4121
4122 // #274 void(float skeldst, float skelsrc, float startbone, float endbone) skel_copybones = #274; // (FTE_CSQC_SKELETONOBJECTS) copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse
4123 static void VM_CL_skel_copybones(prvm_prog_t *prog)
4124 {
4125         int skeletonindexdst = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
4126         int skeletonindexsrc = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
4127         int firstbone = PRVM_G_FLOAT(OFS_PARM2) - 1;
4128         int lastbone = PRVM_G_FLOAT(OFS_PARM3) - 1;
4129         int bonenum;
4130         skeleton_t *skeletondst;
4131         skeleton_t *skeletonsrc;
4132         if (skeletonindexdst < 0 || skeletonindexdst >= MAX_EDICTS || !(skeletondst = prog->skeletons[skeletonindexdst]))
4133                 return;
4134         if (skeletonindexsrc < 0 || skeletonindexsrc >= MAX_EDICTS || !(skeletonsrc = prog->skeletons[skeletonindexsrc]))
4135                 return;
4136         firstbone = max(0, firstbone);
4137         lastbone = min(lastbone, skeletondst->model->num_bones - 1);
4138         lastbone = min(lastbone, skeletonsrc->model->num_bones - 1);
4139         for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
4140                 skeletondst->relativetransforms[bonenum] = skeletonsrc->relativetransforms[bonenum];
4141 }
4142
4143 // #275 void(float skel) skel_delete = #275; // (FTE_CSQC_SKELETONOBJECTS) deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work)
4144 static void VM_CL_skel_delete(prvm_prog_t *prog)
4145 {
4146         int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
4147         skeleton_t *skeleton;
4148         if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
4149                 return;
4150         Mem_Free(skeleton);
4151         prog->skeletons[skeletonindex] = NULL;
4152 }
4153
4154 // #276 float(float modlindex, string framename) frameforname = #276; // (FTE_CSQC_SKELETONOBJECTS) finds number of a specified frame in the animation, returns -1 if no match found
4155 static void VM_CL_frameforname(prvm_prog_t *prog)
4156 {
4157         int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
4158         dp_model_t *model = CL_GetModelByIndex(modelindex);
4159         const char *name = PRVM_G_STRING(OFS_PARM1);
4160         int i;
4161         PRVM_G_FLOAT(OFS_RETURN) = -1;
4162         if (!model || !model->animscenes)
4163                 return;
4164         for (i = 0;i < model->numframes;i++)
4165         {
4166                 if (!strcasecmp(model->animscenes[i].name, name))
4167                 {
4168                         PRVM_G_FLOAT(OFS_RETURN) = i;
4169                         break;
4170                 }
4171         }
4172 }
4173
4174 // #277 float(float modlindex, float framenum) frameduration = #277; // (FTE_CSQC_SKELETONOBJECTS) returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0.
4175 static void VM_CL_frameduration(prvm_prog_t *prog)
4176 {
4177         int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
4178         dp_model_t *model = CL_GetModelByIndex(modelindex);
4179         int framenum = (int)PRVM_G_FLOAT(OFS_PARM1);
4180         PRVM_G_FLOAT(OFS_RETURN) = 0;
4181         if (!model || !model->animscenes || framenum < 0 || framenum >= model->numframes)
4182                 return;
4183         if (model->animscenes[framenum].framerate)
4184                 PRVM_G_FLOAT(OFS_RETURN) = model->animscenes[framenum].framecount / model->animscenes[framenum].framerate;
4185 }
4186
4187 static void VM_CL_RotateMoves(prvm_prog_t *prog)
4188 {
4189         /*
4190          * Obscure builtin used by GAME_XONOTIC.
4191          *
4192          * Edits the input history of cl_movement by rotating all move commands
4193          * currently in the queue using the given transform.
4194          *
4195          * The vector passed is an "angles transform" as used by warpzonelib, i.e.
4196          * v_angle-like (non-inverted) euler angles that perform the rotation
4197          * of the space that is to be done.
4198          *
4199          * This is meant to be used as a fixangle replacement after passing
4200          * through a warpzone/portal: the client is told about the warp transform,
4201          * and calls this function in the same frame as the one on which the
4202          * client's origin got changed by the serverside teleport. Then this code
4203          * transforms the pre-warp input (which matches the empty space behind
4204          * the warp plane) into post-warp input (which matches the target area
4205          * of the warp). Also, at the same time, the client has to use
4206          * R_SetView to adjust VF_CL_VIEWANGLES according to the same transform.
4207          *
4208          * This together allows warpzone motion to be perfectly predicted by
4209          * the client!
4210          *
4211          * Furthermore, for perfect warpzone behaviour, the server side also
4212          * has to detect input the client sent before it received the origin
4213          * update, but after the warp occurred on the server, and has to adjust
4214          * input appropriately.
4215     */
4216         matrix4x4_t m;
4217         vec3_t v = {0, 0, 0};
4218         vec3_t a, x, y, z;
4219         VM_SAFEPARMCOUNT(1, VM_CL_RotateMoves);
4220         VectorCopy(PRVM_G_VECTOR(OFS_PARM0), a);
4221         AngleVectorsFLU(a, x, y, z);
4222         Matrix4x4_FromVectors(&m, x, y, z, v);
4223         CL_RotateMoves(&m);
4224 }
4225
4226 // #358 void(string cubemapname) loadcubemap
4227 static void VM_CL_loadcubemap(prvm_prog_t *prog)
4228 {
4229         const char *name;
4230
4231         VM_SAFEPARMCOUNT(1, VM_CL_loadcubemap);
4232         name = PRVM_G_STRING(OFS_PARM0);
4233         R_GetCubemap(name);
4234 }
4235
4236 #define REFDEFFLAG_TELEPORTED 1
4237 #define REFDEFFLAG_JUMPING 2
4238 #define REFDEFFLAG_DEAD 4
4239 #define REFDEFFLAG_INTERMISSION 8
4240 static void VM_CL_V_CalcRefdef(prvm_prog_t *prog)
4241 {
4242         matrix4x4_t entrendermatrix;
4243         vec3_t clviewangles;
4244         vec3_t clvelocity;
4245         qboolean teleported;
4246         qboolean clonground;
4247         qboolean clcmdjump;
4248         qboolean cldead;
4249         qboolean clintermission;
4250         float clstatsviewheight;
4251         prvm_edict_t *ent;
4252         int flags;
4253
4254         VM_SAFEPARMCOUNT(2, VM_CL_V_CalcRefdef);
4255         ent = PRVM_G_EDICT(OFS_PARM0);
4256         flags = PRVM_G_FLOAT(OFS_PARM1);
4257
4258         // use the CL_GetTagMatrix function on self to ensure consistent behavior (duplicate code would be bad)
4259         CL_GetTagMatrix(prog, &entrendermatrix, ent, 0, NULL);
4260
4261         VectorCopy(cl.csqc_viewangles, clviewangles);
4262         teleported = (flags & REFDEFFLAG_TELEPORTED) != 0;
4263         clonground = ((int)PRVM_clientedictfloat(ent, pmove_flags) & PMF_ONGROUND) != 0;
4264         clcmdjump = (flags & REFDEFFLAG_JUMPING) != 0;
4265         clstatsviewheight = PRVM_clientedictvector(ent, view_ofs)[2];
4266         cldead = (flags & REFDEFFLAG_DEAD) != 0;
4267         clintermission = (flags & REFDEFFLAG_INTERMISSION) != 0;
4268         VectorCopy(PRVM_clientedictvector(ent, velocity), clvelocity);
4269
4270         V_CalcRefdefUsing(&entrendermatrix, clviewangles, teleported, clonground, clcmdjump, clstatsviewheight, cldead, clintermission, clvelocity);
4271
4272         VectorCopy(cl.csqc_vieworiginfromengine, cl.csqc_vieworigin);
4273         VectorCopy(cl.csqc_viewanglesfromengine, cl.csqc_viewangles);
4274         CSQC_R_RecalcView();
4275 }
4276
4277 //============================================================================
4278
4279 // To create a almost working builtin file from this replace:
4280 // "^NULL.*" with ""
4281 // "^{.*//.*}:Wh\(.*\)" with "\1"
4282 // "\:" with "//"
4283 // "^.*//:Wh{\#:d*}:Wh{.*}" with "\2 = \1;"
4284 // "\n\n+" with "\n\n"
4285
4286 prvm_builtin_t vm_cl_builtins[] = {
4287 NULL,                                                   // #0 NULL function (not callable) (QUAKE)
4288 VM_CL_makevectors,                              // #1 void(vector ang) makevectors (QUAKE)
4289 VM_CL_setorigin,                                // #2 void(entity e, vector o) setorigin (QUAKE)
4290 VM_CL_setmodel,                                 // #3 void(entity e, string m) setmodel (QUAKE)
4291 VM_CL_setsize,                                  // #4 void(entity e, vector min, vector max) setsize (QUAKE)
4292 NULL,                                                   // #5 void(entity e, vector min, vector max) setabssize (QUAKE)
4293 VM_break,                                               // #6 void() break (QUAKE)
4294 VM_random,                                              // #7 float() random (QUAKE)
4295 VM_CL_sound,                                    // #8 void(entity e, float chan, string samp) sound (QUAKE)
4296 VM_normalize,                                   // #9 vector(vector v) normalize (QUAKE)
4297 VM_error,                                               // #10 void(string e) error (QUAKE)
4298 VM_objerror,                                    // #11 void(string e) objerror (QUAKE)
4299 VM_vlen,                                                // #12 float(vector v) vlen (QUAKE)
4300 VM_vectoyaw,                                    // #13 float(vector v) vectoyaw (QUAKE)
4301 VM_CL_spawn,                                    // #14 entity() spawn (QUAKE)
4302 VM_remove,                                              // #15 void(entity e) remove (QUAKE)
4303 VM_CL_traceline,                                // #16 void(vector v1, vector v2, float tryents, entity ignoreentity) traceline (QUAKE)
4304 NULL,                                                   // #17 entity() checkclient (QUAKE)
4305 VM_find,                                                // #18 entity(entity start, .string fld, string match) find (QUAKE)
4306 VM_precache_sound,                              // #19 void(string s) precache_sound (QUAKE)
4307 VM_CL_precache_model,                   // #20 void(string s) precache_model (QUAKE)
4308 NULL,                                                   // #21 void(entity client, string s, ...) stuffcmd (QUAKE)
4309 VM_CL_findradius,                               // #22 entity(vector org, float rad) findradius (QUAKE)
4310 NULL,                                                   // #23 void(string s, ...) bprint (QUAKE)
4311 NULL,                                                   // #24 void(entity client, string s, ...) sprint (QUAKE)
4312 VM_dprint,                                              // #25 void(string s, ...) dprint (QUAKE)
4313 VM_ftos,                                                // #26 string(float f) ftos (QUAKE)
4314 VM_vtos,                                                // #27 string(vector v) vtos (QUAKE)
4315 VM_coredump,                                    // #28 void() coredump (QUAKE)
4316 VM_traceon,                                             // #29 void() traceon (QUAKE)
4317 VM_traceoff,                                    // #30 void() traceoff (QUAKE)
4318 VM_eprint,                                              // #31 void(entity e) eprint (QUAKE)
4319 VM_CL_walkmove,                                 // #32 float(float yaw, float dist[, float settrace]) walkmove (QUAKE)
4320 NULL,                                                   // #33 (QUAKE)
4321 VM_CL_droptofloor,                              // #34 float() droptofloor (QUAKE)
4322 VM_CL_lightstyle,                               // #35 void(float style, string value) lightstyle (QUAKE)
4323 VM_rint,                                                // #36 float(float v) rint (QUAKE)
4324 VM_floor,                                               // #37 float(float v) floor (QUAKE)
4325 VM_ceil,                                                // #38 float(float v) ceil (QUAKE)
4326 NULL,                                                   // #39 (QUAKE)
4327 VM_CL_checkbottom,                              // #40 float(entity e) checkbottom (QUAKE)
4328 VM_CL_pointcontents,                    // #41 float(vector v) pointcontents (QUAKE)
4329 NULL,                                                   // #42 (QUAKE)
4330 VM_fabs,                                                // #43 float(float f) fabs (QUAKE)
4331 NULL,                                                   // #44 vector(entity e, float speed) aim (QUAKE)
4332 VM_cvar,                                                // #45 float(string s) cvar (QUAKE)
4333 VM_localcmd,                                    // #46 void(string s) localcmd (QUAKE)
4334 VM_nextent,                                             // #47 entity(entity e) nextent (QUAKE)
4335 VM_CL_particle,                                 // #48 void(vector o, vector d, float color, float count) particle (QUAKE)
4336 VM_changeyaw,                                   // #49 void() ChangeYaw (QUAKE)
4337 NULL,                                                   // #50 (QUAKE)
4338 VM_vectoangles,                                 // #51 vector(vector v) vectoangles (QUAKE)
4339 NULL,                                                   // #52 void(float to, float f) WriteByte (QUAKE)
4340 NULL,                                                   // #53 void(float to, float f) WriteChar (QUAKE)
4341 NULL,                                                   // #54 void(float to, float f) WriteShort (QUAKE)
4342 NULL,                                                   // #55 void(float to, float f) WriteLong (QUAKE)
4343 NULL,                                                   // #56 void(float to, float f) WriteCoord (QUAKE)
4344 NULL,                                                   // #57 void(float to, float f) WriteAngle (QUAKE)
4345 NULL,                                                   // #58 void(float to, string s) WriteString (QUAKE)
4346 NULL,                                                   // #59 (QUAKE)
4347 VM_sin,                                                 // #60 float(float f) sin (DP_QC_SINCOSSQRTPOW)
4348 VM_cos,                                                 // #61 float(float f) cos (DP_QC_SINCOSSQRTPOW)
4349 VM_sqrt,                                                // #62 float(float f) sqrt (DP_QC_SINCOSSQRTPOW)
4350 VM_changepitch,                                 // #63 void(entity ent) changepitch (DP_QC_CHANGEPITCH)
4351 VM_CL_tracetoss,                                // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS)
4352 VM_etos,                                                // #65 string(entity ent) etos (DP_QC_ETOS)
4353 NULL,                                                   // #66 (QUAKE)
4354 NULL,                                                   // #67 void(float step) movetogoal (QUAKE)
4355 VM_precache_file,                               // #68 string(string s) precache_file (QUAKE)
4356 VM_CL_makestatic,                               // #69 void(entity e) makestatic (QUAKE)
4357 NULL,                                                   // #70 void(string s) changelevel (QUAKE)
4358 NULL,                                                   // #71 (QUAKE)
4359 VM_cvar_set,                                    // #72 void(string var, string val) cvar_set (QUAKE)
4360 NULL,                                                   // #73 void(entity client, strings) centerprint (QUAKE)
4361 VM_CL_ambientsound,                             // #74 void(vector pos, string samp, float vol, float atten) ambientsound (QUAKE)
4362 VM_CL_precache_model,                   // #75 string(string s) precache_model2 (QUAKE)
4363 VM_precache_sound,                              // #76 string(string s) precache_sound2 (QUAKE)
4364 VM_precache_file,                               // #77 string(string s) precache_file2 (QUAKE)
4365 NULL,                                                   // #78 void(entity e) setspawnparms (QUAKE)
4366 NULL,                                                   // #79 void(entity killer, entity killee) logfrag (QUAKEWORLD)
4367 NULL,                                                   // #80 string(entity e, string keyname) infokey (QUAKEWORLD)
4368 VM_stof,                                                // #81 float(string s) stof (FRIK_FILE)
4369 NULL,                                                   // #82 void(vector where, float set) multicast (QUAKEWORLD)
4370 NULL,                                                   // #83 (QUAKE)
4371 NULL,                                                   // #84 (QUAKE)
4372 NULL,                                                   // #85 (QUAKE)
4373 NULL,                                                   // #86 (QUAKE)
4374 NULL,                                                   // #87 (QUAKE)
4375 NULL,                                                   // #88 (QUAKE)
4376 NULL,                                                   // #89 (QUAKE)
4377 VM_CL_tracebox,                                 // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
4378 VM_randomvec,                                   // #91 vector() randomvec (DP_QC_RANDOMVEC)
4379 VM_CL_getlight,                                 // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
4380 VM_registercvar,                                // #93 float(string name, string value) registercvar (DP_REGISTERCVAR)
4381 VM_min,                                                 // #94 float(float a, floats) min (DP_QC_MINMAXBOUND)
4382 VM_max,                                                 // #95 float(float a, floats) max (DP_QC_MINMAXBOUND)
4383 VM_bound,                                               // #96 float(float minimum, float val, float maximum) bound (DP_QC_MINMAXBOUND)
4384 VM_pow,                                                 // #97 float(float f, float f) pow (DP_QC_SINCOSSQRTPOW)
4385 VM_findfloat,                                   // #98 entity(entity start, .float fld, float match) findfloat (DP_QC_FINDFLOAT)
4386 VM_checkextension,                              // #99 float(string s) checkextension (the basis of the extension system)
4387 // FrikaC and Telejano range #100-#199
4388 NULL,                                                   // #100
4389 NULL,                                                   // #101
4390 NULL,                                                   // #102
4391 NULL,                                                   // #103
4392 NULL,                                                   // #104
4393 NULL,                                                   // #105
4394 NULL,                                                   // #106
4395 NULL,                                                   // #107
4396 NULL,                                                   // #108
4397 NULL,                                                   // #109
4398 VM_fopen,                                               // #110 float(string filename, float mode) fopen (FRIK_FILE)
4399 VM_fclose,                                              // #111 void(float fhandle) fclose (FRIK_FILE)
4400 VM_fgets,                                               // #112 string(float fhandle) fgets (FRIK_FILE)
4401 VM_fputs,                                               // #113 void(float fhandle, string s) fputs (FRIK_FILE)
4402 VM_strlen,                                              // #114 float(string s) strlen (FRIK_FILE)
4403 VM_strcat,                                              // #115 string(string s1, string s2, ...) strcat (FRIK_FILE)
4404 VM_substring,                                   // #116 string(string s, float start, float length) substring (FRIK_FILE)
4405 VM_stov,                                                // #117 vector(string) stov (FRIK_FILE)
4406 VM_strzone,                                             // #118 string(string s) strzone (FRIK_FILE)
4407 VM_strunzone,                                   // #119 void(string s) strunzone (FRIK_FILE)
4408 NULL,                                                   // #120
4409 NULL,                                                   // #121
4410 NULL,                                                   // #122
4411 NULL,                                                   // #123
4412 NULL,                                                   // #124
4413 NULL,                                                   // #125
4414 NULL,                                                   // #126
4415 NULL,                                                   // #127
4416 NULL,                                                   // #128
4417 NULL,                                                   // #129
4418 NULL,                                                   // #130
4419 NULL,                                                   // #131
4420 NULL,                                                   // #132
4421 NULL,                                                   // #133
4422 NULL,                                                   // #134
4423 NULL,                                                   // #135
4424 NULL,                                                   // #136
4425 NULL,                                                   // #137
4426 NULL,                                                   // #138
4427 NULL,                                                   // #139
4428 NULL,                                                   // #140
4429 NULL,                                                   // #141
4430 NULL,                                                   // #142
4431 NULL,                                                   // #143
4432 NULL,                                                   // #144
4433 NULL,                                                   // #145
4434 NULL,                                                   // #146
4435 NULL,                                                   // #147
4436 NULL,                                                   // #148
4437 NULL,                                                   // #149
4438 NULL,                                                   // #150
4439 NULL,                                                   // #151
4440 NULL,                                                   // #152
4441 NULL,                                                   // #153
4442 NULL,                                                   // #154
4443 NULL,                                                   // #155
4444 NULL,                                                   // #156
4445 NULL,                                                   // #157
4446 NULL,                                                   // #158
4447 NULL,                                                   // #159
4448 NULL,                                                   // #160
4449 NULL,                                                   // #161
4450 NULL,                                                   // #162
4451 NULL,                                                   // #163
4452 NULL,                                                   // #164
4453 NULL,                                                   // #165
4454 NULL,                                                   // #166
4455 NULL,                                                   // #167
4456 NULL,                                                   // #168
4457 NULL,                                                   // #169
4458 NULL,                                                   // #170
4459 NULL,                                                   // #171
4460 NULL,                                                   // #172
4461 NULL,                                                   // #173
4462 NULL,                                                   // #174
4463 NULL,                                                   // #175
4464 NULL,                                                   // #176
4465 NULL,                                                   // #177
4466 NULL,                                                   // #178
4467 NULL,                                                   // #179
4468 NULL,                                                   // #180
4469 NULL,                                                   // #181
4470 NULL,                                                   // #182
4471 NULL,                                                   // #183
4472 NULL,                                                   // #184
4473 NULL,                                                   // #185
4474 NULL,                                                   // #186
4475 NULL,                                                   // #187
4476 NULL,                                                   // #188
4477 NULL,                                                   // #189
4478 NULL,                                                   // #190
4479 NULL,                                                   // #191
4480 NULL,                                                   // #192
4481 NULL,                                                   // #193
4482 NULL,                                                   // #194
4483 NULL,                                                   // #195
4484 NULL,                                                   // #196
4485 NULL,                                                   // #197
4486 NULL,                                                   // #198
4487 NULL,                                                   // #199
4488 // FTEQW range #200-#299
4489 NULL,                                                   // #200
4490 NULL,                                                   // #201
4491 NULL,                                                   // #202
4492 NULL,                                                   // #203
4493 NULL,                                                   // #204
4494 NULL,                                                   // #205
4495 NULL,                                                   // #206
4496 NULL,                                                   // #207
4497 NULL,                                                   // #208
4498 NULL,                                                   // #209
4499 NULL,                                                   // #210
4500 NULL,                                                   // #211
4501 NULL,                                                   // #212
4502 NULL,                                                   // #213
4503 NULL,                                                   // #214
4504 NULL,                                                   // #215
4505 NULL,                                                   // #216
4506 NULL,                                                   // #217
4507 VM_bitshift,                                    // #218 float(float number, float quantity) bitshift (EXT_BITSHIFT)
4508 NULL,                                                   // #219
4509 NULL,                                                   // #220
4510 VM_strstrofs,                                   // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
4511 VM_str2chr,                                             // #222 float(string str, float ofs) str2chr (FTE_STRINGS)
4512 VM_chr2str,                                             // #223 string(float c, ...) chr2str (FTE_STRINGS)
4513 VM_strconv,                                             // #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS)
4514 VM_strpad,                                              // #225 string(float chars, string s, ...) strpad (FTE_STRINGS)
4515 VM_infoadd,                                             // #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS)
4516 VM_infoget,                                             // #227 string(string info, string key) infoget (FTE_STRINGS)
4517 VM_strncmp,                                             // #228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
4518 VM_strncasecmp,                                 // #229 float(string s1, string s2) strcasecmp (FTE_STRINGS)
4519 VM_strncasecmp,                                 // #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS)
4520 NULL,                                                   // #231
4521 NULL,                                                   // #232 void(float index, float type, .void field) SV_AddStat (EXT_CSQC)
4522 NULL,                                                   // #233
4523 NULL,                                                   // #234
4524 NULL,                                                   // #235
4525 NULL,                                                   // #236
4526 NULL,                                                   // #237
4527 NULL,                                                   // #238
4528 NULL,                                                   // #239
4529 VM_CL_checkpvs,                                 // #240
4530 NULL,                                                   // #241
4531 NULL,                                                   // #242
4532 NULL,                                                   // #243
4533 NULL,                                                   // #244
4534 NULL,                                                   // #245
4535 NULL,                                                   // #246
4536 NULL,                                                   // #247
4537 NULL,                                                   // #248
4538 NULL,                                                   // #249
4539 NULL,                                                   // #250
4540 NULL,                                                   // #251
4541 NULL,                                                   // #252
4542 NULL,                                                   // #253
4543 NULL,                                                   // #254
4544 NULL,                                                   // #255
4545 NULL,                                                   // #256
4546 NULL,                                                   // #257
4547 NULL,                                                   // #258
4548 NULL,                                                   // #259
4549 NULL,                                                   // #260
4550 NULL,                                                   // #261
4551 NULL,                                                   // #262
4552 VM_CL_skel_create,                              // #263 float(float modlindex) skel_create = #263; // (FTE_CSQC_SKELETONOBJECTS) create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure  (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex.
4553 VM_CL_skel_build,                               // #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
4554 VM_CL_skel_get_numbones,                // #265 float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS) returns how many bones exist in the created skeleton
4555 VM_CL_skel_get_bonename,                // #266 string(float skel, float bonenum) skel_get_bonename = #266; // (FTE_CSQC_SKELETONOBJECTS) returns name of bone (as a tempstring)
4556 VM_CL_skel_get_boneparent,              // #267 float(float skel, float bonenum) skel_get_boneparent = #267; // (FTE_CSQC_SKELETONOBJECTS) returns parent num for supplied bonenum, -1 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this)
4557 VM_CL_skel_find_bone,                   // #268 float(float skel, string tagname) skel_find_bone = #268; // (FTE_CSQC_SKELETONOBJECTS) get number of bone with specified name, 0 on failure, tagindex (bonenum+1) on success, same as using gettagindex on the modelindex
4558 VM_CL_skel_get_bonerel,                 // #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
4559 VM_CL_skel_get_boneabs,                 // #270 vector(float skel, float bonenum) skel_get_boneabs = #270; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity)
4560 VM_CL_skel_set_bone,                    // #271 void(float skel, float bonenum, vector org) skel_set_bone = #271; // (FTE_CSQC_SKELETONOBJECTS) set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
4561 VM_CL_skel_mul_bone,                    // #272 void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
4562 VM_CL_skel_mul_bones,                   // #273 void(float skel, float startbone, float endbone, vector org) skel_mul_bones = #273; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones)
4563 VM_CL_skel_copybones,                   // #274 void(float skeldst, float skelsrc, float startbone, float endbone) skel_copybones = #274; // (FTE_CSQC_SKELETONOBJECTS) copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse
4564 VM_CL_skel_delete,                              // #275 void(float skel) skel_delete = #275; // (FTE_CSQC_SKELETONOBJECTS) deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work)
4565 VM_CL_frameforname,                             // #276 float(float modlindex, string framename) frameforname = #276; // (FTE_CSQC_SKELETONOBJECTS) finds number of a specified frame in the animation, returns -1 if no match found
4566 VM_CL_frameduration,                    // #277 float(float modlindex, float framenum) frameduration = #277; // (FTE_CSQC_SKELETONOBJECTS) returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0.
4567 NULL,                                                   // #278
4568 NULL,                                                   // #279
4569 NULL,                                                   // #280
4570 NULL,                                                   // #281
4571 NULL,                                                   // #282
4572 NULL,                                                   // #283
4573 NULL,                                                   // #284
4574 NULL,                                                   // #285
4575 NULL,                                                   // #286
4576 NULL,                                                   // #287
4577 NULL,                                                   // #288
4578 NULL,                                                   // #289
4579 NULL,                                                   // #290
4580 NULL,                                                   // #291
4581 NULL,                                                   // #292
4582 NULL,                                                   // #293
4583 NULL,                                                   // #294
4584 NULL,                                                   // #295
4585 NULL,                                                   // #296
4586 NULL,                                                   // #297
4587 NULL,                                                   // #298
4588 NULL,                                                   // #299
4589 // CSQC range #300-#399
4590 VM_CL_R_ClearScene,                             // #300 void() clearscene (EXT_CSQC)
4591 VM_CL_R_AddEntities,                    // #301 void(float mask) addentities (EXT_CSQC)
4592 VM_CL_R_AddEntity,                              // #302 void(entity ent) addentity (EXT_CSQC)
4593 VM_CL_R_SetView,                                // #303 float(float property, ...) setproperty (EXT_CSQC)
4594 VM_CL_R_RenderScene,                    // #304 void() renderscene (EXT_CSQC)
4595 VM_CL_R_AddDynamicLight,                // #305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
4596 VM_CL_R_PolygonBegin,                   // #306 void(string texturename, float flag, float is2d[NYI: , float lines]) R_BeginPolygon
4597 VM_CL_R_PolygonVertex,                  // #307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
4598 VM_CL_R_PolygonEnd,                             // #308 void() R_EndPolygon
4599 VM_CL_R_SetView,                                // #309 float(float property) getproperty (EXT_CSQC)
4600 VM_CL_unproject,                                // #310 vector (vector v) cs_unproject (EXT_CSQC)
4601 VM_CL_project,                                  // #311 vector (vector v) cs_project (EXT_CSQC)
4602 NULL,                                                   // #312
4603 NULL,                                                   // #313
4604 NULL,                                                   // #314
4605 VM_drawline,                                    // #315 void(float width, vector pos1, vector pos2, float flag) drawline (EXT_CSQC)
4606 VM_iscachedpic,                                 // #316 float(string name) iscachedpic (EXT_CSQC)
4607 VM_precache_pic,                                // #317 string(string name, float trywad) precache_pic (EXT_CSQC)
4608 VM_getimagesize,                                // #318 vector(string picname) draw_getimagesize (EXT_CSQC)
4609 VM_freepic,                                             // #319 void(string name) freepic (EXT_CSQC)
4610 VM_drawcharacter,                               // #320 float(vector position, float character, vector scale, vector rgb, float alpha, float flag) drawcharacter (EXT_CSQC)
4611 VM_drawstring,                                  // #321 float(vector position, string text, vector scale, vector rgb, float alpha[, float flag]) drawstring (EXT_CSQC, DP_CSQC)
4612 VM_drawpic,                                             // #322 float(vector position, string pic, vector size, vector rgb, float alpha[, float flag]) drawpic (EXT_CSQC)
4613 VM_drawfill,                                    // #323 float(vector position, vector size, vector rgb, float alpha, float flag) drawfill (EXT_CSQC)
4614 VM_drawsetcliparea,                             // #324 void(float x, float y, float width, float height) drawsetcliparea
4615 VM_drawresetcliparea,                   // #325 void(void) drawresetcliparea
4616 VM_drawcolorcodedstring,                // #326 float drawcolorcodedstring(vector position, string text, vector scale, vector rgb, float alpha, float flag) (EXT_CSQC)
4617 VM_stringwidth,                 // #327 // FIXME is this okay?
4618 VM_drawsubpic,                                  // #328 // FIXME is this okay?
4619 VM_drawrotpic,                                  // #329 // FIXME is this okay?
4620 VM_CL_getstatf,                                 // #330 float(float stnum) getstatf (EXT_CSQC)
4621 VM_CL_getstati,                                 // #331 float(float stnum) getstati (EXT_CSQC)
4622 VM_CL_getstats,                                 // #332 string(float firststnum) getstats (EXT_CSQC)
4623 VM_CL_setmodelindex,                    // #333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
4624 VM_CL_modelnameforindex,                // #334 string(float mdlindex) modelnameforindex (EXT_CSQC)
4625 VM_CL_particleeffectnum,                // #335 float(string effectname) particleeffectnum (EXT_CSQC)
4626 VM_CL_trailparticles,                   // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
4627 VM_CL_pointparticles,                   // #337 void(float effectnum, vector origin [, vector dir, float count]) pointparticles (EXT_CSQC)
4628 VM_centerprint,                                 // #338 void(string s, ...) centerprint (EXT_CSQC)
4629 VM_print,                                               // #339 void(string s, ...) print (EXT_CSQC, DP_SV_PRINT)
4630 VM_keynumtostring,                              // #340 string(float keynum) keynumtostring (EXT_CSQC)
4631 VM_stringtokeynum,                              // #341 float(string keyname) stringtokeynum (EXT_CSQC)
4632 VM_getkeybind,                                  // #342 string(float keynum[, float bindmap]) getkeybind (EXT_CSQC)
4633 VM_CL_setcursormode,                    // #343 void(float usecursor) setcursormode (DP_CSQC)
4634 VM_CL_getmousepos,                              // #344 vector() getmousepos (DP_CSQC)
4635 VM_CL_getinputstate,                    // #345 float(float framenum) getinputstate (EXT_CSQC)
4636 VM_CL_setsensitivityscale,              // #346 void(float sens) setsensitivityscale (EXT_CSQC)
4637 VM_CL_runplayerphysics,                 // #347 void() runstandardplayerphysics (EXT_CSQC)
4638 VM_CL_getplayerkey,                             // #348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
4639 VM_CL_isdemo,                                   // #349 float() isdemo (EXT_CSQC)
4640 VM_isserver,                                    // #350 float() isserver (EXT_CSQC)
4641 VM_CL_setlistener,                              // #351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
4642 VM_CL_registercmd,                              // #352 void(string cmdname) registercommand (EXT_CSQC)
4643 VM_wasfreed,                                    // #353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
4644 VM_CL_serverkey,                                // #354 string(string key) serverkey (EXT_CSQC)
4645 VM_CL_videoplaying,                             // #355
4646 VM_findfont,                                    // #356 float(string fontname) loadfont (DP_GFX_FONTS)
4647 VM_loadfont,                                    // #357 float(string fontname, string fontmaps, string sizes, float slot) loadfont (DP_GFX_FONTS)
4648 VM_CL_loadcubemap,                              // #358 void(string cubemapname) loadcubemap (DP_GFX_)
4649 NULL,                                                   // #359
4650 VM_CL_ReadByte,                                 // #360 float() readbyte (EXT_CSQC)
4651 VM_CL_ReadChar,                                 // #361 float() readchar (EXT_CSQC)
4652 VM_CL_ReadShort,                                // #362 float() readshort (EXT_CSQC)
4653 VM_CL_ReadLong,                                 // #363 float() readlong (EXT_CSQC)
4654 VM_CL_ReadCoord,                                // #364 float() readcoord (EXT_CSQC)
4655 VM_CL_ReadAngle,                                // #365 float() readangle (EXT_CSQC)
4656 VM_CL_ReadString,                               // #366 string() readstring (EXT_CSQC)
4657 VM_CL_ReadFloat,                                // #367 float() readfloat (EXT_CSQC)
4658 NULL,                                           // #368
4659 NULL,                                                   // #369
4660 NULL,                                                   // #370
4661 NULL,                                                   // #371
4662 NULL,                                                   // #372
4663 NULL,                                                   // #373
4664 NULL,                                                   // #374
4665 NULL,                                                   // #375
4666 NULL,                                                   // #376
4667 NULL,                                                   // #377
4668 NULL,                                                   // #378
4669 NULL,                                                   // #379
4670 NULL,                                                   // #380
4671 NULL,                                                   // #381
4672 NULL,                                                   // #382
4673 NULL,                                                   // #383
4674 NULL,                                                   // #384
4675 NULL,                                                   // #385
4676 NULL,                                                   // #386
4677 NULL,                                                   // #387
4678 NULL,                                                   // #388
4679 NULL,                                                   // #389
4680 NULL,                                                   // #390
4681 NULL,                                                   // #391
4682 NULL,                                                   // #392
4683 NULL,                                                   // #393
4684 NULL,                                                   // #394
4685 NULL,                                                   // #395
4686 NULL,                                                   // #396
4687 NULL,                                                   // #397
4688 NULL,                                                   // #398
4689 NULL,                                                   // #399
4690 // LordHavoc's range #400-#499
4691 VM_CL_copyentity,                               // #400 void(entity from, entity to) copyentity (DP_QC_COPYENTITY)
4692 NULL,                                                   // #401 void(entity ent, float colors) setcolor (DP_QC_SETCOLOR)
4693 VM_findchain,                                   // #402 entity(.string fld, string match) findchain (DP_QC_FINDCHAIN)
4694 VM_findchainfloat,                              // #403 entity(.float fld, float match) findchainfloat (DP_QC_FINDCHAINFLOAT)
4695 VM_CL_effect,                                   // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
4696 VM_CL_te_blood,                                 // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
4697 VM_CL_te_bloodshower,                   // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
4698 VM_CL_te_explosionrgb,                  // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
4699 VM_CL_te_particlecube,                  // #408 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color, float gravityflag, float randomveljitter) te_particlecube (DP_TE_PARTICLECUBE)
4700 VM_CL_te_particlerain,                  // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
4701 VM_CL_te_particlesnow,                  // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
4702 VM_CL_te_spark,                                 // #411 void(vector org, vector vel, float howmany) te_spark (DP_TE_SPARK)
4703 VM_CL_te_gunshotquad,                   // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
4704 VM_CL_te_spikequad,                             // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
4705 VM_CL_te_superspikequad,                // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
4706 VM_CL_te_explosionquad,                 // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
4707 VM_CL_te_smallflash,                    // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
4708 VM_CL_te_customflash,                   // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
4709 VM_CL_te_gunshot,                               // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
4710 VM_CL_te_spike,                                 // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
4711 VM_CL_te_superspike,                    // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
4712 VM_CL_te_explosion,                             // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
4713 VM_CL_te_tarexplosion,                  // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
4714 VM_CL_te_wizspike,                              // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
4715 VM_CL_te_knightspike,                   // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
4716 VM_CL_te_lavasplash,                    // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
4717 VM_CL_te_teleport,                              // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
4718 VM_CL_te_explosion2,                    // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
4719 VM_CL_te_lightning1,                    // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
4720 VM_CL_te_lightning2,                    // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
4721 VM_CL_te_lightning3,                    // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
4722 VM_CL_te_beam,                                  // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
4723 VM_vectorvectors,                               // #432 void(vector dir) vectorvectors (DP_QC_VECTORVECTORS)
4724 VM_CL_te_plasmaburn,                    // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
4725 VM_getsurfacenumpoints,         // #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
4726 VM_getsurfacepoint,                     // #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
4727 VM_getsurfacenormal,                    // #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
4728 VM_getsurfacetexture,           // #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
4729 VM_getsurfacenearpoint,         // #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
4730 VM_getsurfaceclippedpoint,      // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
4731 NULL,                                                   // #440 void(entity e, string s) clientcommand (KRIMZON_SV_PARSECLIENTCOMMAND)
4732 VM_tokenize,                                    // #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
4733 VM_argv,                                                // #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
4734 VM_CL_setattachment,                    // #443 void(entity e, entity tagentity, string tagname) setattachment (DP_GFX_QUAKE3MODELTAGS)
4735 VM_search_begin,                                // #444 float(string pattern, float caseinsensitive, float quiet) search_begin (DP_QC_FS_SEARCH)
4736 VM_search_end,                                  // #445 void(float handle) search_end (DP_QC_FS_SEARCH)
4737 VM_search_getsize,                              // #446 float(float handle) search_getsize (DP_QC_FS_SEARCH)
4738 VM_search_getfilename,                  // #447 string(float handle, float num) search_getfilename (DP_QC_FS_SEARCH)
4739 VM_cvar_string,                                 // #448 string(string s) cvar_string (DP_QC_CVAR_STRING)
4740 VM_findflags,                                   // #449 entity(entity start, .float fld, float match) findflags (DP_QC_FINDFLAGS)
4741 VM_findchainflags,                              // #450 entity(.float fld, float match) findchainflags (DP_QC_FINDCHAINFLAGS)
4742 VM_CL_gettagindex,                              // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
4743 VM_CL_gettaginfo,                               // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
4744 NULL,                                                   // #453 void(entity clent) dropclient (DP_SV_DROPCLIENT)
4745 NULL,                                                   // #454 entity() spawnclient (DP_SV_BOTCLIENT)
4746 NULL,                                                   // #455 float(entity clent) clienttype (DP_SV_BOTCLIENT)
4747 NULL,                                                   // #456 void(float to, string s) WriteUnterminatedString (DP_SV_WRITEUNTERMINATEDSTRING)
4748 VM_CL_te_flamejet,                              // #457 void(vector org, vector vel, float howmany) te_flamejet (DP_TE_FLAMEJET)
4749 NULL,                                                   // #458
4750 VM_ftoe,                                                // #459 entity(float num) entitybyindex (DP_QC_EDICT_NUM)
4751 VM_buf_create,                                  // #460 float() buf_create (DP_QC_STRINGBUFFERS)
4752 VM_buf_del,                                             // #461 void(float bufhandle) buf_del (DP_QC_STRINGBUFFERS)
4753 VM_buf_getsize,                                 // #462 float(float bufhandle) buf_getsize (DP_QC_STRINGBUFFERS)
4754 VM_buf_copy,                                    // #463 void(float bufhandle_from, float bufhandle_to) buf_copy (DP_QC_STRINGBUFFERS)
4755 VM_buf_sort,                                    // #464 void(float bufhandle, float sortpower, float backward) buf_sort (DP_QC_STRINGBUFFERS)
4756 VM_buf_implode,                                 // #465 string(float bufhandle, string glue) buf_implode (DP_QC_STRINGBUFFERS)
4757 VM_bufstr_get,                                  // #466 string(float bufhandle, float string_index) bufstr_get (DP_QC_STRINGBUFFERS)
4758 VM_bufstr_set,                                  // #467 void(float bufhandle, float string_index, string str) bufstr_set (DP_QC_STRINGBUFFERS)
4759 VM_bufstr_add,                                  // #468 float(float bufhandle, string str, float order) bufstr_add (DP_QC_STRINGBUFFERS)
4760 VM_bufstr_free,                                 // #469 void(float bufhandle, float string_index) bufstr_free (DP_QC_STRINGBUFFERS)
4761 NULL,                                                   // #470 void(float index, float type, .void field) SV_AddStat (EXT_CSQC)
4762 VM_asin,                                                // #471 float(float s) VM_asin (DP_QC_ASINACOSATANATAN2TAN)
4763 VM_acos,                                                // #472 float(float c) VM_acos (DP_QC_ASINACOSATANATAN2TAN)
4764 VM_atan,                                                // #473 float(float t) VM_atan (DP_QC_ASINACOSATANATAN2TAN)
4765 VM_atan2,                                               // #474 float(float c, float s) VM_atan2 (DP_QC_ASINACOSATANATAN2TAN)
4766 VM_tan,                                                 // #475 float(float a) VM_tan (DP_QC_ASINACOSATANATAN2TAN)
4767 VM_strlennocol,                                 // #476 float(string s) : DRESK - String Length (not counting color codes) (DP_QC_STRINGCOLORFUNCTIONS)
4768 VM_strdecolorize,                               // #477 string(string s) : DRESK - Decolorized String (DP_QC_STRINGCOLORFUNCTIONS)
4769 VM_strftime,                                    // #478 string(float uselocaltime, string format, ...) (DP_QC_STRFTIME)
4770 VM_tokenizebyseparator,                 // #479 float(string s) tokenizebyseparator (DP_QC_TOKENIZEBYSEPARATOR)
4771 VM_strtolower,                                  // #480 string(string s) VM_strtolower (DP_QC_STRING_CASE_FUNCTIONS)
4772 VM_strtoupper,                                  // #481 string(string s) VM_strtoupper (DP_QC_STRING_CASE_FUNCTIONS)
4773 VM_cvar_defstring,                              // #482 string(string s) cvar_defstring (DP_QC_CVAR_DEFSTRING)
4774 VM_CL_pointsound,                               // #483 void(vector origin, string sample, float volume, float attenuation) pointsound (DP_SV_POINTSOUND)
4775 VM_strreplace,                                  // #484 string(string search, string replace, string subject) strreplace (DP_QC_STRREPLACE)
4776 VM_strireplace,                                 // #485 string(string search, string replace, string subject) strireplace (DP_QC_STRREPLACE)
4777 VM_getsurfacepointattribute,// #486 vector(entity e, float s, float n, float a) getsurfacepointattribute
4778 VM_gecko_create,                                        // #487 float gecko_create( string name )
4779 VM_gecko_destroy,                                       // #488 void gecko_destroy( string name )
4780 VM_gecko_navigate,                              // #489 void gecko_navigate( string name, string URI )
4781 VM_gecko_keyevent,                              // #490 float gecko_keyevent( string name, float key, float eventtype )
4782 VM_gecko_movemouse,                             // #491 void gecko_mousemove( string name, float x, float y )
4783 VM_gecko_resize,                                        // #492 void gecko_resize( string name, float w, float h )
4784 VM_gecko_get_texture_extent,    // #493 vector gecko_get_texture_extent( string name )
4785 VM_crc16,                                               // #494 float(float caseinsensitive, string s, ...) crc16 = #494 (DP_QC_CRC16)
4786 VM_cvar_type,                                   // #495 float(string name) cvar_type = #495; (DP_QC_CVAR_TYPE)
4787 VM_numentityfields,                             // #496 float() numentityfields = #496; (QP_QC_ENTITYDATA)
4788 VM_entityfieldname,                             // #497 string(float fieldnum) entityfieldname = #497; (DP_QC_ENTITYDATA)
4789 VM_entityfieldtype,                             // #498 float(float fieldnum) entityfieldtype = #498; (DP_QC_ENTITYDATA)
4790 VM_getentityfieldstring,                // #499 string(float fieldnum, entity ent) getentityfieldstring = #499; (DP_QC_ENTITYDATA)
4791 VM_putentityfieldstring,                // #500 float(float fieldnum, entity ent, string s) putentityfieldstring = #500; (DP_QC_ENTITYDATA)
4792 VM_CL_ReadPicture,                              // #501 string() ReadPicture = #501;
4793 VM_CL_boxparticles,                             // #502 void(float effectnum, entity own, vector origin_from, vector origin_to, vector dir_from, vector dir_to, float count) boxparticles (DP_CSQC_BOXPARTICLES)
4794 VM_whichpack,                                   // #503 string(string) whichpack = #503;
4795 VM_CL_GetEntity,                                // #504 float(float entitynum, float fldnum) getentity = #504; vector(float entitynum, float fldnum) getentityvec = #504;
4796 NULL,                                                   // #505
4797 NULL,                                                   // #506
4798 NULL,                                                   // #507
4799 NULL,                                                   // #508
4800 NULL,                                                   // #509
4801 VM_uri_escape,                                  // #510 string(string in) uri_escape = #510;
4802 VM_uri_unescape,                                // #511 string(string in) uri_unescape = #511;
4803 VM_etof,                                        // #512 float(entity ent) num_for_edict = #512 (DP_QC_NUM_FOR_EDICT)
4804 VM_uri_get,                                             // #513 float(string uri, float id, [string post_contenttype, string post_delim, [float buf]]) uri_get = #513; (DP_QC_URI_GET, DP_QC_URI_POST)
4805 VM_tokenize_console,                                    // #514 float(string str) tokenize_console = #514; (DP_QC_TOKENIZE_CONSOLE)
4806 VM_argv_start_index,                                    // #515 float(float idx) argv_start_index = #515; (DP_QC_TOKENIZE_CONSOLE)
4807 VM_argv_end_index,                                              // #516 float(float idx) argv_end_index = #516; (DP_QC_TOKENIZE_CONSOLE)
4808 VM_buf_cvarlist,                                                // #517 void(float buf, string prefix, string antiprefix) buf_cvarlist = #517; (DP_QC_STRINGBUFFERS_CVARLIST)
4809 VM_cvar_description,                                    // #518 float(string name) cvar_description = #518; (DP_QC_CVAR_DESCRIPTION)
4810 VM_gettime,                                             // #519 float(float timer) gettime = #519; (DP_QC_GETTIME)
4811 VM_keynumtostring,                              // #520 string keynumtostring(float keynum)
4812 VM_findkeysforcommand,                  // #521 string findkeysforcommand(string command[, float bindmap])
4813 VM_CL_InitParticleSpawner,              // #522 void(float max_themes) initparticlespawner (DP_CSQC_SPAWNPARTICLE)
4814 VM_CL_ResetParticle,                    // #523 void() resetparticle (DP_CSQC_SPAWNPARTICLE)
4815 VM_CL_ParticleTheme,                    // #524 void(float theme) particletheme (DP_CSQC_SPAWNPARTICLE)
4816 VM_CL_ParticleThemeSave,                // #525 void() particlethemesave, void(float theme) particlethemeupdate (DP_CSQC_SPAWNPARTICLE)
4817 VM_CL_ParticleThemeFree,                // #526 void() particlethemefree (DP_CSQC_SPAWNPARTICLE)
4818 VM_CL_SpawnParticle,                    // #527 float(vector org, vector vel, [float theme]) particle (DP_CSQC_SPAWNPARTICLE)
4819 VM_CL_SpawnParticleDelayed,             // #528 float(vector org, vector vel, float delay, float collisiondelay, [float theme]) delayedparticle (DP_CSQC_SPAWNPARTICLE)
4820 VM_loadfromdata,                                // #529
4821 VM_loadfromfile,                                // #530
4822 VM_CL_setpause,                                 // #531 float(float ispaused) setpause = #531 (DP_CSQC_SETPAUSE)
4823 VM_log,                                                 // #532
4824 VM_getsoundtime,                                // #533 float(entity e, float channel) getsoundtime = #533; (DP_SND_GETSOUNDTIME)
4825 VM_soundlength,                                 // #534 float(string sample) soundlength = #534; (DP_SND_GETSOUNDTIME)
4826 VM_buf_loadfile,                // #535 float(string filename, float bufhandle) buf_loadfile (DP_QC_STRINGBUFFERS_EXT_WIP)
4827 VM_buf_writefile,               // #536 float(float filehandle, float bufhandle, float startpos, float numstrings) buf_writefile (DP_QC_STRINGBUFFERS_EXT_WIP)
4828 VM_bufstr_find,                 // #537 float(float bufhandle, string match, float matchrule, float startpos) bufstr_find (DP_QC_STRINGBUFFERS_EXT_WIP)
4829 VM_matchpattern,                // #538 float(string s, string pattern, float matchrule) matchpattern (DP_QC_STRINGBUFFERS_EXT_WIP)
4830 NULL,                                                   // #539
4831 VM_physics_enable,                              // #540 void(entity e, float physics_enabled) physics_enable = #540; (DP_PHYSICS_ODE)
4832 VM_physics_addforce,                    // #541 void(entity e, vector force, vector relative_ofs) physics_addforce = #541; (DP_PHYSICS_ODE)
4833 VM_physics_addtorque,                   // #542 void(entity e, vector torque) physics_addtorque = #542; (DP_PHYSICS_ODE)
4834 NULL,                                                   // #543
4835 NULL,                                                   // #544
4836 NULL,                                                   // #545
4837 NULL,                                                   // #546
4838 NULL,                                                   // #547
4839 NULL,                                                   // #548
4840 NULL,                                                   // #549
4841 NULL,                                                   // #550
4842 NULL,                                                   // #551
4843 NULL,                                                   // #552
4844 NULL,                                                   // #553
4845 NULL,                                                   // #554
4846 NULL,                                                   // #555
4847 NULL,                                                   // #556
4848 NULL,                                                   // #557
4849 NULL,                                                   // #558
4850 NULL,                                                   // #559
4851 NULL,                                                   // #560
4852 NULL,                                                   // #561
4853 NULL,                                                   // #562
4854 NULL,                                                   // #563
4855 NULL,                                                   // #564
4856 NULL,                                                   // #565
4857 NULL,                                                   // #566
4858 NULL,                                                   // #567
4859 NULL,                                                   // #568
4860 NULL,                                                   // #569
4861 NULL,                                                   // #570
4862 NULL,                                                   // #571
4863 NULL,                                                   // #572
4864 NULL,                                                   // #573
4865 NULL,                                                   // #574
4866 NULL,                                                   // #575
4867 NULL,                                                   // #576
4868 NULL,                                                   // #577
4869 NULL,                                                   // #578
4870 NULL,                                                   // #579
4871 NULL,                                                   // #580
4872 NULL,                                                   // #581
4873 NULL,                                                   // #582
4874 NULL,                                                   // #583
4875 NULL,                                                   // #584
4876 NULL,                                                   // #585
4877 NULL,                                                   // #586
4878 NULL,                                                   // #587
4879 NULL,                                                   // #588
4880 NULL,                                                   // #589
4881 NULL,                                                   // #590
4882 NULL,                                                   // #591
4883 NULL,                                                   // #592
4884 NULL,                                                   // #593
4885 NULL,                                                   // #594
4886 NULL,                                                   // #595
4887 NULL,                                                   // #596
4888 NULL,                                                   // #597
4889 NULL,                                                   // #598
4890 NULL,                                                   // #599
4891 NULL,                                                   // #600
4892 NULL,                                                   // #601
4893 NULL,                                                   // #602
4894 NULL,                                                   // #603
4895 NULL,                                                   // #604
4896 VM_callfunction,                                // #605
4897 VM_writetofile,                                 // #606
4898 VM_isfunction,                                  // #607
4899 NULL,                                                   // #608
4900 NULL,                                                   // #609
4901 VM_findkeysforcommand,                  // #610 string findkeysforcommand(string command[, float bindmap])
4902 NULL,                                                   // #611
4903 NULL,                                                   // #612
4904 VM_parseentitydata,                             // #613
4905 NULL,                                                   // #614
4906 NULL,                                                   // #615
4907 NULL,                                                   // #616
4908 NULL,                                                   // #617
4909 NULL,                                                   // #618
4910 NULL,                                                   // #619
4911 NULL,                                                   // #620
4912 NULL,                                                   // #621
4913 NULL,                                                   // #622
4914 NULL,                                                   // #623
4915 VM_CL_getextresponse,                   // #624 string getextresponse(void)
4916 NULL,                                                   // #625
4917 NULL,                                                   // #626
4918 VM_sprintf,                     // #627 string sprintf(string format, ...)
4919 VM_getsurfacenumtriangles,              // #628 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACETRIANGLE)
4920 VM_getsurfacetriangle,                  // #629 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACETRIANGLE)
4921 VM_setkeybind,                                          // #630 float(float key, string bind[, float bindmap]) setkeybind
4922 VM_getbindmaps,                                         // #631 vector(void) getbindmap
4923 VM_setbindmaps,                                         // #632 float(vector bm) setbindmap
4924 NULL,                                                   // #633
4925 NULL,                                                   // #634
4926 NULL,                                                   // #635
4927 NULL,                                                   // #636
4928 NULL,                                                   // #637
4929 VM_CL_RotateMoves,                                      // #638
4930 VM_digest_hex,                                          // #639
4931 VM_CL_V_CalcRefdef,                                     // #640 void(entity e) V_CalcRefdef (DP_CSQC_V_CALCREFDEF)
4932 NULL,                                                   // #641
4933 VM_coverage,                                            // #642
4934 NULL
4935 };
4936
4937 const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);
4938
4939 void VM_Polygons_Reset(prvm_prog_t *prog)
4940 {
4941         vmpolygons_t *polys = &prog->vmpolygons;
4942
4943         // TODO: replace vm_polygons stuff with a more general debugging polygon system, and make vm_polygons functions use that system
4944         if(polys->initialized)
4945         {
4946                 Mem_FreePool(&polys->pool);
4947                 polys->initialized = false;
4948         }
4949 }
4950
4951 void CLVM_init_cmd(prvm_prog_t *prog)
4952 {
4953         VM_Cmd_Init(prog);
4954         VM_Polygons_Reset(prog);
4955 }
4956
4957 void CLVM_reset_cmd(prvm_prog_t *prog)
4958 {
4959         World_End(&cl.world);
4960         VM_Cmd_Reset(prog);
4961         VM_Polygons_Reset(prog);
4962 }