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