clvm_cmds.c

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