clvm_cmds.c

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