5 #include "cl_collision.h"
10 //============================================================================
12 //[515]: unsolved PROBLEMS
13 //- finish player physics code (cs_runplayerphysics)
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
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
23 extern cvar_t v_flipped;
24 extern cvar_t r_equalize_entities_fullbright;
26 sfx_t *S_FindName(const char *name);
27 int Sbar_GetSortedPlayerIndex (int index);
28 void Sbar_SortFrags (void);
29 void CL_FindNonSolidLocation(const vec3_t in, vec3_t out, vec_t radius);
30 void CSQC_RelinkAllEntities (int drawmask);
31 void CSQC_RelinkCSQCEntities (void);
32 const char *Key_GetBind (int key);
34 // #1 void(vector ang) makevectors
35 static void VM_CL_makevectors (void)
37 VM_SAFEPARMCOUNT(1, VM_CL_makevectors);
38 AngleVectors (PRVM_G_VECTOR(OFS_PARM0), prog->globals.client->v_forward, prog->globals.client->v_right, prog->globals.client->v_up);
41 // #2 void(entity e, vector o) setorigin
42 void VM_CL_setorigin (void)
46 VM_SAFEPARMCOUNT(2, VM_CL_setorigin);
48 e = PRVM_G_EDICT(OFS_PARM0);
49 if (e == prog->edicts)
51 VM_Warning("setorigin: can not modify world entity\n");
54 if (e->priv.required->free)
56 VM_Warning("setorigin: can not modify free entity\n");
59 org = PRVM_G_VECTOR(OFS_PARM1);
60 VectorCopy (org, e->fields.client->origin);
64 static void SetMinMaxSize (prvm_edict_t *e, float *min, float *max)
70 PRVM_ERROR("SetMinMaxSize: backwards mins/maxs");
73 VectorCopy (min, e->fields.client->mins);
74 VectorCopy (max, e->fields.client->maxs);
75 VectorSubtract (max, min, e->fields.client->size);
80 // #3 void(entity e, string m) setmodel
81 void VM_CL_setmodel (void)
88 VM_SAFEPARMCOUNT(2, VM_CL_setmodel);
90 e = PRVM_G_EDICT(OFS_PARM0);
91 e->fields.client->modelindex = 0;
92 e->fields.client->model = 0;
94 m = PRVM_G_STRING(OFS_PARM1);
96 for (i = 0;i < MAX_MODELS && cl.csqc_model_precache[i];i++)
98 if (!strcmp(cl.csqc_model_precache[i]->name, m))
100 mod = cl.csqc_model_precache[i];
101 e->fields.client->model = PRVM_SetEngineString(mod->name);
102 e->fields.client->modelindex = -(i+1);
108 for (i = 0;i < MAX_MODELS;i++)
110 mod = cl.model_precache[i];
111 if (mod && !strcmp(mod->name, m))
113 e->fields.client->model = PRVM_SetEngineString(mod->name);
114 e->fields.client->modelindex = i;
121 // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
122 //SetMinMaxSize (e, mod->normalmins, mod->normalmaxs);
126 SetMinMaxSize (e, vec3_origin, vec3_origin);
127 VM_Warning ("setmodel: model '%s' not precached\n", m);
131 // #4 void(entity e, vector min, vector max) setsize
132 static void VM_CL_setsize (void)
136 VM_SAFEPARMCOUNT(3, VM_CL_setsize);
138 e = PRVM_G_EDICT(OFS_PARM0);
139 if (e == prog->edicts)
141 VM_Warning("setsize: can not modify world entity\n");
144 if (e->priv.server->free)
146 VM_Warning("setsize: can not modify free entity\n");
149 min = PRVM_G_VECTOR(OFS_PARM1);
150 max = PRVM_G_VECTOR(OFS_PARM2);
152 SetMinMaxSize( e, min, max );
157 // #8 void(entity e, float chan, string samp, float volume, float atten) sound
158 static void VM_CL_sound (void)
162 prvm_edict_t *entity;
167 VM_SAFEPARMCOUNT(5, VM_CL_sound);
169 entity = PRVM_G_EDICT(OFS_PARM0);
170 channel = (int)PRVM_G_FLOAT(OFS_PARM1);
171 sample = PRVM_G_STRING(OFS_PARM2);
172 volume = PRVM_G_FLOAT(OFS_PARM3);
173 attenuation = PRVM_G_FLOAT(OFS_PARM4);
175 if (volume < 0 || volume > 1)
177 VM_Warning("VM_CL_sound: volume must be in range 0-1\n");
181 if (attenuation < 0 || attenuation > 4)
183 VM_Warning("VM_CL_sound: attenuation must be in range 0-4\n");
187 if (channel < 0 || channel > 7)
189 VM_Warning("VM_CL_sound: channel must be in range 0-7\n");
193 CL_VM_GetEntitySoundOrigin(MAX_EDICTS + PRVM_NUM_FOR_EDICT(entity), org);
194 S_StartSound(MAX_EDICTS + PRVM_NUM_FOR_EDICT(entity), channel, S_FindName(sample), org, volume, attenuation);
197 // #483 void(vector origin, string sample, float volume, float attenuation) pointsound
198 static void VM_CL_pointsound(void)
205 VM_SAFEPARMCOUNT(4, VM_CL_pointsound);
207 VectorCopy( PRVM_G_VECTOR(OFS_PARM0), org);
208 sample = PRVM_G_STRING(OFS_PARM1);
209 volume = PRVM_G_FLOAT(OFS_PARM2);
210 attenuation = PRVM_G_FLOAT(OFS_PARM3);
212 if (volume < 0 || volume > 1)
214 VM_Warning("VM_CL_pointsound: volume must be in range 0-1\n");
218 if (attenuation < 0 || attenuation > 4)
220 VM_Warning("VM_CL_pointsound: attenuation must be in range 0-4\n");
224 // Send World Entity as Entity to Play Sound (for CSQC, that is MAX_EDICTS)
225 S_StartSound(MAX_EDICTS, 0, S_FindName(sample), org, volume, attenuation);
228 // #14 entity() spawn
229 static void VM_CL_spawn (void)
232 ed = PRVM_ED_Alloc();
236 void CL_VM_SetTraceGlobals(const trace_t *trace, int svent)
239 VM_SetTraceGlobals(trace);
240 if ((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.trace_networkentity)))
244 #define CL_HitNetworkBrushModels(move) !((move) == MOVE_WORLDONLY)
245 #define CL_HitNetworkPlayers(move) !((move) == MOVE_WORLDONLY || (move) == MOVE_NOMONSTERS)
247 // #16 void(vector v1, vector v2, float movetype, entity ignore) traceline
248 static void VM_CL_traceline (void)
255 VM_SAFEPARMCOUNTRANGE(4, 4, VM_CL_traceline);
257 prog->xfunction->builtinsprofile += 30;
259 v1 = PRVM_G_VECTOR(OFS_PARM0);
260 v2 = PRVM_G_VECTOR(OFS_PARM1);
261 move = (int)PRVM_G_FLOAT(OFS_PARM2);
262 ent = PRVM_G_EDICT(OFS_PARM3);
264 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]))
265 PRVM_ERROR("%s: NAN errors detected in traceline('%f %f %f', '%f %f %f', %i, entity %i)\n", PRVM_NAME, v1[0], v1[1], v1[2], v2[0], v2[1], v2[2], move, PRVM_EDICT_TO_PROG(ent));
267 trace = CL_TraceLine(v1, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
269 CL_VM_SetTraceGlobals(&trace, svent);
276 Used for use tracing and shot targeting
277 Traces are blocked by bbox and exact bsp entityes, and also slide box entities
278 if the tryents flag is set.
280 tracebox (vector1, vector mins, vector maxs, vector2, tryents)
283 // LordHavoc: added this for my own use, VERY useful, similar to traceline
284 static void VM_CL_tracebox (void)
286 float *v1, *v2, *m1, *m2;
291 VM_SAFEPARMCOUNTRANGE(6, 8, VM_CL_tracebox); // allow more parameters for future expansion
293 prog->xfunction->builtinsprofile += 30;
295 v1 = PRVM_G_VECTOR(OFS_PARM0);
296 m1 = PRVM_G_VECTOR(OFS_PARM1);
297 m2 = PRVM_G_VECTOR(OFS_PARM2);
298 v2 = PRVM_G_VECTOR(OFS_PARM3);
299 move = (int)PRVM_G_FLOAT(OFS_PARM4);
300 ent = PRVM_G_EDICT(OFS_PARM5);
302 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]))
303 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));
305 trace = CL_TraceBox(v1, m1, m2, v2, move, ent, CL_GenericHitSuperContentsMask(ent), CL_HitNetworkBrushModels(move), CL_HitNetworkPlayers(move), &svent, true);
307 CL_VM_SetTraceGlobals(&trace, svent);
310 trace_t CL_Trace_Toss (prvm_edict_t *tossent, prvm_edict_t *ignore, int *svent)
315 vec3_t original_origin;
316 vec3_t original_velocity;
317 vec3_t original_angles;
318 vec3_t original_avelocity;
322 VectorCopy(tossent->fields.client->origin , original_origin );
323 VectorCopy(tossent->fields.client->velocity , original_velocity );
324 VectorCopy(tossent->fields.client->angles , original_angles );
325 VectorCopy(tossent->fields.client->avelocity, original_avelocity);
327 val = PRVM_EDICTFIELDVALUE(tossent, prog->fieldoffsets.gravity);
328 if (val != NULL && val->_float != 0)
329 gravity = val->_float;
332 gravity *= cl.movevars_gravity * 0.05;
334 for (i = 0;i < 200;i++) // LordHavoc: sanity check; never trace more than 10 seconds
336 tossent->fields.client->velocity[2] -= gravity;
337 VectorMA (tossent->fields.client->angles, 0.05, tossent->fields.client->avelocity, tossent->fields.client->angles);
338 VectorScale (tossent->fields.client->velocity, 0.05, move);
339 VectorAdd (tossent->fields.client->origin, move, end);
340 trace = CL_TraceBox(tossent->fields.client->origin, tossent->fields.client->mins, tossent->fields.client->maxs, end, MOVE_NORMAL, tossent, CL_GenericHitSuperContentsMask(tossent), true, true, NULL, true);
341 VectorCopy (trace.endpos, tossent->fields.client->origin);
343 if (trace.fraction < 1)
347 VectorCopy(original_origin , tossent->fields.client->origin );
348 VectorCopy(original_velocity , tossent->fields.client->velocity );
349 VectorCopy(original_angles , tossent->fields.client->angles );
350 VectorCopy(original_avelocity, tossent->fields.client->avelocity);
355 static void VM_CL_tracetoss (void)
359 prvm_edict_t *ignore;
362 prog->xfunction->builtinsprofile += 600;
364 VM_SAFEPARMCOUNT(2, VM_CL_tracetoss);
366 ent = PRVM_G_EDICT(OFS_PARM0);
367 if (ent == prog->edicts)
369 VM_Warning("tracetoss: can not use world entity\n");
372 ignore = PRVM_G_EDICT(OFS_PARM1);
374 trace = CL_Trace_Toss (ent, ignore, &svent);
376 CL_VM_SetTraceGlobals(&trace, svent);
380 // #20 void(string s) precache_model
381 void VM_CL_precache_model (void)
387 VM_SAFEPARMCOUNT(1, VM_CL_precache_model);
389 name = PRVM_G_STRING(OFS_PARM0);
390 for (i = 0;i < MAX_MODELS && cl.csqc_model_precache[i];i++)
392 if(!strcmp(cl.csqc_model_precache[i]->name, name))
394 PRVM_G_FLOAT(OFS_RETURN) = -(i+1);
398 PRVM_G_FLOAT(OFS_RETURN) = 0;
399 m = Mod_ForName(name, false, false, name[0] == '*' ? cl.model_name[1] : NULL);
402 for (i = 0;i < MAX_MODELS;i++)
404 if (!cl.csqc_model_precache[i])
406 cl.csqc_model_precache[i] = (dp_model_t*)m;
407 PRVM_G_FLOAT(OFS_RETURN) = -(i+1);
411 VM_Warning("VM_CL_precache_model: no free models\n");
414 VM_Warning("VM_CL_precache_model: model \"%s\" not found\n", name);
417 int CSQC_EntitiesInBox (vec3_t mins, vec3_t maxs, int maxlist, prvm_edict_t **list)
422 ent = PRVM_NEXT_EDICT(prog->edicts);
423 for(k=0,i=1; i<prog->num_edicts ;i++, ent = PRVM_NEXT_EDICT(ent))
425 if (ent->priv.required->free)
427 if(BoxesOverlap(mins, maxs, ent->fields.client->absmin, ent->fields.client->absmax))
433 // #22 entity(vector org, float rad) findradius
434 static void VM_CL_findradius (void)
436 prvm_edict_t *ent, *chain;
437 vec_t radius, radius2;
438 vec3_t org, eorg, mins, maxs;
439 int i, numtouchedicts;
440 static prvm_edict_t *touchedicts[MAX_EDICTS];
443 VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_findradius);
446 chainfield = PRVM_G_INT(OFS_PARM2);
448 chainfield = prog->fieldoffsets.chain;
450 PRVM_ERROR("VM_findchain: %s doesnt have the specified chain field !", PRVM_NAME);
452 chain = (prvm_edict_t *)prog->edicts;
454 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), org);
455 radius = PRVM_G_FLOAT(OFS_PARM1);
456 radius2 = radius * radius;
458 mins[0] = org[0] - (radius + 1);
459 mins[1] = org[1] - (radius + 1);
460 mins[2] = org[2] - (radius + 1);
461 maxs[0] = org[0] + (radius + 1);
462 maxs[1] = org[1] + (radius + 1);
463 maxs[2] = org[2] + (radius + 1);
464 numtouchedicts = CSQC_EntitiesInBox(mins, maxs, MAX_EDICTS, touchedicts);
465 if (numtouchedicts > MAX_EDICTS)
467 // this never happens //[515]: for what then ?
468 Con_Printf("CSQC_EntitiesInBox returned %i edicts, max was %i\n", numtouchedicts, MAX_EDICTS);
469 numtouchedicts = MAX_EDICTS;
471 for (i = 0;i < numtouchedicts;i++)
473 ent = touchedicts[i];
474 // Quake did not return non-solid entities but darkplaces does
475 // (note: this is the reason you can't blow up fallen zombies)
476 if (ent->fields.client->solid == SOLID_NOT && !sv_gameplayfix_blowupfallenzombies.integer)
478 // LordHavoc: compare against bounding box rather than center so it
479 // doesn't miss large objects, and use DotProduct instead of Length
480 // for a major speedup
481 VectorSubtract(org, ent->fields.client->origin, eorg);
482 if (sv_gameplayfix_findradiusdistancetobox.integer)
484 eorg[0] -= bound(ent->fields.client->mins[0], eorg[0], ent->fields.client->maxs[0]);
485 eorg[1] -= bound(ent->fields.client->mins[1], eorg[1], ent->fields.client->maxs[1]);
486 eorg[2] -= bound(ent->fields.client->mins[2], eorg[2], ent->fields.client->maxs[2]);
489 VectorMAMAM(1, eorg, -0.5f, ent->fields.client->mins, -0.5f, ent->fields.client->maxs, eorg);
490 if (DotProduct(eorg, eorg) < radius2)
492 PRVM_EDICTFIELDVALUE(ent, chainfield)->edict = PRVM_EDICT_TO_PROG(chain);
497 VM_RETURN_EDICT(chain);
500 // #34 float() droptofloor
501 static void VM_CL_droptofloor (void)
508 VM_SAFEPARMCOUNTRANGE(0, 2, VM_CL_droptofloor); // allow 2 parameters because the id1 defs.qc had an incorrect prototype
510 // assume failure if it returns early
511 PRVM_G_FLOAT(OFS_RETURN) = 0;
513 ent = PRVM_PROG_TO_EDICT(prog->globals.client->self);
514 if (ent == prog->edicts)
516 VM_Warning("droptofloor: can not modify world entity\n");
519 if (ent->priv.server->free)
521 VM_Warning("droptofloor: can not modify free entity\n");
525 VectorCopy (ent->fields.client->origin, end);
528 trace = CL_TraceBox(ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
530 if (trace.fraction != 1)
532 VectorCopy (trace.endpos, ent->fields.client->origin);
533 ent->fields.client->flags = (int)ent->fields.client->flags | FL_ONGROUND;
534 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.groundentity)))
535 val->edict = PRVM_EDICT_TO_PROG(trace.ent);
536 PRVM_G_FLOAT(OFS_RETURN) = 1;
537 // if support is destroyed, keep suspended (gross hack for floating items in various maps)
538 // ent->priv.server->suspendedinairflag = true;
542 // #35 void(float style, string value) lightstyle
543 static void VM_CL_lightstyle (void)
548 VM_SAFEPARMCOUNT(2, VM_CL_lightstyle);
550 i = (int)PRVM_G_FLOAT(OFS_PARM0);
551 c = PRVM_G_STRING(OFS_PARM1);
552 if (i >= cl.max_lightstyle)
554 VM_Warning("VM_CL_lightstyle >= MAX_LIGHTSTYLES\n");
557 strlcpy (cl.lightstyle[i].map, c, sizeof (cl.lightstyle[i].map));
558 cl.lightstyle[i].map[MAX_STYLESTRING - 1] = 0;
559 cl.lightstyle[i].length = (int)strlen(cl.lightstyle[i].map);
562 // #40 float(entity e) checkbottom
563 static void VM_CL_checkbottom (void)
565 static int cs_yes, cs_no;
567 vec3_t mins, maxs, start, stop;
572 VM_SAFEPARMCOUNT(1, VM_CL_checkbottom);
573 ent = PRVM_G_EDICT(OFS_PARM0);
574 PRVM_G_FLOAT(OFS_RETURN) = 0;
576 VectorAdd (ent->fields.client->origin, ent->fields.client->mins, mins);
577 VectorAdd (ent->fields.client->origin, ent->fields.client->maxs, maxs);
579 // if all of the points under the corners are solid world, don't bother
580 // with the tougher checks
581 // the corners must be within 16 of the midpoint
582 start[2] = mins[2] - 1;
583 for (x=0 ; x<=1 ; x++)
584 for (y=0 ; y<=1 ; y++)
586 start[0] = x ? maxs[0] : mins[0];
587 start[1] = y ? maxs[1] : mins[1];
588 if (!(CL_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
593 PRVM_G_FLOAT(OFS_RETURN) = true;
594 return; // we got out easy
599 // check it for real...
603 // the midpoint must be within 16 of the bottom
604 start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
605 start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
606 stop[2] = start[2] - 2*sv_stepheight.value;
607 trace = CL_TraceLine(start, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
609 if (trace.fraction == 1.0)
612 mid = bottom = trace.endpos[2];
614 // the corners must be within 16 of the midpoint
615 for (x=0 ; x<=1 ; x++)
616 for (y=0 ; y<=1 ; y++)
618 start[0] = stop[0] = x ? maxs[0] : mins[0];
619 start[1] = stop[1] = y ? maxs[1] : mins[1];
621 trace = CL_TraceLine(start, stop, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, NULL, true);
623 if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
624 bottom = trace.endpos[2];
625 if (trace.fraction == 1.0 || mid - trace.endpos[2] > sv_stepheight.value)
630 PRVM_G_FLOAT(OFS_RETURN) = true;
633 // #41 float(vector v) pointcontents
634 static void VM_CL_pointcontents (void)
636 VM_SAFEPARMCOUNT(1, VM_CL_pointcontents);
637 PRVM_G_FLOAT(OFS_RETURN) = Mod_Q1BSP_NativeContentsFromSuperContents(NULL, CL_PointSuperContents(PRVM_G_VECTOR(OFS_PARM0)));
640 // #48 void(vector o, vector d, float color, float count) particle
641 static void VM_CL_particle (void)
646 VM_SAFEPARMCOUNT(4, VM_CL_particle);
648 org = PRVM_G_VECTOR(OFS_PARM0);
649 dir = PRVM_G_VECTOR(OFS_PARM1);
650 color = (int)PRVM_G_FLOAT(OFS_PARM2);
651 count = (int)PRVM_G_FLOAT(OFS_PARM3);
652 CL_ParticleEffect(EFFECT_SVC_PARTICLE, count, org, org, dir, dir, NULL, color);
655 // #74 void(vector pos, string samp, float vol, float atten) ambientsound
656 static void VM_CL_ambientsound (void)
660 VM_SAFEPARMCOUNT(4, VM_CL_ambientsound);
661 s = S_FindName(PRVM_G_STRING(OFS_PARM0));
662 f = PRVM_G_VECTOR(OFS_PARM1);
663 S_StaticSound (s, f, PRVM_G_FLOAT(OFS_PARM2), PRVM_G_FLOAT(OFS_PARM3)*64);
666 // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
667 static void VM_CL_getlight (void)
669 vec3_t ambientcolor, diffusecolor, diffusenormal;
672 VM_SAFEPARMCOUNT(1, VM_CL_getlight);
674 p = PRVM_G_VECTOR(OFS_PARM0);
675 VectorClear(ambientcolor);
676 VectorClear(diffusecolor);
677 VectorClear(diffusenormal);
678 if (cl.worldmodel && cl.worldmodel->brush.LightPoint)
679 cl.worldmodel->brush.LightPoint(cl.worldmodel, p, ambientcolor, diffusecolor, diffusenormal);
680 VectorMA(ambientcolor, 0.5, diffusecolor, PRVM_G_VECTOR(OFS_RETURN));
684 //============================================================================
685 //[515]: SCENE MANAGER builtins
686 extern qboolean CSQC_AddRenderEdict (prvm_edict_t *ed, int edictnum);//csprogs.c
688 static void CSQC_R_RecalcView (void)
690 extern matrix4x4_t viewmodelmatrix;
691 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);
692 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);
695 void CL_RelinkLightFlashes(void);
696 //#300 void() clearscene (EXT_CSQC)
697 void VM_CL_R_ClearScene (void)
699 VM_SAFEPARMCOUNT(0, VM_CL_R_ClearScene);
700 // clear renderable entity and light lists
701 r_refdef.scene.numentities = 0;
702 r_refdef.scene.numlights = 0;
703 // FIXME: restore these to the values from VM_CL_UpdateView
707 r_refdef.view.width = vid.width;
708 r_refdef.view.height = vid.height;
709 r_refdef.view.depth = 1;
710 // FIXME: restore frustum_x/frustum_y
711 r_refdef.view.useperspective = true;
712 r_refdef.view.frustum_y = tan(scr_fov.value * M_PI / 360.0) * (3.0/4.0) * cl.viewzoom;
713 r_refdef.view.frustum_x = r_refdef.view.frustum_y * (float)r_refdef.view.width / (float)r_refdef.view.height / vid_pixelheight.value;
714 r_refdef.view.frustum_x *= r_refdef.frustumscale_x;
715 r_refdef.view.frustum_y *= r_refdef.frustumscale_y;
716 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;
717 r_refdef.view.ortho_y = scr_fov.value * (3.0 / 4.0);
718 r_refdef.view.clear = true;
719 r_refdef.view.isoverlay = false;
720 // FIXME: restore cl.csqc_origin
721 // FIXME: restore cl.csqc_angles
722 cl.csqc_vidvars.drawworld = true;
723 cl.csqc_vidvars.drawenginesbar = false;
724 cl.csqc_vidvars.drawcrosshair = false;
727 //#301 void(float mask) addentities (EXT_CSQC)
728 extern void CSQC_Predraw (prvm_edict_t *ed);//csprogs.c
729 extern void CSQC_Think (prvm_edict_t *ed);//csprogs.c
730 void VM_CL_R_AddEntities (void)
732 double t = Sys_DoubleTime();
735 VM_SAFEPARMCOUNT(1, VM_CL_R_AddEntities);
736 drawmask = (int)PRVM_G_FLOAT(OFS_PARM0);
737 CSQC_RelinkAllEntities(drawmask);
738 CL_RelinkLightFlashes();
740 prog->globals.client->time = cl.time;
741 for(i=1;i<prog->num_edicts;i++)
743 ed = &prog->edicts[i];
744 if(ed->priv.required->free)
747 if(ed->priv.required->free)
749 // note that for RF_USEAXIS entities, Predraw sets v_forward/v_right/v_up globals that are read by CSQC_AddRenderEdict
751 if(ed->priv.required->free)
753 if(!((int)ed->fields.client->drawmask & drawmask))
755 CSQC_AddRenderEdict(ed, i);
758 // callprofile fixing hack: do not include this time in what is counted for CSQC_UpdateView
759 prog->functions[prog->funcoffsets.CSQC_UpdateView].totaltime -= Sys_DoubleTime() - t;
762 //#302 void(entity ent) addentity (EXT_CSQC)
763 void VM_CL_R_AddEntity (void)
765 double t = Sys_DoubleTime();
766 VM_SAFEPARMCOUNT(1, VM_CL_R_AddEntity);
767 CSQC_AddRenderEdict(PRVM_G_EDICT(OFS_PARM0), 0);
768 prog->functions[prog->funcoffsets.CSQC_UpdateView].totaltime -= Sys_DoubleTime() - t;
771 //#303 float(float property, ...) setproperty (EXT_CSQC)
772 void VM_CL_R_SetView (void)
778 VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_R_SetView);
780 c = (int)PRVM_G_FLOAT(OFS_PARM0);
781 f = PRVM_G_VECTOR(OFS_PARM1);
782 k = PRVM_G_FLOAT(OFS_PARM1);
787 r_refdef.view.x = (int)(f[0]);
788 r_refdef.view.y = (int)(f[1]);
791 r_refdef.view.x = (int)(k);
794 r_refdef.view.y = (int)(k);
797 r_refdef.view.width = (int)(f[0]);
798 r_refdef.view.height = (int)(f[1]);
801 r_refdef.view.width = (int)(k);
804 r_refdef.view.height = (int)(k);
807 r_refdef.view.x = (int)(f[0]);
808 r_refdef.view.y = (int)(f[1]);
809 f = PRVM_G_VECTOR(OFS_PARM2);
810 r_refdef.view.width = (int)(f[0]);
811 r_refdef.view.height = (int)(f[1]);
814 r_refdef.view.frustum_x = tan(f[0] * M_PI / 360.0);r_refdef.view.ortho_x = f[0];
815 r_refdef.view.frustum_y = tan(f[1] * M_PI / 360.0);r_refdef.view.ortho_y = f[1];
818 r_refdef.view.frustum_x = tan(k * M_PI / 360.0);r_refdef.view.ortho_x = k;
821 r_refdef.view.frustum_y = tan(k * M_PI / 360.0);r_refdef.view.ortho_y = k;
824 VectorCopy(f, cl.csqc_origin);
828 cl.csqc_origin[0] = k;
832 cl.csqc_origin[1] = k;
836 cl.csqc_origin[2] = k;
840 VectorCopy(f, cl.csqc_angles);
844 cl.csqc_angles[0] = k;
848 cl.csqc_angles[1] = k;
852 cl.csqc_angles[2] = k;
856 cl.csqc_vidvars.drawworld = k != 0;
858 case VF_DRAWENGINESBAR:
859 cl.csqc_vidvars.drawenginesbar = k != 0;
861 case VF_DRAWCROSSHAIR:
862 cl.csqc_vidvars.drawcrosshair = k != 0;
864 case VF_CL_VIEWANGLES:
865 VectorCopy(f, cl.viewangles);
867 case VF_CL_VIEWANGLES_X:
868 cl.viewangles[0] = k;
870 case VF_CL_VIEWANGLES_Y:
871 cl.viewangles[1] = k;
873 case VF_CL_VIEWANGLES_Z:
874 cl.viewangles[2] = k;
877 r_refdef.view.useperspective = k != 0;
880 r_refdef.view.isoverlay = !k;
883 PRVM_G_FLOAT(OFS_RETURN) = 0;
884 VM_Warning("VM_CL_R_SetView : unknown parm %i\n", c);
887 PRVM_G_FLOAT(OFS_RETURN) = 1;
890 //#305 void(vector org, float radius, vector lightcolours[, float style, string cubemapname, float pflags]) adddynamiclight (EXT_CSQC)
891 void VM_CL_R_AddDynamicLight (void)
893 double t = Sys_DoubleTime();
898 const char *cubemapname = NULL;
899 int pflags = PFLAGS_CORONA | PFLAGS_FULLDYNAMIC;
900 float coronaintensity = 1;
901 float coronasizescale = 0.25;
902 qboolean castshadow = true;
903 float ambientscale = 0;
904 float diffusescale = 1;
905 float specularscale = 1;
907 vec3_t forward, left, up;
908 VM_SAFEPARMCOUNTRANGE(3, 8, VM_CL_R_AddDynamicLight);
910 // if we've run out of dlights, just return
911 if (r_refdef.scene.numlights >= MAX_DLIGHTS)
914 org = PRVM_G_VECTOR(OFS_PARM0);
915 radius = PRVM_G_FLOAT(OFS_PARM1);
916 col = PRVM_G_VECTOR(OFS_PARM2);
919 style = (int)PRVM_G_FLOAT(OFS_PARM3);
920 if (style >= MAX_LIGHTSTYLES)
922 Con_DPrintf("VM_CL_R_AddDynamicLight: out of bounds lightstyle index %i\n", style);
927 cubemapname = PRVM_G_STRING(OFS_PARM4);
929 pflags = (int)PRVM_G_FLOAT(OFS_PARM5);
930 coronaintensity = (pflags & PFLAGS_CORONA) != 0;
931 castshadow = (pflags & PFLAGS_NOSHADOW) == 0;
933 VectorScale(prog->globals.client->v_forward, radius, forward);
934 VectorScale(prog->globals.client->v_right, -radius, left);
935 VectorScale(prog->globals.client->v_up, radius, up);
936 Matrix4x4_FromVectors(&matrix, forward, left, up, org);
938 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);
939 r_refdef.scene.lights[r_refdef.scene.numlights] = &r_refdef.scene.templights[r_refdef.scene.numlights++];
940 prog->functions[prog->funcoffsets.CSQC_UpdateView].totaltime -= Sys_DoubleTime() - t;
943 //============================================================================
945 //#310 vector (vector v) cs_unproject (EXT_CSQC)
946 static void VM_CL_unproject (void)
951 VM_SAFEPARMCOUNT(1, VM_CL_unproject);
952 f = PRVM_G_VECTOR(OFS_PARM0);
953 if(v_flipped.integer)
954 f[0] = (2 * r_refdef.view.x + r_refdef.view.width) * (vid_conwidth.integer / (float) vid.width) - f[0];
957 (-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,
958 (-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);
959 Matrix4x4_Transform(&r_refdef.view.matrix, temp, PRVM_G_VECTOR(OFS_RETURN));
962 //#311 vector (vector v) cs_project (EXT_CSQC)
963 static void VM_CL_project (void)
969 VM_SAFEPARMCOUNT(1, VM_CL_project);
970 f = PRVM_G_VECTOR(OFS_PARM0);
971 Matrix4x4_Invert_Simple(&m, &r_refdef.view.matrix);
972 Matrix4x4_Transform(&m, f, v);
973 if(v_flipped.integer)
975 VectorSet(PRVM_G_VECTOR(OFS_RETURN),
976 (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)),
977 (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)),
981 //#330 float(float stnum) getstatf (EXT_CSQC)
982 static void VM_CL_getstatf (void)
990 VM_SAFEPARMCOUNT(1, VM_CL_getstatf);
991 i = (int)PRVM_G_FLOAT(OFS_PARM0);
992 if(i < 0 || i >= MAX_CL_STATS)
994 VM_Warning("VM_CL_getstatf: index>=MAX_CL_STATS or index<0\n");
998 PRVM_G_FLOAT(OFS_RETURN) = dat.f;
1001 //#331 float(float stnum) getstati (EXT_CSQC)
1002 static void VM_CL_getstati (void)
1005 int firstbit, bitcount;
1007 VM_SAFEPARMCOUNTRANGE(1, 3, VM_CL_getstati);
1009 index = (int)PRVM_G_FLOAT(OFS_PARM0);
1012 firstbit = (int)PRVM_G_FLOAT(OFS_PARM1);
1014 bitcount = (int)PRVM_G_FLOAT(OFS_PARM2);
1024 if(index < 0 || index >= MAX_CL_STATS)
1026 VM_Warning("VM_CL_getstati: index>=MAX_CL_STATS or index<0\n");
1029 i = cl.stats[index];
1030 if (bitcount != 32) //32 causes the mask to overflow, so there's nothing to subtract from.
1031 i = (((unsigned int)i)&(((1<<bitcount)-1)<<firstbit))>>firstbit;
1032 PRVM_G_FLOAT(OFS_RETURN) = i;
1035 //#332 string(float firststnum) getstats (EXT_CSQC)
1036 static void VM_CL_getstats (void)
1040 VM_SAFEPARMCOUNT(1, VM_CL_getstats);
1041 i = (int)PRVM_G_FLOAT(OFS_PARM0);
1042 if(i < 0 || i > MAX_CL_STATS-4)
1044 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1045 VM_Warning("VM_CL_getstats: index>MAX_CL_STATS-4 or index<0\n");
1048 strlcpy(t, (char*)&cl.stats[i], sizeof(t));
1049 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
1052 //#333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
1053 static void VM_CL_setmodelindex (void)
1057 struct model_s *model;
1059 VM_SAFEPARMCOUNT(2, VM_CL_setmodelindex);
1061 t = PRVM_G_EDICT(OFS_PARM0);
1063 i = (int)PRVM_G_FLOAT(OFS_PARM1);
1065 t->fields.client->model = 0;
1066 t->fields.client->modelindex = 0;
1071 model = CL_GetModelByIndex(i);
1074 VM_Warning("VM_CL_setmodelindex: null model\n");
1077 t->fields.client->model = PRVM_SetEngineString(model->name);
1078 t->fields.client->modelindex = i;
1080 // TODO: check if this breaks needed consistency and maybe add a cvar for it too?? [1/10/2008 Black]
1083 SetMinMaxSize (t, model->normalmins, model->normalmaxs);
1086 SetMinMaxSize (t, vec3_origin, vec3_origin);
1089 //#334 string(float mdlindex) modelnameforindex (EXT_CSQC)
1090 static void VM_CL_modelnameforindex (void)
1094 VM_SAFEPARMCOUNT(1, VM_CL_modelnameforindex);
1096 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1097 model = CL_GetModelByIndex((int)PRVM_G_FLOAT(OFS_PARM0));
1098 PRVM_G_INT(OFS_RETURN) = model ? PRVM_SetEngineString(model->name) : 0;
1101 //#335 float(string effectname) particleeffectnum (EXT_CSQC)
1102 static void VM_CL_particleeffectnum (void)
1105 VM_SAFEPARMCOUNT(1, VM_CL_particleeffectnum);
1106 i = CL_ParticleEffectIndexForName(PRVM_G_STRING(OFS_PARM0));
1109 PRVM_G_FLOAT(OFS_RETURN) = i;
1112 // #336 void(entity ent, float effectnum, vector start, vector end[, float color]) trailparticles (EXT_CSQC)
1113 static void VM_CL_trailparticles (void)
1118 VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_trailparticles);
1120 t = PRVM_G_EDICT(OFS_PARM0);
1121 i = (int)PRVM_G_FLOAT(OFS_PARM1);
1122 start = PRVM_G_VECTOR(OFS_PARM2);
1123 end = PRVM_G_VECTOR(OFS_PARM3);
1127 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);
1130 //#337 void(float effectnum, vector origin, vector dir, float count[, float color]) pointparticles (EXT_CSQC)
1131 static void VM_CL_pointparticles (void)
1135 VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_pointparticles);
1136 i = (int)PRVM_G_FLOAT(OFS_PARM0);
1137 f = PRVM_G_VECTOR(OFS_PARM1);
1138 v = PRVM_G_VECTOR(OFS_PARM2);
1139 n = (int)PRVM_G_FLOAT(OFS_PARM3);
1142 CL_ParticleEffect(i, n, f, f, v, v, NULL, prog->argc >= 5 ? (int)PRVM_G_FLOAT(OFS_PARM4) : 0);
1145 //#342 string(float keynum) getkeybind (EXT_CSQC)
1146 static void VM_CL_getkeybind (void)
1148 VM_SAFEPARMCOUNT(1, VM_CL_getkeybind);
1149 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(Key_GetBind((int)PRVM_G_FLOAT(OFS_PARM0)));
1152 //#343 void(float usecursor) setcursormode (EXT_CSQC)
1153 static void VM_CL_setcursormode (void)
1155 VM_SAFEPARMCOUNT(1, VM_CL_setcursormode);
1156 cl.csqc_wantsmousemove = PRVM_G_FLOAT(OFS_PARM0) != 0;
1157 cl_ignoremousemoves = 2;
1160 //#344 vector() getmousepos (EXT_CSQC)
1161 static void VM_CL_getmousepos(void)
1163 VM_SAFEPARMCOUNT(0,VM_CL_getmousepos);
1165 if (key_consoleactive || key_dest != key_game)
1166 VectorSet(PRVM_G_VECTOR(OFS_RETURN), 0, 0, 0);
1167 else if (cl.csqc_wantsmousemove)
1168 VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_windowmouse_x * vid_conwidth.integer / vid.width, in_windowmouse_y * vid_conheight.integer / vid.height, 0);
1170 VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_mouse_x * vid_conwidth.integer / vid.width, in_mouse_y * vid_conheight.integer / vid.height, 0);
1173 //#345 float(float framenum) getinputstate (EXT_CSQC)
1174 static void VM_CL_getinputstate (void)
1177 VM_SAFEPARMCOUNT(1, VM_CL_getinputstate);
1178 frame = (int)PRVM_G_FLOAT(OFS_PARM0);
1179 PRVM_G_FLOAT(OFS_RETURN) = false;
1180 for (i = 0;i < CL_MAX_USERCMDS;i++)
1182 if (cl.movecmd[i].sequence == frame)
1184 VectorCopy(cl.movecmd[i].viewangles, prog->globals.client->input_angles);
1185 prog->globals.client->input_buttons = cl.movecmd[i].buttons; // FIXME: this should not be directly exposed to csqc (translation layer needed?)
1186 prog->globals.client->input_movevalues[0] = cl.movecmd[i].forwardmove;
1187 prog->globals.client->input_movevalues[1] = cl.movecmd[i].sidemove;
1188 prog->globals.client->input_movevalues[2] = cl.movecmd[i].upmove;
1189 prog->globals.client->input_timelength = cl.movecmd[i].frametime;
1190 if(cl.movecmd[i].crouch)
1192 VectorCopy(cl.playercrouchmins, prog->globals.client->pmove_mins);
1193 VectorCopy(cl.playercrouchmaxs, prog->globals.client->pmove_maxs);
1197 VectorCopy(cl.playerstandmins, prog->globals.client->pmove_mins);
1198 VectorCopy(cl.playerstandmaxs, prog->globals.client->pmove_maxs);
1200 PRVM_G_FLOAT(OFS_RETURN) = true;
1205 //#346 void(float sens) setsensitivityscaler (EXT_CSQC)
1206 static void VM_CL_setsensitivityscale (void)
1208 VM_SAFEPARMCOUNT(1, VM_CL_setsensitivityscale);
1209 cl.sensitivityscale = PRVM_G_FLOAT(OFS_PARM0);
1212 //#347 void() runstandardplayerphysics (EXT_CSQC)
1213 static void VM_CL_runplayerphysics (void)
1217 //#348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
1218 static void VM_CL_getplayerkey (void)
1224 VM_SAFEPARMCOUNT(2, VM_CL_getplayerkey);
1226 i = (int)PRVM_G_FLOAT(OFS_PARM0);
1227 c = PRVM_G_STRING(OFS_PARM1);
1228 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
1232 i = Sbar_GetSortedPlayerIndex(-1-i);
1233 if(i < 0 || i >= cl.maxclients)
1238 if(!strcasecmp(c, "name"))
1239 strlcpy(t, cl.scores[i].name, sizeof(t));
1241 if(!strcasecmp(c, "frags"))
1242 dpsnprintf(t, sizeof(t), "%i", cl.scores[i].frags);
1244 if(!strcasecmp(c, "ping"))
1245 dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_ping);
1247 if(!strcasecmp(c, "pl"))
1248 dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_packetloss);
1250 if(!strcasecmp(c, "movementloss"))
1251 dpsnprintf(t, sizeof(t), "%i", cl.scores[i].qw_movementloss);
1253 if(!strcasecmp(c, "entertime"))
1254 dpsnprintf(t, sizeof(t), "%f", cl.scores[i].qw_entertime);
1256 if(!strcasecmp(c, "colors"))
1257 dpsnprintf(t, sizeof(t), "%i", cl.scores[i].colors);
1259 if(!strcasecmp(c, "topcolor"))
1260 dpsnprintf(t, sizeof(t), "%i", cl.scores[i].colors & 0xf0);
1262 if(!strcasecmp(c, "bottomcolor"))
1263 dpsnprintf(t, sizeof(t), "%i", (cl.scores[i].colors &15)<<4);
1265 if(!strcasecmp(c, "viewentity"))
1266 dpsnprintf(t, sizeof(t), "%i", i+1);
1269 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(t);
1272 //#349 float() isdemo (EXT_CSQC)
1273 static void VM_CL_isdemo (void)
1275 VM_SAFEPARMCOUNT(0, VM_CL_isdemo);
1276 PRVM_G_FLOAT(OFS_RETURN) = cls.demoplayback;
1279 //#351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
1280 static void VM_CL_setlistener (void)
1282 VM_SAFEPARMCOUNT(4, VM_CL_setlistener);
1283 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));
1284 cl.csqc_usecsqclistener = true; //use csqc listener at this frame
1287 //#352 void(string cmdname) registercommand (EXT_CSQC)
1288 static void VM_CL_registercmd (void)
1291 VM_SAFEPARMCOUNT(1, VM_CL_registercmd);
1292 if(!Cmd_Exists(PRVM_G_STRING(OFS_PARM0)))
1296 alloclen = strlen(PRVM_G_STRING(OFS_PARM0)) + 1;
1297 t = (char *)Z_Malloc(alloclen);
1298 memcpy(t, PRVM_G_STRING(OFS_PARM0), alloclen);
1299 Cmd_AddCommand(t, NULL, "console command created by QuakeC");
1302 Cmd_AddCommand(PRVM_G_STRING(OFS_PARM0), NULL, "console command created by QuakeC");
1306 //#360 float() readbyte (EXT_CSQC)
1307 static void VM_CL_ReadByte (void)
1309 VM_SAFEPARMCOUNT(0, VM_CL_ReadByte);
1310 PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadByte();
1313 //#361 float() readchar (EXT_CSQC)
1314 static void VM_CL_ReadChar (void)
1316 VM_SAFEPARMCOUNT(0, VM_CL_ReadChar);
1317 PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadChar();
1320 //#362 float() readshort (EXT_CSQC)
1321 static void VM_CL_ReadShort (void)
1323 VM_SAFEPARMCOUNT(0, VM_CL_ReadShort);
1324 PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadShort();
1327 //#363 float() readlong (EXT_CSQC)
1328 static void VM_CL_ReadLong (void)
1330 VM_SAFEPARMCOUNT(0, VM_CL_ReadLong);
1331 PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadLong();
1334 //#364 float() readcoord (EXT_CSQC)
1335 static void VM_CL_ReadCoord (void)
1337 VM_SAFEPARMCOUNT(0, VM_CL_ReadCoord);
1338 PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadCoord(cls.protocol);
1341 //#365 float() readangle (EXT_CSQC)
1342 static void VM_CL_ReadAngle (void)
1344 VM_SAFEPARMCOUNT(0, VM_CL_ReadAngle);
1345 PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadAngle(cls.protocol);
1348 //#366 string() readstring (EXT_CSQC)
1349 static void VM_CL_ReadString (void)
1351 VM_SAFEPARMCOUNT(0, VM_CL_ReadString);
1352 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(MSG_ReadString());
1355 //#367 float() readfloat (EXT_CSQC)
1356 static void VM_CL_ReadFloat (void)
1358 VM_SAFEPARMCOUNT(0, VM_CL_ReadFloat);
1359 PRVM_G_FLOAT(OFS_RETURN) = MSG_ReadFloat();
1362 //#501 string() readpicture (DP_CSQC_READWRITEPICTURE)
1363 extern cvar_t cl_readpicture_force;
1364 static void VM_CL_ReadPicture (void)
1367 unsigned char *data;
1373 VM_SAFEPARMCOUNT(0, VM_CL_ReadPicture);
1375 name = MSG_ReadString();
1376 size = MSG_ReadShort();
1378 // check if a texture of that name exists
1379 // if yes, it is used and the data is discarded
1380 // if not, the (low quality) data is used to build a new texture, whose name will get returned
1382 pic = Draw_CachePic_Flags (name, CACHEPICFLAG_NOTPERSISTENT);
1386 if(pic->tex == r_texture_notexture)
1387 pic->tex = NULL; // don't overwrite the notexture by Draw_NewPic
1388 if(pic->tex && !cl_readpicture_force.integer)
1390 // texture found and loaded
1391 // skip over the jpeg as we don't need it
1392 for(i = 0; i < size; ++i)
1397 // texture not found
1398 // use the attached jpeg as texture
1399 buf = (unsigned char *) Mem_Alloc(tempmempool, size);
1400 MSG_ReadBytes(size, buf);
1401 data = JPEG_LoadImage_BGRA(buf, size);
1403 Draw_NewPic(name, image_width, image_height, false, data);
1408 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(name);
1411 //////////////////////////////////////////////////////////
1413 static void VM_CL_makestatic (void)
1417 VM_SAFEPARMCOUNT(1, VM_CL_makestatic);
1419 ent = PRVM_G_EDICT(OFS_PARM0);
1420 if (ent == prog->edicts)
1422 VM_Warning("makestatic: can not modify world entity\n");
1425 if (ent->priv.server->free)
1427 VM_Warning("makestatic: can not modify free entity\n");
1431 if (cl.num_static_entities < cl.max_static_entities)
1435 entity_t *staticent = &cl.static_entities[cl.num_static_entities++];
1437 // copy it to the current state
1438 memset(staticent, 0, sizeof(*staticent));
1439 staticent->render.model = CL_GetModelByIndex((int)ent->fields.client->modelindex);
1440 staticent->render.framegroupblend[0].frame = (int)ent->fields.client->frame;
1441 staticent->render.framegroupblend[0].lerp = 1;
1442 // make torchs play out of sync
1443 staticent->render.framegroupblend[0].start = lhrandom(-10, -1);
1444 staticent->render.skinnum = (int)ent->fields.client->skin;
1445 staticent->render.effects = (int)ent->fields.client->effects;
1446 staticent->render.alpha = 1;
1447 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.alpha)) && val->_float) staticent->render.alpha = val->_float;
1448 staticent->render.scale = 1;
1449 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale)) && val->_float) staticent->render.scale = val->_float;
1450 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.colormod)) && VectorLength2(val->vector)) VectorCopy(val->vector, staticent->render.colormod);
1451 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.glowmod)) && VectorLength2(val->vector)) VectorCopy(val->vector, staticent->render.glowmod);
1452 if (!VectorLength2(staticent->render.colormod))
1453 VectorSet(staticent->render.colormod, 1, 1, 1);
1454 if (!VectorLength2(staticent->render.glowmod))
1455 VectorSet(staticent->render.glowmod, 1, 1, 1);
1458 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderflags)) && val->_float) renderflags = (int)val->_float;
1459 if (renderflags & RF_USEAXIS)
1462 VectorNegate(prog->globals.client->v_right, left);
1463 Matrix4x4_FromVectors(&staticent->render.matrix, prog->globals.client->v_forward, left, prog->globals.client->v_up, ent->fields.client->origin);
1464 Matrix4x4_Scale(&staticent->render.matrix, staticent->render.scale, 1);
1467 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);
1469 // either fullbright or lit
1470 if(!r_fullbright.integer)
1472 if (!(staticent->render.effects & EF_FULLBRIGHT))
1473 staticent->render.flags |= RENDER_LIGHT;
1474 else if(r_equalize_entities_fullbright.integer)
1475 staticent->render.flags |= RENDER_LIGHT | RENDER_EQUALIZE;
1477 // turn off shadows from transparent objects
1478 if (!(staticent->render.effects & (EF_NOSHADOW | EF_ADDITIVE | EF_NODEPTHTEST)) && (staticent->render.alpha >= 1))
1479 staticent->render.flags |= RENDER_SHADOW;
1480 if (staticent->render.effects & EF_NODEPTHTEST)
1481 staticent->render.flags |= RENDER_NODEPTHTEST;
1482 if (staticent->render.effects & EF_ADDITIVE)
1483 staticent->render.flags |= RENDER_ADDITIVE;
1484 if (staticent->render.effects & EF_DOUBLESIDED)
1485 staticent->render.flags |= RENDER_DOUBLESIDED;
1487 staticent->render.allowdecals = true;
1488 CL_UpdateRenderEntity(&staticent->render);
1491 Con_Printf("Too many static entities");
1493 // throw the entity away now
1497 //=================================================================//
1503 copies data from one entity to another
1505 copyentity(src, dst)
1508 static void VM_CL_copyentity (void)
1510 prvm_edict_t *in, *out;
1511 VM_SAFEPARMCOUNT(2, VM_CL_copyentity);
1512 in = PRVM_G_EDICT(OFS_PARM0);
1513 if (in == prog->edicts)
1515 VM_Warning("copyentity: can not read world entity\n");
1518 if (in->priv.server->free)
1520 VM_Warning("copyentity: can not read free entity\n");
1523 out = PRVM_G_EDICT(OFS_PARM1);
1524 if (out == prog->edicts)
1526 VM_Warning("copyentity: can not modify world entity\n");
1529 if (out->priv.server->free)
1531 VM_Warning("copyentity: can not modify free entity\n");
1534 memcpy(out->fields.vp, in->fields.vp, prog->progs->entityfields * 4);
1538 //=================================================================//
1540 // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
1541 static void VM_CL_effect (void)
1543 VM_SAFEPARMCOUNT(5, VM_CL_effect);
1544 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));
1547 // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
1548 static void VM_CL_te_blood (void)
1552 VM_SAFEPARMCOUNT(3, VM_CL_te_blood);
1553 if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1555 pos = PRVM_G_VECTOR(OFS_PARM0);
1556 CL_FindNonSolidLocation(pos, pos2, 4);
1557 CL_ParticleEffect(EFFECT_TE_BLOOD, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM1), NULL, 0);
1560 // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
1561 static void VM_CL_te_bloodshower (void)
1565 VM_SAFEPARMCOUNT(4, VM_CL_te_bloodshower);
1566 if (PRVM_G_FLOAT(OFS_PARM3) < 1)
1568 speed = PRVM_G_FLOAT(OFS_PARM2);
1575 CL_ParticleEffect(EFFECT_TE_BLOOD, PRVM_G_FLOAT(OFS_PARM3), PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), vel1, vel2, NULL, 0);
1578 // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
1579 static void VM_CL_te_explosionrgb (void)
1583 matrix4x4_t tempmatrix;
1584 VM_SAFEPARMCOUNT(2, VM_CL_te_explosionrgb);
1585 pos = PRVM_G_VECTOR(OFS_PARM0);
1586 CL_FindNonSolidLocation(pos, pos2, 10);
1587 CL_ParticleExplosion(pos2);
1588 Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1589 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);
1592 // #408 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color, float gravityflag, float randomveljitter) te_particlecube (DP_TE_PARTICLECUBE)
1593 static void VM_CL_te_particlecube (void)
1595 VM_SAFEPARMCOUNT(7, VM_CL_te_particlecube);
1596 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));
1599 // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
1600 static void VM_CL_te_particlerain (void)
1602 VM_SAFEPARMCOUNT(5, VM_CL_te_particlerain);
1603 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);
1606 // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
1607 static void VM_CL_te_particlesnow (void)
1609 VM_SAFEPARMCOUNT(5, VM_CL_te_particlesnow);
1610 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);
1613 // #411 void(vector org, vector vel, float howmany) te_spark
1614 static void VM_CL_te_spark (void)
1618 VM_SAFEPARMCOUNT(3, VM_CL_te_spark);
1620 pos = PRVM_G_VECTOR(OFS_PARM0);
1621 CL_FindNonSolidLocation(pos, pos2, 4);
1622 CL_ParticleEffect(EFFECT_TE_SPARK, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM1), NULL, 0);
1625 extern cvar_t cl_sound_ric_gunshot;
1626 // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
1627 static void VM_CL_te_gunshotquad (void)
1632 VM_SAFEPARMCOUNT(1, VM_CL_te_gunshotquad);
1634 pos = PRVM_G_VECTOR(OFS_PARM0);
1635 CL_FindNonSolidLocation(pos, pos2, 4);
1636 CL_ParticleEffect(EFFECT_TE_GUNSHOTQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1637 if(cl_sound_ric_gunshot.integer >= 2)
1639 if (rand() % 5) S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1643 if (rnd == 1) S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1644 else if (rnd == 2) S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1645 else S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1650 // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
1651 static void VM_CL_te_spikequad (void)
1656 VM_SAFEPARMCOUNT(1, VM_CL_te_spikequad);
1658 pos = PRVM_G_VECTOR(OFS_PARM0);
1659 CL_FindNonSolidLocation(pos, pos2, 4);
1660 CL_ParticleEffect(EFFECT_TE_SPIKEQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1661 if (rand() % 5) S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1665 if (rnd == 1) S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1666 else if (rnd == 2) S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1667 else S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1671 // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
1672 static void VM_CL_te_superspikequad (void)
1677 VM_SAFEPARMCOUNT(1, VM_CL_te_superspikequad);
1679 pos = PRVM_G_VECTOR(OFS_PARM0);
1680 CL_FindNonSolidLocation(pos, pos2, 4);
1681 CL_ParticleEffect(EFFECT_TE_SUPERSPIKEQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1682 if (rand() % 5) S_StartSound(-1, 0, cl.sfx_tink1, pos, 1, 1);
1686 if (rnd == 1) S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1687 else if (rnd == 2) S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1688 else S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1692 // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
1693 static void VM_CL_te_explosionquad (void)
1697 VM_SAFEPARMCOUNT(1, VM_CL_te_explosionquad);
1699 pos = PRVM_G_VECTOR(OFS_PARM0);
1700 CL_FindNonSolidLocation(pos, pos2, 10);
1701 CL_ParticleEffect(EFFECT_TE_EXPLOSIONQUAD, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1702 S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1705 // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
1706 static void VM_CL_te_smallflash (void)
1710 VM_SAFEPARMCOUNT(1, VM_CL_te_smallflash);
1712 pos = PRVM_G_VECTOR(OFS_PARM0);
1713 CL_FindNonSolidLocation(pos, pos2, 10);
1714 CL_ParticleEffect(EFFECT_TE_SMALLFLASH, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1717 // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
1718 static void VM_CL_te_customflash (void)
1722 matrix4x4_t tempmatrix;
1723 VM_SAFEPARMCOUNT(4, VM_CL_te_customflash);
1725 pos = PRVM_G_VECTOR(OFS_PARM0);
1726 CL_FindNonSolidLocation(pos, pos2, 4);
1727 Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1728 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);
1731 // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
1732 static void VM_CL_te_gunshot (void)
1737 VM_SAFEPARMCOUNT(1, VM_CL_te_gunshot);
1739 pos = PRVM_G_VECTOR(OFS_PARM0);
1740 CL_FindNonSolidLocation(pos, pos2, 4);
1741 CL_ParticleEffect(EFFECT_TE_GUNSHOT, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1742 if(cl_sound_ric_gunshot.integer == 1 || cl_sound_ric_gunshot.integer == 3)
1744 if (rand() % 5) S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1748 if (rnd == 1) S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1749 else if (rnd == 2) S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1750 else S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1755 // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
1756 static void VM_CL_te_spike (void)
1761 VM_SAFEPARMCOUNT(1, VM_CL_te_spike);
1763 pos = PRVM_G_VECTOR(OFS_PARM0);
1764 CL_FindNonSolidLocation(pos, pos2, 4);
1765 CL_ParticleEffect(EFFECT_TE_SPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1766 if (rand() % 5) S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1770 if (rnd == 1) S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1771 else if (rnd == 2) S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1772 else S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1776 // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
1777 static void VM_CL_te_superspike (void)
1782 VM_SAFEPARMCOUNT(1, VM_CL_te_superspike);
1784 pos = PRVM_G_VECTOR(OFS_PARM0);
1785 CL_FindNonSolidLocation(pos, pos2, 4);
1786 CL_ParticleEffect(EFFECT_TE_SUPERSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1787 if (rand() % 5) S_StartSound(-1, 0, cl.sfx_tink1, pos2, 1, 1);
1791 if (rnd == 1) S_StartSound(-1, 0, cl.sfx_ric1, pos2, 1, 1);
1792 else if (rnd == 2) S_StartSound(-1, 0, cl.sfx_ric2, pos2, 1, 1);
1793 else S_StartSound(-1, 0, cl.sfx_ric3, pos2, 1, 1);
1797 // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
1798 static void VM_CL_te_explosion (void)
1802 VM_SAFEPARMCOUNT(1, VM_CL_te_explosion);
1804 pos = PRVM_G_VECTOR(OFS_PARM0);
1805 CL_FindNonSolidLocation(pos, pos2, 10);
1806 CL_ParticleEffect(EFFECT_TE_EXPLOSION, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1807 S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1810 // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
1811 static void VM_CL_te_tarexplosion (void)
1815 VM_SAFEPARMCOUNT(1, VM_CL_te_tarexplosion);
1817 pos = PRVM_G_VECTOR(OFS_PARM0);
1818 CL_FindNonSolidLocation(pos, pos2, 10);
1819 CL_ParticleEffect(EFFECT_TE_TAREXPLOSION, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1820 S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1823 // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
1824 static void VM_CL_te_wizspike (void)
1828 VM_SAFEPARMCOUNT(1, VM_CL_te_wizspike);
1830 pos = PRVM_G_VECTOR(OFS_PARM0);
1831 CL_FindNonSolidLocation(pos, pos2, 4);
1832 CL_ParticleEffect(EFFECT_TE_WIZSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1833 S_StartSound(-1, 0, cl.sfx_wizhit, pos2, 1, 1);
1836 // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
1837 static void VM_CL_te_knightspike (void)
1841 VM_SAFEPARMCOUNT(1, VM_CL_te_knightspike);
1843 pos = PRVM_G_VECTOR(OFS_PARM0);
1844 CL_FindNonSolidLocation(pos, pos2, 4);
1845 CL_ParticleEffect(EFFECT_TE_KNIGHTSPIKE, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1846 S_StartSound(-1, 0, cl.sfx_knighthit, pos2, 1, 1);
1849 // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
1850 static void VM_CL_te_lavasplash (void)
1852 VM_SAFEPARMCOUNT(1, VM_CL_te_lavasplash);
1853 CL_ParticleEffect(EFFECT_TE_LAVASPLASH, 1, PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM0), vec3_origin, vec3_origin, NULL, 0);
1856 // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
1857 static void VM_CL_te_teleport (void)
1859 VM_SAFEPARMCOUNT(1, VM_CL_te_teleport);
1860 CL_ParticleEffect(EFFECT_TE_TELEPORT, 1, PRVM_G_VECTOR(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM0), vec3_origin, vec3_origin, NULL, 0);
1863 // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
1864 static void VM_CL_te_explosion2 (void)
1868 matrix4x4_t tempmatrix;
1869 int colorStart, colorLength;
1870 unsigned char *tempcolor;
1871 VM_SAFEPARMCOUNT(3, VM_CL_te_explosion2);
1873 pos = PRVM_G_VECTOR(OFS_PARM0);
1874 colorStart = (int)PRVM_G_FLOAT(OFS_PARM1);
1875 colorLength = (int)PRVM_G_FLOAT(OFS_PARM2);
1876 CL_FindNonSolidLocation(pos, pos2, 10);
1877 CL_ParticleExplosion2(pos2, colorStart, colorLength);
1878 tempcolor = palette_rgb[(rand()%colorLength) + colorStart];
1879 color[0] = tempcolor[0] * (2.0f / 255.0f);
1880 color[1] = tempcolor[1] * (2.0f / 255.0f);
1881 color[2] = tempcolor[2] * (2.0f / 255.0f);
1882 Matrix4x4_CreateTranslate(&tempmatrix, pos2[0], pos2[1], pos2[2]);
1883 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);
1884 S_StartSound(-1, 0, cl.sfx_r_exp3, pos2, 1, 1);
1888 // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
1889 static void VM_CL_te_lightning1 (void)
1891 VM_SAFEPARMCOUNT(3, VM_CL_te_lightning1);
1892 CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt, true);
1895 // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
1896 static void VM_CL_te_lightning2 (void)
1898 VM_SAFEPARMCOUNT(3, VM_CL_te_lightning2);
1899 CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt2, true);
1902 // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
1903 static void VM_CL_te_lightning3 (void)
1905 VM_SAFEPARMCOUNT(3, VM_CL_te_lightning3);
1906 CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_bolt3, false);
1909 // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
1910 static void VM_CL_te_beam (void)
1912 VM_SAFEPARMCOUNT(3, VM_CL_te_beam);
1913 CL_NewBeam(PRVM_G_EDICTNUM(OFS_PARM0), PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM2), cl.model_beam, false);
1916 // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
1917 static void VM_CL_te_plasmaburn (void)
1921 VM_SAFEPARMCOUNT(1, VM_CL_te_plasmaburn);
1923 pos = PRVM_G_VECTOR(OFS_PARM0);
1924 CL_FindNonSolidLocation(pos, pos2, 4);
1925 CL_ParticleEffect(EFFECT_TE_PLASMABURN, 1, pos2, pos2, vec3_origin, vec3_origin, NULL, 0);
1928 // #457 void(vector org, vector velocity, float howmany) te_flamejet (DP_TE_FLAMEJET)
1929 static void VM_CL_te_flamejet (void)
1933 VM_SAFEPARMCOUNT(3, VM_CL_te_flamejet);
1934 if (PRVM_G_FLOAT(OFS_PARM2) < 1)
1936 pos = PRVM_G_VECTOR(OFS_PARM0);
1937 CL_FindNonSolidLocation(pos, pos2, 4);
1938 CL_ParticleEffect(EFFECT_TE_FLAMEJET, PRVM_G_FLOAT(OFS_PARM2), pos2, pos2, PRVM_G_VECTOR(OFS_PARM1), PRVM_G_VECTOR(OFS_PARM1), NULL, 0);
1942 //====================================================================
1945 extern void clippointtosurface(dp_model_t *model, msurface_t *surface, vec3_t p, vec3_t out);
1947 static msurface_t *cl_getsurface(dp_model_t *model, int surfacenum)
1949 if (surfacenum < 0 || surfacenum >= model->nummodelsurfaces)
1951 return model->data_surfaces + surfacenum + model->firstmodelsurface;
1954 // #434 float(entity e, float s) getsurfacenumpoints
1955 static void VM_CL_getsurfacenumpoints(void)
1958 msurface_t *surface;
1959 VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenumpoints);
1960 // return 0 if no such surface
1961 if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1963 PRVM_G_FLOAT(OFS_RETURN) = 0;
1967 // note: this (incorrectly) assumes it is a simple polygon
1968 PRVM_G_FLOAT(OFS_RETURN) = surface->num_vertices;
1971 // #435 vector(entity e, float s, float n) getsurfacepoint
1972 static void VM_CL_getsurfacepoint(void)
1976 msurface_t *surface;
1978 VM_SAFEPARMCOUNT(3, VM_CL_getsurfacenumpoints);
1979 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
1980 ed = PRVM_G_EDICT(OFS_PARM0);
1981 if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
1983 // note: this (incorrectly) assumes it is a simple polygon
1984 pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
1985 if (pointnum < 0 || pointnum >= surface->num_vertices)
1987 // FIXME: implement rotation/scaling
1988 VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
1990 //PF_getsurfacepointattribute, // #486 vector(entity e, float s, float n, float a) getsurfacepointattribute = #486;
1991 // float SPA_POSITION = 0;
1992 // float SPA_S_AXIS = 1;
1993 // float SPA_T_AXIS = 2;
1994 // float SPA_R_AXIS = 3; // same as SPA_NORMAL
1995 // float SPA_TEXCOORDS0 = 4;
1996 // float SPA_LIGHTMAP0_TEXCOORDS = 5;
1997 // float SPA_LIGHTMAP0_COLOR = 6;
1998 // TODO: add some wrapper code and merge VM_CL/SV_getsurface* [12/16/2007 Black]
1999 static void VM_CL_getsurfacepointattribute(void)
2003 msurface_t *surface;
2007 VM_SAFEPARMCOUNT(4, VM_CL_getsurfacenumpoints);
2008 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2009 ed = PRVM_G_EDICT(OFS_PARM0);
2010 if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2012 // note: this (incorrectly) assumes it is a simple polygon
2013 pointnum = (int)PRVM_G_FLOAT(OFS_PARM2);
2014 if (pointnum < 0 || pointnum >= surface->num_vertices)
2017 // FIXME: implement rotation/scaling
2018 attributetype = (int) PRVM_G_FLOAT(OFS_PARM3);
2020 switch( attributetype ) {
2021 // float SPA_POSITION = 0;
2023 VectorAdd(&(model->surfmesh.data_vertex3f + 3 * surface->num_firstvertex)[pointnum * 3], ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
2025 // float SPA_S_AXIS = 1;
2027 VectorCopy(&(model->surfmesh.data_svector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
2029 // float SPA_T_AXIS = 2;
2031 VectorCopy(&(model->surfmesh.data_tvector3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
2033 // float SPA_R_AXIS = 3; // same as SPA_NORMAL
2035 VectorCopy(&(model->surfmesh.data_normal3f + 3 * surface->num_firstvertex)[pointnum * 3], PRVM_G_VECTOR(OFS_RETURN));
2037 // float SPA_TEXCOORDS0 = 4;
2039 float *ret = PRVM_G_VECTOR(OFS_RETURN);
2040 float *texcoord = &(model->surfmesh.data_texcoordtexture2f + 2 * surface->num_firstvertex)[pointnum * 2];
2041 ret[0] = texcoord[0];
2042 ret[1] = texcoord[1];
2046 // float SPA_LIGHTMAP0_TEXCOORDS = 5;
2048 float *ret = PRVM_G_VECTOR(OFS_RETURN);
2049 float *texcoord = &(model->surfmesh.data_texcoordlightmap2f + 2 * surface->num_firstvertex)[pointnum * 2];
2050 ret[0] = texcoord[0];
2051 ret[1] = texcoord[1];
2055 // float SPA_LIGHTMAP0_COLOR = 6;
2057 // ignore alpha for now..
2058 VectorCopy( &(model->surfmesh.data_lightmapcolor4f + 4 * surface->num_firstvertex)[pointnum * 4], PRVM_G_VECTOR(OFS_RETURN));
2061 VectorSet( PRVM_G_VECTOR(OFS_RETURN), 0.0f, 0.0f, 0.0f );
2065 // #436 vector(entity e, float s) getsurfacenormal
2066 static void VM_CL_getsurfacenormal(void)
2069 msurface_t *surface;
2071 VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenormal);
2072 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2073 if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2075 // FIXME: implement rotation/scaling
2076 // note: this (incorrectly) assumes it is a simple polygon
2077 // note: this only returns the first triangle, so it doesn't work very
2078 // well for curved surfaces or arbitrary meshes
2079 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);
2080 VectorNormalize(normal);
2081 VectorCopy(normal, PRVM_G_VECTOR(OFS_RETURN));
2084 // #437 string(entity e, float s) getsurfacetexture
2085 static void VM_CL_getsurfacetexture(void)
2088 msurface_t *surface;
2089 VM_SAFEPARMCOUNT(2, VM_CL_getsurfacetexture);
2090 PRVM_G_INT(OFS_RETURN) = OFS_NULL;
2091 if (!(model = CL_GetModelFromEdict(PRVM_G_EDICT(OFS_PARM0))) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2093 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(surface->texture->name);
2096 // #438 float(entity e, vector p) getsurfacenearpoint
2097 static void VM_CL_getsurfacenearpoint(void)
2099 int surfacenum, best;
2101 vec_t dist, bestdist;
2103 dp_model_t *model = NULL;
2104 msurface_t *surface;
2106 VM_SAFEPARMCOUNT(2, VM_CL_getsurfacenearpoint);
2107 PRVM_G_FLOAT(OFS_RETURN) = -1;
2108 ed = PRVM_G_EDICT(OFS_PARM0);
2109 if(!(model = CL_GetModelFromEdict(ed)) || !model->num_surfaces)
2112 // FIXME: implement rotation/scaling
2113 point = PRVM_G_VECTOR(OFS_PARM1);
2114 VectorSubtract(point, ed->fields.client->origin, p);
2116 bestdist = 1000000000;
2117 for (surfacenum = 0;surfacenum < model->nummodelsurfaces;surfacenum++)
2119 surface = model->data_surfaces + surfacenum + model->firstmodelsurface;
2120 // first see if the nearest point on the surface's box is closer than the previous match
2121 clipped[0] = bound(surface->mins[0], p[0], surface->maxs[0]) - p[0];
2122 clipped[1] = bound(surface->mins[1], p[1], surface->maxs[1]) - p[1];
2123 clipped[2] = bound(surface->mins[2], p[2], surface->maxs[2]) - p[2];
2124 dist = VectorLength2(clipped);
2125 if (dist < bestdist)
2127 // it is, check the nearest point on the actual geometry
2128 clippointtosurface(model, surface, p, clipped);
2129 VectorSubtract(clipped, p, clipped);
2130 dist += VectorLength2(clipped);
2131 if (dist < bestdist)
2133 // that's closer too, store it as the best match
2139 PRVM_G_FLOAT(OFS_RETURN) = best;
2142 // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint
2143 static void VM_CL_getsurfaceclippedpoint(void)
2147 msurface_t *surface;
2149 VM_SAFEPARMCOUNT(3, VM_CL_getsurfaceclippedpoint);
2150 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
2151 ed = PRVM_G_EDICT(OFS_PARM0);
2152 if (!(model = CL_GetModelFromEdict(ed)) || !(surface = cl_getsurface(model, (int)PRVM_G_FLOAT(OFS_PARM1))))
2154 // FIXME: implement rotation/scaling
2155 VectorSubtract(PRVM_G_VECTOR(OFS_PARM2), ed->fields.client->origin, p);
2156 clippointtosurface(model, surface, p, out);
2157 // FIXME: implement rotation/scaling
2158 VectorAdd(out, ed->fields.client->origin, PRVM_G_VECTOR(OFS_RETURN));
2161 // #443 void(entity e, entity tagentity, string tagname) setattachment
2162 void VM_CL_setattachment (void)
2165 prvm_edict_t *tagentity;
2166 const char *tagname;
2170 VM_SAFEPARMCOUNT(3, VM_CL_setattachment);
2172 e = PRVM_G_EDICT(OFS_PARM0);
2173 tagentity = PRVM_G_EDICT(OFS_PARM1);
2174 tagname = PRVM_G_STRING(OFS_PARM2);
2176 if (e == prog->edicts)
2178 VM_Warning("setattachment: can not modify world entity\n");
2181 if (e->priv.server->free)
2183 VM_Warning("setattachment: can not modify free entity\n");
2187 if (tagentity == NULL)
2188 tagentity = prog->edicts;
2190 v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_entity);
2192 v->edict = PRVM_EDICT_TO_PROG(tagentity);
2194 v = PRVM_EDICTFIELDVALUE(e, prog->fieldoffsets.tag_index);
2197 if (tagentity != NULL && tagentity != prog->edicts && tagname && tagname[0])
2199 modelindex = (int)tagentity->fields.client->modelindex;
2200 model = CL_GetModelByIndex(modelindex);
2203 v->_float = Mod_Alias_GetTagIndexForName(model, (int)tagentity->fields.client->skin, tagname);
2205 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);
2208 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));
2212 /////////////////////////////////////////
2213 // DP_MD3_TAGINFO extension coded by VorteX
2215 int CL_GetTagIndex (prvm_edict_t *e, const char *tagname)
2217 dp_model_t *model = CL_GetModelFromEdict(e);
2219 return Mod_Alias_GetTagIndexForName(model, (int)e->fields.client->skin, tagname);
2224 int CL_GetExtendedTagInfo (prvm_edict_t *e, int tagindex, int *parentindex, const char **tagname, matrix4x4_t *tag_localmatrix)
2231 Matrix4x4_CreateIdentity(tag_localmatrix);
2234 && (model = CL_GetModelFromEdict(e))
2235 && model->animscenes)
2237 r = Mod_Alias_GetExtendedTagInfoForIndex(model, (int)e->fields.client->skin, e->priv.server->frameblend, &e->priv.server->skeleton, tagindex - 1, parentindex, tagname, tag_localmatrix);
2248 int CL_GetPitchSign(prvm_edict_t *ent)
2251 if ((model = CL_GetModelFromEdict(ent)) && model->type == mod_alias)
2256 void CL_GetEntityMatrix (prvm_edict_t *ent, matrix4x4_t *out, qboolean viewmatrix)
2260 float pitchsign = 1;
2263 val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.scale);
2264 if (val && val->_float != 0)
2265 scale = val->_float;
2267 // TODO do we need the same weird angle inverting logic here as in the server side case?
2269 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);
2272 pitchsign = CL_GetPitchSign(ent);
2273 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);
2277 int CL_GetEntityLocalTagMatrix(prvm_edict_t *ent, int tagindex, matrix4x4_t *out)
2281 && (model = CL_GetModelFromEdict(ent))
2282 && model->animscenes)
2284 VM_GenerateFrameGroupBlend(ent->priv.server->framegroupblend, ent);
2285 VM_FrameBlendFromFrameGroupBlend(ent->priv.server->frameblend, ent->priv.server->framegroupblend, model);
2286 VM_UpdateEdictSkeleton(ent, model, ent->priv.server->frameblend);
2287 return Mod_Alias_GetTagMatrix(model, ent->priv.server->frameblend, &ent->priv.server->skeleton, tagindex, out);
2289 *out = identitymatrix;
2293 // Warnings/errors code:
2294 // 0 - normal (everything all-right)
2297 // 3 - null or non-precached model
2298 // 4 - no tags with requested index
2299 // 5 - runaway loop at attachment chain
2300 extern cvar_t cl_bob;
2301 extern cvar_t cl_bobcycle;
2302 extern cvar_t cl_bobup;
2303 int CL_GetTagMatrix (matrix4x4_t *out, prvm_edict_t *ent, int tagindex)
2308 matrix4x4_t entitymatrix, tagmatrix, attachmatrix;
2311 *out = identitymatrix; // warnings and errors return identical matrix
2313 if (ent == prog->edicts)
2315 if (ent->priv.server->free)
2318 model = CL_GetModelFromEdict(ent);
2322 tagmatrix = identitymatrix;
2326 if(attachloop >= 256)
2328 // apply transformation by child's tagindex on parent entity and then
2329 // by parent entity itself
2330 ret = CL_GetEntityLocalTagMatrix(ent, tagindex - 1, &attachmatrix);
2331 if(ret && attachloop == 0)
2333 CL_GetEntityMatrix(ent, &entitymatrix, false);
2334 Matrix4x4_Concat(&tagmatrix, &attachmatrix, out);
2335 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2336 // next iteration we process the parent entity
2337 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_entity)) && val->edict)
2339 tagindex = (int)PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.tag_index)->_float;
2340 ent = PRVM_EDICT_NUM(val->edict);
2347 // RENDER_VIEWMODEL magic
2348 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.renderflags)) && (RF_VIEWMODEL & (int)val->_float))
2350 Matrix4x4_Copy(&tagmatrix, out);
2352 CL_GetEntityMatrix(prog->edicts, &entitymatrix, true);
2353 Matrix4x4_Concat(out, &entitymatrix, &tagmatrix);
2356 // Cl_bob, ported from rendering code
2357 if (ent->fields.client->health > 0 && cl_bob.value && cl_bobcycle.value)
2360 // LordHavoc: this code is *weird*, but not replacable (I think it
2361 // should be done in QC on the server, but oh well, quake is quake)
2362 // LordHavoc: figured out bobup: the time at which the sin is at 180
2363 // degrees (which allows lengthening or squishing the peak or valley)
2364 cycle = cl.time/cl_bobcycle.value;
2365 cycle -= (int)cycle;
2366 if (cycle < cl_bobup.value)
2367 cycle = sin(M_PI * cycle / cl_bobup.value);
2369 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
2370 // bob is proportional to velocity in the xy plane
2371 // (don't count Z, or jumping messes it up)
2372 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;
2373 bob = bob*0.3 + bob*0.7*cycle;
2374 Matrix4x4_AdjustOrigin(out, 0, 0, bound(-7, bob, 4));
2381 // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
2382 void VM_CL_gettagindex (void)
2385 const char *tag_name;
2388 VM_SAFEPARMCOUNT(2, VM_CL_gettagindex);
2390 ent = PRVM_G_EDICT(OFS_PARM0);
2391 tag_name = PRVM_G_STRING(OFS_PARM1);
2392 if (ent == prog->edicts)
2394 VM_Warning("VM_CL_gettagindex(entity #%i): can't affect world entity\n", PRVM_NUM_FOR_EDICT(ent));
2397 if (ent->priv.server->free)
2399 VM_Warning("VM_CL_gettagindex(entity #%i): can't affect free entity\n", PRVM_NUM_FOR_EDICT(ent));
2404 if (!CL_GetModelFromEdict(ent))
2405 Con_DPrintf("VM_CL_gettagindex(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(ent));
2408 tag_index = CL_GetTagIndex(ent, tag_name);
2410 Con_Printf("VM_CL_gettagindex(entity #%i): tag \"%s\" not found\n", PRVM_NUM_FOR_EDICT(ent), tag_name);
2412 PRVM_G_FLOAT(OFS_RETURN) = tag_index;
2415 // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
2416 void VM_CL_gettaginfo (void)
2420 matrix4x4_t tag_matrix;
2421 matrix4x4_t tag_localmatrix;
2423 const char *tagname;
2426 vec3_t fo, le, up, trans;
2427 const dp_model_t *model;
2429 VM_SAFEPARMCOUNT(2, VM_CL_gettaginfo);
2431 e = PRVM_G_EDICT(OFS_PARM0);
2432 tagindex = (int)PRVM_G_FLOAT(OFS_PARM1);
2433 returncode = CL_GetTagMatrix(&tag_matrix, e, tagindex);
2434 Matrix4x4_ToVectors(&tag_matrix, prog->globals.client->v_forward, le, prog->globals.client->v_up, PRVM_G_VECTOR(OFS_RETURN));
2435 VectorScale(le, -1, prog->globals.client->v_right);
2436 model = CL_GetModelFromEdict(e);
2437 VM_GenerateFrameGroupBlend(e->priv.server->framegroupblend, e);
2438 VM_FrameBlendFromFrameGroupBlend(e->priv.server->frameblend, e->priv.server->framegroupblend, model);
2439 VM_UpdateEdictSkeleton(e, model, e->priv.server->frameblend);
2440 CL_GetExtendedTagInfo(e, tagindex, &parentindex, &tagname, &tag_localmatrix);
2441 Matrix4x4_ToVectors(&tag_localmatrix, fo, le, up, trans);
2443 if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_parent)))
2444 val->_float = parentindex;
2445 if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_name)))
2446 val->string = tagname ? PRVM_SetTempString(tagname) : 0;
2447 if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_offset)))
2448 VectorCopy(trans, val->vector);
2449 if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_forward)))
2450 VectorCopy(fo, val->vector);
2451 if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_right)))
2452 VectorScale(le, -1, val->vector);
2453 if((val = PRVM_GLOBALFIELDVALUE(prog->globaloffsets.gettaginfo_up)))
2454 VectorCopy(up, val->vector);
2459 VM_Warning("gettagindex: can't affect world entity\n");
2462 VM_Warning("gettagindex: can't affect free entity\n");
2465 Con_DPrintf("CL_GetTagMatrix(entity #%i): null or non-precached model\n", PRVM_NUM_FOR_EDICT(e));
2468 Con_DPrintf("CL_GetTagMatrix(entity #%i): model has no tag with requested index %i\n", PRVM_NUM_FOR_EDICT(e), tagindex);
2471 Con_DPrintf("CL_GetTagMatrix(entity #%i): runaway loop at attachment chain\n", PRVM_NUM_FOR_EDICT(e));
2476 //============================================================================
2478 //====================
2479 // DP_CSQC_SPAWNPARTICLE
2480 // a QC hook to engine's CL_NewParticle
2481 //====================
2483 // particle theme struct
2484 typedef struct vmparticletheme_s
2486 unsigned short typeindex;
2487 qboolean initialized;
2489 porientation_t orientation;
2500 float liquidfriction;
2502 float velocityjitter;
2503 qboolean qualityreduction;
2510 float delaycollision;
2514 typedef struct vmparticlespawner_s
2517 qboolean initialized;
2519 vmparticletheme_t *themes;
2522 float *particle_type;
2523 float *particle_blendmode;
2524 float *particle_orientation;
2525 float *particle_color1;
2526 float *particle_color2;
2527 float *particle_tex;
2528 float *particle_size;
2529 float *particle_sizeincrease;
2530 float *particle_alpha;
2531 float *particle_alphafade;
2532 float *particle_time;
2533 float *particle_gravity;
2534 float *particle_bounce;
2535 float *particle_airfriction;
2536 float *particle_liquidfriction;
2537 float *particle_originjitter;
2538 float *particle_velocityjitter;
2539 float *particle_qualityreduction;
2540 float *particle_stretch;
2541 float *particle_staincolor1;
2542 float *particle_staincolor2;
2543 float *particle_staintex;
2544 float *particle_delayspawn;
2545 float *particle_delaycollision;
2546 }vmparticlespawner_t;
2548 vmparticlespawner_t vmpartspawner;
2550 // TODO: automatic max_themes grow
2551 static void VM_InitParticleSpawner (int maxthemes)
2555 // bound max themes to not be an insane value
2558 if (maxthemes > 2048)
2560 // allocate and set up structure
2561 if (vmpartspawner.initialized) // reallocate
2563 Mem_FreePool(&vmpartspawner.pool);
2564 memset(&vmpartspawner, 0, sizeof(vmparticlespawner_t));
2566 vmpartspawner.pool = Mem_AllocPool("VMPARTICLESPAWNER", 0, NULL);
2567 vmpartspawner.themes = (vmparticletheme_t *)Mem_Alloc(vmpartspawner.pool, sizeof(vmparticletheme_t)*maxthemes);
2568 vmpartspawner.max_themes = maxthemes;
2569 vmpartspawner.initialized = true;
2570 vmpartspawner.verified = true;
2571 // get field addresses for fast querying (we can do 1000 calls of spawnparticle in a frame)
2572 #define getglobal(v,s) val = PRVM_GLOBALFIELDVALUE(PRVM_ED_FindGlobalOffset(s)); if (val) { vmpartspawner.v = &val->_float; } else { VM_Warning("VM_InitParticleSpawner: missing global '%s', spawner cannot work\n", s); vmpartspawner.verified = false; }
2573 #define getglobalvector(v,s) val = PRVM_GLOBALFIELDVALUE(PRVM_ED_FindGlobalOffset(s)); if (val) { vmpartspawner.v = (float *)val->vector; } else { VM_Warning("VM_InitParticleSpawner: missing global '%s', spawner cannot work\n", s); vmpartspawner.verified = false; }
2574 getglobal(particle_type, "particle_type");
2575 getglobal(particle_blendmode, "particle_blendmode");
2576 getglobal(particle_orientation, "particle_orientation");
2577 getglobalvector(particle_color1, "particle_color1");
2578 getglobalvector(particle_color2, "particle_color2");
2579 getglobal(particle_tex, "particle_tex");
2580 getglobal(particle_size, "particle_size");
2581 getglobal(particle_sizeincrease, "particle_sizeincrease");
2582 getglobal(particle_alpha, "particle_alpha");
2583 getglobal(particle_alphafade, "particle_alphafade");
2584 getglobal(particle_time, "particle_time");
2585 getglobal(particle_gravity, "particle_gravity");
2586 getglobal(particle_bounce, "particle_bounce");
2587 getglobal(particle_airfriction, "particle_airfriction");
2588 getglobal(particle_liquidfriction, "particle_liquidfriction");
2589 getglobal(particle_originjitter, "particle_originjitter");
2590 getglobal(particle_velocityjitter, "particle_velocityjitter");
2591 getglobal(particle_qualityreduction, "particle_qualityreduction");
2592 getglobal(particle_stretch, "particle_stretch");
2593 getglobalvector(particle_staincolor1, "particle_staincolor1");
2594 getglobalvector(particle_staincolor2, "particle_staincolor2");
2595 getglobal(particle_staintex, "particle_staintex");
2596 getglobal(particle_delayspawn, "particle_delayspawn");
2597 getglobal(particle_delaycollision, "particle_delaycollision");
2599 #undef getglobalvector
2602 // reset particle theme to default values
2603 static void VM_ResetParticleTheme (vmparticletheme_t *theme)
2605 theme->initialized = true;
2606 theme->typeindex = pt_static;
2607 theme->blendmode = PBLEND_ADD;
2608 theme->orientation = PARTICLE_BILLBOARD;
2609 theme->color1 = 0x808080;
2610 theme->color2 = 0xFFFFFF;
2613 theme->sizeincrease = 0;
2615 theme->alphafade = 512;
2616 theme->gravity = 0.0f;
2617 theme->bounce = 0.0f;
2618 theme->airfriction = 1.0f;
2619 theme->liquidfriction = 4.0f;
2620 theme->originjitter = 0.0f;
2621 theme->velocityjitter = 0.0f;
2622 theme->qualityreduction = false;
2623 theme->lifetime = 4;
2625 theme->staincolor1 = -1;
2626 theme->staincolor2 = -1;
2627 theme->staintex = -1;
2628 theme->delayspawn = 0.0f;
2629 theme->delaycollision = 0.0f;
2632 // particle theme -> QC globals
2633 void VM_CL_ParticleThemeToGlobals(vmparticletheme_t *theme)
2635 *vmpartspawner.particle_type = theme->typeindex;
2636 *vmpartspawner.particle_blendmode = theme->blendmode;
2637 *vmpartspawner.particle_orientation = theme->orientation;
2638 vmpartspawner.particle_color1[0] = (theme->color1 >> 16) & 0xFF; // VorteX: int only can store 0-255, not 0-256 which means 0 - 0,99609375...
2639 vmpartspawner.particle_color1[1] = (theme->color1 >> 8) & 0xFF;
2640 vmpartspawner.particle_color1[2] = (theme->color1 >> 0) & 0xFF;
2641 vmpartspawner.particle_color2[0] = (theme->color2 >> 16) & 0xFF;
2642 vmpartspawner.particle_color2[1] = (theme->color2 >> 8) & 0xFF;
2643 vmpartspawner.particle_color2[2] = (theme->color2 >> 0) & 0xFF;
2644 *vmpartspawner.particle_tex = (float)theme->tex;
2645 *vmpartspawner.particle_size = theme->size;
2646 *vmpartspawner.particle_sizeincrease = theme->sizeincrease;
2647 *vmpartspawner.particle_alpha = (float)theme->alpha/256;
2648 *vmpartspawner.particle_alphafade = (float)theme->alphafade/256;
2649 *vmpartspawner.particle_time = theme->lifetime;
2650 *vmpartspawner.particle_gravity = theme->gravity;
2651 *vmpartspawner.particle_bounce = theme->bounce;
2652 *vmpartspawner.particle_airfriction = theme->airfriction;
2653 *vmpartspawner.particle_liquidfriction = theme->liquidfriction;
2654 *vmpartspawner.particle_originjitter = theme->originjitter;
2655 *vmpartspawner.particle_velocityjitter = theme->velocityjitter;
2656 *vmpartspawner.particle_qualityreduction = theme->qualityreduction;
2657 *vmpartspawner.particle_stretch = theme->stretch;
2658 vmpartspawner.particle_staincolor1[0] = (theme->staincolor1 >> 16) & 0xFF;
2659 vmpartspawner.particle_staincolor1[1] = (theme->staincolor1 >> 8) & 0xFF;
2660 vmpartspawner.particle_staincolor1[2] = (theme->staincolor1 >> 0) & 0xFF;
2661 vmpartspawner.particle_staincolor2[0] = (theme->staincolor2 >> 16) & 0xFF;
2662 vmpartspawner.particle_staincolor2[1] = (theme->staincolor2 >> 8) & 0xFF;
2663 vmpartspawner.particle_staincolor2[2] = (theme->staincolor2 >> 0) & 0xFF;
2664 *vmpartspawner.particle_staintex = (float)theme->staintex;
2665 *vmpartspawner.particle_delayspawn = theme->delayspawn;
2666 *vmpartspawner.particle_delaycollision = theme->delaycollision;
2669 // QC globals -> particle theme
2670 void VM_CL_ParticleThemeFromGlobals(vmparticletheme_t *theme)
2672 theme->typeindex = (unsigned short)*vmpartspawner.particle_type;
2673 theme->blendmode = (pblend_t)*vmpartspawner.particle_blendmode;
2674 theme->orientation = (porientation_t)*vmpartspawner.particle_orientation;
2675 theme->color1 = ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]);
2676 theme->color2 = ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]);
2677 theme->tex = (int)*vmpartspawner.particle_tex;
2678 theme->size = *vmpartspawner.particle_size;
2679 theme->sizeincrease = *vmpartspawner.particle_sizeincrease;
2680 theme->alpha = (int)(*vmpartspawner.particle_alpha*256);
2681 theme->alphafade = (int)(*vmpartspawner.particle_alphafade*256);
2682 theme->lifetime = *vmpartspawner.particle_time;
2683 theme->gravity = *vmpartspawner.particle_gravity;
2684 theme->bounce = *vmpartspawner.particle_bounce;
2685 theme->airfriction = *vmpartspawner.particle_airfriction;
2686 theme->liquidfriction = *vmpartspawner.particle_liquidfriction;
2687 theme->originjitter = *vmpartspawner.particle_originjitter;
2688 theme->velocityjitter = *vmpartspawner.particle_velocityjitter;
2689 theme->qualityreduction = (*vmpartspawner.particle_qualityreduction) ? true : false;
2690 theme->stretch = *vmpartspawner.particle_stretch;
2691 theme->staincolor1 = vmpartspawner.particle_staincolor1[0]*65536 + vmpartspawner.particle_staincolor1[1]*256 + vmpartspawner.particle_staincolor1[2];
2692 theme->staincolor2 = vmpartspawner.particle_staincolor2[0]*65536 + vmpartspawner.particle_staincolor2[1]*256 + vmpartspawner.particle_staincolor2[2];
2693 theme->staintex =(int)*vmpartspawner.particle_staintex;
2694 theme->delayspawn = *vmpartspawner.particle_delayspawn;
2695 theme->delaycollision = *vmpartspawner.particle_delaycollision;
2698 // init particle spawner interface
2699 // # float(float max_themes) initparticlespawner
2700 void VM_CL_InitParticleSpawner (void)
2702 VM_SAFEPARMCOUNTRANGE(0, 1, VM_CL_InitParticleSpawner);
2703 VM_InitParticleSpawner((int)PRVM_G_FLOAT(OFS_PARM0));
2704 vmpartspawner.themes[0].initialized = true;
2705 VM_ResetParticleTheme(&vmpartspawner.themes[0]);
2706 PRVM_G_FLOAT(OFS_RETURN) = (vmpartspawner.verified == true) ? 1 : 0;
2709 // void() resetparticle
2710 void VM_CL_ResetParticle (void)
2712 VM_SAFEPARMCOUNT(0, VM_CL_ResetParticle);
2713 if (vmpartspawner.verified == false)
2715 VM_Warning("VM_CL_ResetParticle: particle spawner not initialized\n");
2718 VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0]);
2721 // void(float themenum) particletheme
2722 void VM_CL_ParticleTheme (void)
2726 VM_SAFEPARMCOUNT(1, VM_CL_ParticleTheme);
2727 if (vmpartspawner.verified == false)
2729 VM_Warning("VM_CL_ParticleTheme: particle spawner not initialized\n");
2732 themenum = (int)PRVM_G_FLOAT(OFS_PARM0);
2733 if (themenum < 0 || themenum >= vmpartspawner.max_themes)
2735 VM_Warning("VM_CL_ParticleTheme: bad theme number %i\n", themenum);
2736 VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0]);
2739 if (vmpartspawner.themes[themenum].initialized == false)
2741 VM_Warning("VM_CL_ParticleTheme: theme #%i not exists\n", themenum);
2742 VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0]);
2745 // load particle theme into globals
2746 VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[themenum]);
2749 // float() saveparticletheme
2750 // void(float themenum) updateparticletheme
2751 void VM_CL_ParticleThemeSave (void)
2755 VM_SAFEPARMCOUNTRANGE(0, 1, VM_CL_ParticleThemeSave);
2756 if (vmpartspawner.verified == false)
2758 VM_Warning("VM_CL_ParticleThemeSave: particle spawner not initialized\n");
2761 // allocate new theme, save it and return
2764 for (themenum = 0; themenum < vmpartspawner.max_themes; themenum++)
2765 if (vmpartspawner.themes[themenum].initialized == false)
2767 if (themenum >= vmpartspawner.max_themes)
2769 if (vmpartspawner.max_themes == 2048)
2770 VM_Warning("VM_CL_ParticleThemeSave: no free theme slots\n");
2772 VM_Warning("VM_CL_ParticleThemeSave: no free theme slots, try initparticlespawner() with highter max_themes\n");
2773 PRVM_G_FLOAT(OFS_RETURN) = -1;
2776 vmpartspawner.themes[themenum].initialized = true;
2777 VM_CL_ParticleThemeFromGlobals(&vmpartspawner.themes[themenum]);
2778 PRVM_G_FLOAT(OFS_RETURN) = themenum;
2781 // update existing theme
2782 themenum = (int)PRVM_G_FLOAT(OFS_PARM0);
2783 if (themenum < 0 || themenum >= vmpartspawner.max_themes)
2785 VM_Warning("VM_CL_ParticleThemeSave: bad theme number %i\n", themenum);
2788 vmpartspawner.themes[themenum].initialized = true;
2789 VM_CL_ParticleThemeFromGlobals(&vmpartspawner.themes[themenum]);
2792 // void(float themenum) freeparticletheme
2793 void VM_CL_ParticleThemeFree (void)
2797 VM_SAFEPARMCOUNT(1, VM_CL_ParticleThemeFree);
2798 if (vmpartspawner.verified == false)
2800 VM_Warning("VM_CL_ParticleThemeFree: particle spawner not initialized\n");
2803 themenum = (int)PRVM_G_FLOAT(OFS_PARM0);
2805 if (themenum <= 0 || themenum >= vmpartspawner.max_themes)
2807 VM_Warning("VM_CL_ParticleThemeFree: bad theme number %i\n", themenum);
2810 if (vmpartspawner.themes[themenum].initialized == false)
2812 VM_Warning("VM_CL_ParticleThemeFree: theme #%i already freed\n", themenum);
2813 VM_CL_ParticleThemeToGlobals(&vmpartspawner.themes[0]);
2817 VM_ResetParticleTheme(&vmpartspawner.themes[themenum]);
2818 vmpartspawner.themes[themenum].initialized = false;
2821 // float(vector org, vector dir, [float theme]) particle
2822 // returns 0 if failed, 1 if succesful
2823 void VM_CL_SpawnParticle (void)
2826 vmparticletheme_t *theme;
2830 VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_SpawnParticle2);
2831 if (vmpartspawner.verified == false)
2833 VM_Warning("VM_CL_SpawnParticle: particle spawner not initialized\n");
2834 PRVM_G_FLOAT(OFS_RETURN) = 0;
2837 org = PRVM_G_VECTOR(OFS_PARM0);
2838 dir = PRVM_G_VECTOR(OFS_PARM1);
2840 if (prog->argc < 3) // global-set particle
2842 part = CL_NewParticle((unsigned short)*vmpartspawner.particle_type, ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, (int)(*vmpartspawner.particle_alpha*256), (int)(*vmpartspawner.particle_alphafade*256), *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)*vmpartspawner.particle_blendmode, (porientation_t)*vmpartspawner.particle_orientation, ((int)vmpartspawner.particle_staincolor1[0] << 16) + ((int)vmpartspawner.particle_staincolor1[1] << 8) + ((int)vmpartspawner.particle_staincolor1[2]), ((int)vmpartspawner.particle_staincolor2[0] << 16) + ((int)vmpartspawner.particle_staincolor2[1] << 8) + ((int)vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex);
2845 PRVM_G_FLOAT(OFS_RETURN) = 0;
2848 if (*vmpartspawner.particle_delayspawn)
2849 part->delayedspawn = cl.time + *vmpartspawner.particle_delayspawn;
2850 if (*vmpartspawner.particle_delaycollision)
2851 part->delayedcollisions = cl.time + *vmpartspawner.particle_delaycollision;
2853 else // quick themed particle
2855 themenum = (int)PRVM_G_FLOAT(OFS_PARM2);
2856 if (themenum <= 0 || themenum >= vmpartspawner.max_themes)
2858 VM_Warning("VM_CL_SpawnParticle: bad theme number %i\n", themenum);
2859 PRVM_G_FLOAT(OFS_RETURN) = 0;
2862 theme = &vmpartspawner.themes[themenum];
2863 part = CL_NewParticle(theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex);
2866 PRVM_G_FLOAT(OFS_RETURN) = 0;
2869 if (theme->delayspawn)
2870 part->delayedspawn = cl.time + theme->delayspawn;
2871 if (theme->delaycollision)
2872 part->delayedcollisions = cl.time + theme->delaycollision;
2874 PRVM_G_FLOAT(OFS_RETURN) = 1;
2877 // float(vector org, vector dir, float spawndelay, float collisiondelay, [float theme]) delayedparticle
2878 // returns 0 if failed, 1 if success
2879 void VM_CL_SpawnParticleDelayed (void)
2882 vmparticletheme_t *theme;
2886 VM_SAFEPARMCOUNTRANGE(4, 5, VM_CL_SpawnParticle2);
2887 if (vmpartspawner.verified == false)
2889 VM_Warning("VM_CL_SpawnParticle: particle spawner not initialized\n");
2890 PRVM_G_FLOAT(OFS_RETURN) = 0;
2893 org = PRVM_G_VECTOR(OFS_PARM0);
2894 dir = PRVM_G_VECTOR(OFS_PARM1);
2895 if (prog->argc < 5) // global-set particle
2896 part = CL_NewParticle((unsigned short)*vmpartspawner.particle_type, ((int)vmpartspawner.particle_color1[0] << 16) + ((int)vmpartspawner.particle_color1[1] << 8) + ((int)vmpartspawner.particle_color1[2]), ((int)vmpartspawner.particle_color2[0] << 16) + ((int)vmpartspawner.particle_color2[1] << 8) + ((int)vmpartspawner.particle_color2[2]), (int)*vmpartspawner.particle_tex, *vmpartspawner.particle_size, *vmpartspawner.particle_sizeincrease, (int)(*vmpartspawner.particle_alpha*256), (int)(*vmpartspawner.particle_alphafade*256), *vmpartspawner.particle_gravity, *vmpartspawner.particle_bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], *vmpartspawner.particle_airfriction, *vmpartspawner.particle_liquidfriction, *vmpartspawner.particle_originjitter, *vmpartspawner.particle_velocityjitter, (*vmpartspawner.particle_qualityreduction) ? true : false, *vmpartspawner.particle_time, *vmpartspawner.particle_stretch, (pblend_t)*vmpartspawner.particle_blendmode, (porientation_t)*vmpartspawner.particle_orientation, ((int)vmpartspawner.particle_staincolor1[0] << 16) + ((int)vmpartspawner.particle_staincolor1[1] << 8) + ((int)vmpartspawner.particle_staincolor1[2]), ((int)vmpartspawner.particle_staincolor2[0] << 16) + ((int)vmpartspawner.particle_staincolor2[1] << 8) + ((int)vmpartspawner.particle_staincolor2[2]), (int)*vmpartspawner.particle_staintex);
2897 else // themed particle
2899 themenum = (int)PRVM_G_FLOAT(OFS_PARM4);
2900 if (themenum <= 0 || themenum >= vmpartspawner.max_themes)
2902 VM_Warning("VM_CL_SpawnParticle: bad theme number %i\n", themenum);
2903 PRVM_G_FLOAT(OFS_RETURN) = 0;
2906 theme = &vmpartspawner.themes[themenum];
2907 part = CL_NewParticle(theme->typeindex, theme->color1, theme->color2, theme->tex, theme->size, theme->sizeincrease, theme->alpha, theme->alphafade, theme->gravity, theme->bounce, org[0], org[1], org[2], dir[0], dir[1], dir[2], theme->airfriction, theme->liquidfriction, theme->originjitter, theme->velocityjitter, theme->qualityreduction, theme->lifetime, theme->stretch, theme->blendmode, theme->orientation, theme->staincolor1, theme->staincolor2, theme->staintex);
2911 PRVM_G_FLOAT(OFS_RETURN) = 0;
2914 part->delayedspawn = cl.time + PRVM_G_FLOAT(OFS_PARM2);
2915 part->delayedcollisions = cl.time + PRVM_G_FLOAT(OFS_PARM3);
2916 PRVM_G_FLOAT(OFS_RETURN) = 0;
2920 //====================
2921 //QC POLYGON functions
2922 //====================
2924 #define VMPOLYGONS_MAXPOINTS 64
2926 typedef struct vmpolygons_triangle_s
2928 rtexture_t *texture;
2930 unsigned short elements[3];
2931 }vmpolygons_triangle_t;
2933 typedef struct vmpolygons_s
2936 qboolean initialized;
2937 double progstarttime;
2941 float *data_vertex3f;
2942 float *data_color4f;
2943 float *data_texcoord2f;
2947 vmpolygons_triangle_t *data_triangles;
2948 unsigned short *data_sortedelement3s;
2950 qboolean begin_active;
2951 rtexture_t *begin_texture;
2954 float begin_vertex[VMPOLYGONS_MAXPOINTS][3];
2955 float begin_color[VMPOLYGONS_MAXPOINTS][4];
2956 float begin_texcoord[VMPOLYGONS_MAXPOINTS][2];
2959 // FIXME: make VM_CL_R_Polygon functions use Debug_Polygon functions?
2960 vmpolygons_t vmpolygons[PRVM_MAXPROGS];
2962 //#304 void() renderscene (EXT_CSQC)
2963 // moved that here to reset the polygons,
2964 // resetting them earlier causes R_Mesh_Draw to be called with numvertices = 0
2966 void VM_CL_R_RenderScene (void)
2968 double t = Sys_DoubleTime();
2969 vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
2970 VM_SAFEPARMCOUNT(0, VM_CL_R_RenderScene);
2972 // we need to update any RENDER_VIEWMODEL entities at this point because
2973 // csqc supplies its own view matrix
2974 CL_UpdateViewEntities();
2978 polys->num_vertices = polys->num_triangles = 0;
2979 polys->progstarttime = prog->starttime;
2981 // callprofile fixing hack: do not include this time in what is counted for CSQC_UpdateView
2982 prog->functions[prog->funcoffsets.CSQC_UpdateView].totaltime -= Sys_DoubleTime() - t;
2985 static void VM_ResizePolygons(vmpolygons_t *polys)
2987 float *oldvertex3f = polys->data_vertex3f;
2988 float *oldcolor4f = polys->data_color4f;
2989 float *oldtexcoord2f = polys->data_texcoord2f;
2990 vmpolygons_triangle_t *oldtriangles = polys->data_triangles;
2991 unsigned short *oldsortedelement3s = polys->data_sortedelement3s;
2992 polys->max_vertices = min(polys->max_triangles*3, 65536);
2993 polys->data_vertex3f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[3]));
2994 polys->data_color4f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[4]));
2995 polys->data_texcoord2f = (float *)Mem_Alloc(polys->pool, polys->max_vertices*sizeof(float[2]));
2996 polys->data_triangles = (vmpolygons_triangle_t *)Mem_Alloc(polys->pool, polys->max_triangles*sizeof(vmpolygons_triangle_t));
2997 polys->data_sortedelement3s = (unsigned short *)Mem_Alloc(polys->pool, polys->max_triangles*sizeof(unsigned short[3]));
2998 if (polys->num_vertices)
3000 memcpy(polys->data_vertex3f, oldvertex3f, polys->num_vertices*sizeof(float[3]));
3001 memcpy(polys->data_color4f, oldcolor4f, polys->num_vertices*sizeof(float[4]));
3002 memcpy(polys->data_texcoord2f, oldtexcoord2f, polys->num_vertices*sizeof(float[2]));
3004 if (polys->num_triangles)
3006 memcpy(polys->data_triangles, oldtriangles, polys->num_triangles*sizeof(vmpolygons_triangle_t));
3007 memcpy(polys->data_sortedelement3s, oldsortedelement3s, polys->num_triangles*sizeof(unsigned short[3]));
3010 Mem_Free(oldvertex3f);
3012 Mem_Free(oldcolor4f);
3014 Mem_Free(oldtexcoord2f);
3016 Mem_Free(oldtriangles);
3017 if (oldsortedelement3s)
3018 Mem_Free(oldsortedelement3s);
3021 static void VM_InitPolygons (vmpolygons_t* polys)
3023 memset(polys, 0, sizeof(*polys));
3024 polys->pool = Mem_AllocPool("VMPOLY", 0, NULL);
3025 polys->max_triangles = 1024;
3026 VM_ResizePolygons(polys);
3027 polys->initialized = true;
3030 static void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
3032 int surfacelistindex;
3033 vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
3034 if(polys->progstarttime != prog->starttime) // from other progs? won't draw these (this can cause crashes!)
3036 R_Mesh_ResetTextureState();
3037 R_Mesh_Matrix(&identitymatrix);
3038 GL_CullFace(GL_NONE);
3039 R_Mesh_VertexPointer(polys->data_vertex3f, 0, 0);
3040 R_Mesh_ColorPointer(polys->data_color4f, 0, 0);
3041 R_Mesh_TexCoordPointer(0, 2, polys->data_texcoord2f, 0, 0);
3042 R_SetupGenericShader(true);
3044 for (surfacelistindex = 0;surfacelistindex < numsurfaces;)
3046 int numtriangles = 0;
3047 rtexture_t *tex = polys->data_triangles[surfacelist[surfacelistindex]].texture;
3048 int drawflag = polys->data_triangles[surfacelist[surfacelistindex]].drawflag;
3049 // this can't call _DrawQ_ProcessDrawFlag, but should be in sync with it
3050 // FIXME factor this out
3051 if(drawflag == DRAWFLAG_ADDITIVE)
3052 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
3053 else if(drawflag == DRAWFLAG_MODULATE)
3054 GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
3055 else if(drawflag == DRAWFLAG_2XMODULATE)
3056 GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR);
3057 else if(drawflag == DRAWFLAG_SCREEN)
3058 GL_BlendFunc(GL_ONE_MINUS_DST_COLOR,GL_ONE);
3060 GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
3061 R_Mesh_TexBind(0, R_GetTexture(tex));
3063 for (;surfacelistindex < numsurfaces;surfacelistindex++)
3065 if (polys->data_triangles[surfacelist[surfacelistindex]].texture != tex || polys->data_triangles[surfacelist[surfacelistindex]].drawflag != drawflag)
3067 VectorCopy(polys->data_triangles[surfacelist[surfacelistindex]].elements, polys->data_sortedelement3s + 3*numtriangles);
3070 R_Mesh_Draw(0, polys->num_vertices, 0, numtriangles, NULL, polys->data_sortedelement3s, 0, 0);
3074 void VMPolygons_Store(vmpolygons_t *polys)
3076 if (r_refdef.draw2dstage)
3078 // draw the polygon as 2D immediately
3079 drawqueuemesh_t mesh;
3080 mesh.texture = polys->begin_texture;
3081 mesh.num_vertices = polys->begin_vertices;
3082 mesh.num_triangles = polys->begin_vertices-2;
3083 mesh.data_element3i = polygonelement3i;
3084 mesh.data_element3s = polygonelement3s;
3085 mesh.data_vertex3f = polys->begin_vertex[0];
3086 mesh.data_color4f = polys->begin_color[0];
3087 mesh.data_texcoord2f = polys->begin_texcoord[0];
3088 DrawQ_Mesh(&mesh, polys->begin_drawflag);
3092 // queue the polygon as 3D for sorted transparent rendering later
3094 if (polys->max_triangles < polys->num_triangles + polys->begin_vertices-2)
3096 polys->max_triangles *= 2;
3097 VM_ResizePolygons(polys);
3099 if (polys->num_vertices + polys->begin_vertices <= polys->max_vertices)
3101 // needle in a haystack!
3102 // polys->num_vertices was used for copying where we actually want to copy begin_vertices
3103 // that also caused it to not render the first polygon that is added
3105 memcpy(polys->data_vertex3f + polys->num_vertices * 3, polys->begin_vertex[0], polys->begin_vertices * sizeof(float[3]));
3106 memcpy(polys->data_color4f + polys->num_vertices * 4, polys->begin_color[0], polys->begin_vertices * sizeof(float[4]));
3107 memcpy(polys->data_texcoord2f + polys->num_vertices * 2, polys->begin_texcoord[0], polys->begin_vertices * sizeof(float[2]));
3108 for (i = 0;i < polys->begin_vertices-2;i++)
3110 polys->data_triangles[polys->num_triangles].texture = polys->begin_texture;
3111 polys->data_triangles[polys->num_triangles].drawflag = polys->begin_drawflag;
3112 polys->data_triangles[polys->num_triangles].elements[0] = polys->num_vertices;
3113 polys->data_triangles[polys->num_triangles].elements[1] = polys->num_vertices + i+1;
3114 polys->data_triangles[polys->num_triangles].elements[2] = polys->num_vertices + i+2;
3115 polys->num_triangles++;
3117 polys->num_vertices += polys->begin_vertices;
3120 polys->begin_active = false;
3123 // TODO: move this into the client code and clean-up everything else, too! [1/6/2008 Black]
3124 // LordHavoc: agreed, this is a mess
3125 void VM_CL_AddPolygonsToMeshQueue (void)
3128 vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
3131 // only add polygons of the currently active prog to the queue - if there is none, we're done
3135 if (!polys->num_triangles)
3138 for (i = 0;i < polys->num_triangles;i++)
3140 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);
3141 R_MeshQueue_AddTransparent(center, VM_DrawPolygonCallback, NULL, i, NULL);
3144 /*polys->num_triangles = 0; // now done after rendering the scene,
3145 polys->num_vertices = 0; // otherwise it's not rendered at all and prints an error message --blub */
3148 //void(string texturename, float flag) R_BeginPolygon
3149 void VM_CL_R_PolygonBegin (void)
3151 const char *picname;
3153 vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
3156 // TODO instead of using skinframes here (which provides the benefit of
3157 // better management of flags, and is more suited for 3D rendering), what
3158 // about supporting Q3 shaders?
3160 VM_SAFEPARMCOUNT(2, VM_CL_R_PolygonBegin);
3162 if (!polys->initialized)
3163 VM_InitPolygons(polys);
3164 if(polys->progstarttime != prog->starttime)
3166 // from another progs? then reset the polys first (fixes crashes on map change, because that can make skinframe textures invalid)
3167 polys->num_vertices = polys->num_triangles = 0;
3168 polys->progstarttime = prog->starttime;
3170 if (polys->begin_active)
3172 VM_Warning("VM_CL_R_PolygonBegin: called twice without VM_CL_R_PolygonBegin after first\n");
3175 picname = PRVM_G_STRING(OFS_PARM0);
3180 tf = TEXF_PRECACHE | TEXF_ALPHA;
3181 if((int)PRVM_G_FLOAT(OFS_PARM1) & DRAWFLAG_MIPMAP)
3186 sf = R_SkinFrame_FindNextByName(sf, picname);
3188 while(sf && sf->textureflags != tf);
3190 if(!sf || !sf->base)
3191 sf = R_SkinFrame_LoadExternal(picname, tf, true);
3194 R_SkinFrame_MarkUsed(sf);
3197 polys->begin_texture = (sf && sf->base) ? sf->base : r_texture_white;
3198 polys->begin_drawflag = (int)PRVM_G_FLOAT(OFS_PARM1) & DRAWFLAG_MASK;
3199 polys->begin_vertices = 0;
3200 polys->begin_active = true;
3203 //void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
3204 void VM_CL_R_PolygonVertex (void)
3206 vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
3208 VM_SAFEPARMCOUNT(4, VM_CL_R_PolygonVertex);
3210 if (!polys->begin_active)
3212 VM_Warning("VM_CL_R_PolygonVertex: VM_CL_R_PolygonBegin wasn't called\n");
3216 if (polys->begin_vertices >= VMPOLYGONS_MAXPOINTS)
3218 VM_Warning("VM_CL_R_PolygonVertex: may have %i vertices max\n", VMPOLYGONS_MAXPOINTS);
3222 polys->begin_vertex[polys->begin_vertices][0] = PRVM_G_VECTOR(OFS_PARM0)[0];
3223 polys->begin_vertex[polys->begin_vertices][1] = PRVM_G_VECTOR(OFS_PARM0)[1];
3224 polys->begin_vertex[polys->begin_vertices][2] = PRVM_G_VECTOR(OFS_PARM0)[2];
3225 polys->begin_texcoord[polys->begin_vertices][0] = PRVM_G_VECTOR(OFS_PARM1)[0];
3226 polys->begin_texcoord[polys->begin_vertices][1] = PRVM_G_VECTOR(OFS_PARM1)[1];
3227 polys->begin_color[polys->begin_vertices][0] = PRVM_G_VECTOR(OFS_PARM2)[0];
3228 polys->begin_color[polys->begin_vertices][1] = PRVM_G_VECTOR(OFS_PARM2)[1];
3229 polys->begin_color[polys->begin_vertices][2] = PRVM_G_VECTOR(OFS_PARM2)[2];
3230 polys->begin_color[polys->begin_vertices][3] = PRVM_G_FLOAT(OFS_PARM3);
3231 polys->begin_vertices++;
3234 //void() R_EndPolygon
3235 void VM_CL_R_PolygonEnd (void)
3237 vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
3239 VM_SAFEPARMCOUNT(0, VM_CL_R_PolygonEnd);
3240 if (!polys->begin_active)
3242 VM_Warning("VM_CL_R_PolygonEnd: VM_CL_R_PolygonBegin wasn't called\n");
3245 polys->begin_active = false;
3246 if (polys->begin_vertices >= 3)
3247 VMPolygons_Store(polys);
3249 VM_Warning("VM_CL_R_PolygonEnd: %i vertices isn't a good choice\n", polys->begin_vertices);
3252 static vmpolygons_t debugPolys;
3254 void Debug_PolygonBegin(const char *picname, int drawflag)
3256 if(!debugPolys.initialized)
3257 VM_InitPolygons(&debugPolys);
3258 if(debugPolys.begin_active)
3260 Con_Printf("Debug_PolygonBegin: called twice without Debug_PolygonEnd after first\n");
3263 debugPolys.begin_texture = picname[0] ? Draw_CachePic (picname)->tex : r_texture_white;
3264 debugPolys.begin_drawflag = drawflag;
3265 debugPolys.begin_vertices = 0;
3266 debugPolys.begin_active = true;
3269 void Debug_PolygonVertex(float x, float y, float z, float s, float t, float r, float g, float b, float a)
3271 if(!debugPolys.begin_active)
3273 Con_Printf("Debug_PolygonVertex: Debug_PolygonBegin wasn't called\n");
3277 if(debugPolys.begin_vertices > VMPOLYGONS_MAXPOINTS)
3279 Con_Printf("Debug_PolygonVertex: may have %i vertices max\n", VMPOLYGONS_MAXPOINTS);
3283 debugPolys.begin_vertex[debugPolys.begin_vertices][0] = x;
3284 debugPolys.begin_vertex[debugPolys.begin_vertices][1] = y;
3285 debugPolys.begin_vertex[debugPolys.begin_vertices][2] = z;
3286 debugPolys.begin_texcoord[debugPolys.begin_vertices][0] = s;
3287 debugPolys.begin_texcoord[debugPolys.begin_vertices][1] = t;
3288 debugPolys.begin_color[debugPolys.begin_vertices][0] = r;
3289 debugPolys.begin_color[debugPolys.begin_vertices][1] = g;
3290 debugPolys.begin_color[debugPolys.begin_vertices][2] = b;
3291 debugPolys.begin_color[debugPolys.begin_vertices][3] = a;
3292 debugPolys.begin_vertices++;
3295 void Debug_PolygonEnd(void)
3297 if (!debugPolys.begin_active)
3299 Con_Printf("Debug_PolygonEnd: Debug_PolygonBegin wasn't called\n");
3302 debugPolys.begin_active = false;
3303 if (debugPolys.begin_vertices >= 3)
3304 VMPolygons_Store(&debugPolys);
3306 Con_Printf("Debug_PolygonEnd: %i vertices isn't a good choice\n", debugPolys.begin_vertices);
3313 Returns false if any part of the bottom of the entity is off an edge that
3318 qboolean CL_CheckBottom (prvm_edict_t *ent)
3320 vec3_t mins, maxs, start, stop;
3325 VectorAdd (ent->fields.client->origin, ent->fields.client->mins, mins);
3326 VectorAdd (ent->fields.client->origin, ent->fields.client->maxs, maxs);
3328 // if all of the points under the corners are solid world, don't bother
3329 // with the tougher checks
3330 // the corners must be within 16 of the midpoint
3331 start[2] = mins[2] - 1;
3332 for (x=0 ; x<=1 ; x++)
3333 for (y=0 ; y<=1 ; y++)
3335 start[0] = x ? maxs[0] : mins[0];
3336 start[1] = y ? maxs[1] : mins[1];
3337 if (!(CL_PointSuperContents(start) & (SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY)))
3341 return true; // we got out easy
3345 // check it for real...
3349 // the midpoint must be within 16 of the bottom
3350 start[0] = stop[0] = (mins[0] + maxs[0])*0.5;
3351 start[1] = stop[1] = (mins[1] + maxs[1])*0.5;
3352 stop[2] = start[2] - 2*sv_stepheight.value;
3353 trace = CL_TraceLine(start, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), true, false, NULL, true);
3355 if (trace.fraction == 1.0)
3357 mid = bottom = trace.endpos[2];
3359 // the corners must be within 16 of the midpoint
3360 for (x=0 ; x<=1 ; x++)
3361 for (y=0 ; y<=1 ; y++)
3363 start[0] = stop[0] = x ? maxs[0] : mins[0];
3364 start[1] = stop[1] = y ? maxs[1] : mins[1];
3366 trace = CL_TraceLine(start, stop, MOVE_NOMONSTERS, ent, CL_GenericHitSuperContentsMask(ent), true, false, NULL, true);
3368 if (trace.fraction != 1.0 && trace.endpos[2] > bottom)
3369 bottom = trace.endpos[2];
3370 if (trace.fraction == 1.0 || mid - trace.endpos[2] > sv_stepheight.value)
3381 Called by monster program code.
3382 The move will be adjusted for slopes and stairs, but if the move isn't
3383 possible, no move is done and false is returned
3386 qboolean CL_movestep (prvm_edict_t *ent, vec3_t move, qboolean relink, qboolean noenemy, qboolean settrace)
3389 vec3_t oldorg, neworg, end, traceendpos;
3392 prvm_edict_t *enemy;
3396 VectorCopy (ent->fields.client->origin, oldorg);
3397 VectorAdd (ent->fields.client->origin, move, neworg);
3399 // flying monsters don't step up
3400 if ( (int)ent->fields.client->flags & (FL_SWIM | FL_FLY) )
3402 // try one move with vertical motion, then one without
3403 for (i=0 ; i<2 ; i++)
3405 VectorAdd (ent->fields.client->origin, move, neworg);
3406 enemy = PRVM_PROG_TO_EDICT(ent->fields.client->enemy);
3407 if (i == 0 && enemy != prog->edicts)
3409 dz = ent->fields.client->origin[2] - PRVM_PROG_TO_EDICT(ent->fields.client->enemy)->fields.client->origin[2];
3415 trace = CL_TraceBox(ent->fields.client->origin, ent->fields.client->mins, ent->fields.client->maxs, neworg, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
3417 CL_VM_SetTraceGlobals(&trace, svent);
3419 if (trace.fraction == 1)
3421 VectorCopy(trace.endpos, traceendpos);
3422 if (((int)ent->fields.client->flags & FL_SWIM) && !(CL_PointSuperContents(traceendpos) & SUPERCONTENTS_LIQUIDSMASK))
3423 return false; // swim monster left water
3425 VectorCopy (traceendpos, ent->fields.client->origin);
3431 if (enemy == prog->edicts)
3438 // push down from a step height above the wished position
3439 neworg[2] += sv_stepheight.value;
3440 VectorCopy (neworg, end);
3441 end[2] -= sv_stepheight.value*2;
3443 trace = CL_TraceBox(neworg, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
3445 CL_VM_SetTraceGlobals(&trace, svent);
3447 if (trace.startsolid)
3449 neworg[2] -= sv_stepheight.value;
3450 trace = CL_TraceBox(neworg, ent->fields.client->mins, ent->fields.client->maxs, end, MOVE_NORMAL, ent, CL_GenericHitSuperContentsMask(ent), true, true, &svent, true);
3452 CL_VM_SetTraceGlobals(&trace, svent);
3453 if (trace.startsolid)
3456 if (trace.fraction == 1)
3458 // if monster had the ground pulled out, go ahead and fall
3459 if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
3461 VectorAdd (ent->fields.client->origin, move, ent->fields.client->origin);
3464 ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_ONGROUND;
3468 return false; // walked off an edge
3471 // check point traces down for dangling corners
3472 VectorCopy (trace.endpos, ent->fields.client->origin);
3474 if (!CL_CheckBottom (ent))
3476 if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
3477 { // entity had floor mostly pulled out from underneath it
3478 // and is trying to correct
3483 VectorCopy (oldorg, ent->fields.client->origin);
3487 if ( (int)ent->fields.client->flags & FL_PARTIALGROUND )
3488 ent->fields.client->flags = (int)ent->fields.client->flags & ~FL_PARTIALGROUND;
3490 if ((val = PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.groundentity)))
3491 val->edict = PRVM_EDICT_TO_PROG(trace.ent);
3503 float(float yaw, float dist[, settrace]) walkmove
3506 static void VM_CL_walkmove (void)
3515 VM_SAFEPARMCOUNTRANGE(2, 3, VM_CL_walkmove);
3517 // assume failure if it returns early
3518 PRVM_G_FLOAT(OFS_RETURN) = 0;
3520 ent = PRVM_PROG_TO_EDICT(prog->globals.client->self);
3521 if (ent == prog->edicts)
3523 VM_Warning("walkmove: can not modify world entity\n");
3526 if (ent->priv.server->free)
3528 VM_Warning("walkmove: can not modify free entity\n");
3531 yaw = PRVM_G_FLOAT(OFS_PARM0);
3532 dist = PRVM_G_FLOAT(OFS_PARM1);
3533 settrace = prog->argc >= 3 && PRVM_G_FLOAT(OFS_PARM2);
3535 if ( !( (int)ent->fields.client->flags & (FL_ONGROUND|FL_FLY|FL_SWIM) ) )
3538 yaw = yaw*M_PI*2 / 360;
3540 move[0] = cos(yaw)*dist;
3541 move[1] = sin(yaw)*dist;
3544 // save program state, because CL_movestep may call other progs
3545 oldf = prog->xfunction;
3546 oldself = prog->globals.client->self;
3548 PRVM_G_FLOAT(OFS_RETURN) = CL_movestep(ent, move, true, false, settrace);
3551 // restore program state
3552 prog->xfunction = oldf;
3553 prog->globals.client->self = oldself;
3560 string(string key) serverkey
3563 void VM_CL_serverkey(void)
3565 char string[VM_STRINGTEMP_LENGTH];
3566 VM_SAFEPARMCOUNT(1, VM_CL_serverkey);
3567 InfoString_GetValue(cl.qw_serverinfo, PRVM_G_STRING(OFS_PARM0), string, sizeof(string));
3568 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
3575 Checks if an entity is in a point's PVS.
3576 Should be fast but can be inexact.
3578 float checkpvs(vector viewpos, entity viewee) = #240;
3581 static void VM_CL_checkpvs (void)
3584 prvm_edict_t *viewee;
3590 unsigned char fatpvs[MAX_MAP_LEAFS/8];
3593 VM_SAFEPARMCOUNT(2, VM_SV_checkpvs);
3594 VectorCopy(PRVM_G_VECTOR(OFS_PARM0), viewpos);
3595 viewee = PRVM_G_EDICT(OFS_PARM1);
3597 if(viewee->priv.required->free)
3599 VM_Warning("checkpvs: can not check free entity\n");
3600 PRVM_G_FLOAT(OFS_RETURN) = 4;
3604 VectorAdd(viewee->fields.server->origin, viewee->fields.server->mins, mi);
3605 VectorAdd(viewee->fields.server->origin, viewee->fields.server->maxs, ma);
3608 if(!sv.worldmodel->brush.GetPVS || !sv.worldmodel->brush.BoxTouchingPVS)
3610 // no PVS support on this worldmodel... darn
3611 PRVM_G_FLOAT(OFS_RETURN) = 3;
3614 pvs = sv.worldmodel->brush.GetPVS(sv.worldmodel, viewpos);
3617 // viewpos isn't in any PVS... darn
3618 PRVM_G_FLOAT(OFS_RETURN) = 2;
3621 PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, pvs, mi, ma);
3623 // using fat PVS like FTEQW does (slow)
3624 if(!sv.worldmodel->brush.FatPVS || !sv.worldmodel->brush.BoxTouchingPVS)
3626 // no PVS support on this worldmodel... darn
3627 PRVM_G_FLOAT(OFS_RETURN) = 3;
3630 fatpvsbytes = sv.worldmodel->brush.FatPVS(sv.worldmodel, viewpos, 8, fatpvs, sizeof(fatpvs), false);
3633 // viewpos isn't in any PVS... darn
3634 PRVM_G_FLOAT(OFS_RETURN) = 2;
3637 PRVM_G_FLOAT(OFS_RETURN) = sv.worldmodel->brush.BoxTouchingPVS(sv.worldmodel, fatpvs, mi, ma);
3641 // #263 float(float modlindex) skel_create = #263; // (FTE_CSQC_SKELETONOBJECTS) create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex.
3642 static void VM_CL_skel_create(void)
3644 int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
3645 dp_model_t *model = CL_GetModelByIndex(modelindex);
3646 skeleton_t *skeleton;
3648 PRVM_G_FLOAT(OFS_RETURN) = 0;
3649 if (!model || !model->num_bones)
3651 for (i = 0;i < MAX_EDICTS;i++)
3652 if (!prog->skeletons[i])
3654 if (i == MAX_EDICTS)
3656 prog->skeletons[i] = skeleton = Mem_Alloc(cls.levelmempool, sizeof(skeleton_t) + model->num_bones * sizeof(matrix4x4_t));
3657 skeleton->model = model;
3658 skeleton->relativetransforms = (matrix4x4_t *)(skeleton+1);
3659 // initialize to identity matrices
3660 for (i = 0;i < skeleton->model->num_bones;i++)
3661 skeleton->relativetransforms[i] = identitymatrix;
3662 PRVM_G_FLOAT(OFS_RETURN) = i + 1;
3665 // #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
3666 static void VM_CL_skel_build(void)
3668 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3669 skeleton_t *skeleton;
3670 prvm_edict_t *ed = PRVM_G_EDICT(OFS_PARM1);
3671 int modelindex = (int)PRVM_G_FLOAT(OFS_PARM2);
3672 float retainfrac = PRVM_G_FLOAT(OFS_PARM3);
3673 int firstbone = PRVM_G_FLOAT(OFS_PARM4);
3674 int lastbone = PRVM_G_FLOAT(OFS_PARM5);
3675 dp_model_t *model = CL_GetModelByIndex(modelindex);
3680 framegroupblend_t framegroupblend[MAX_FRAMEGROUPBLENDS];
3681 frameblend_t frameblend[MAX_FRAMEBLENDS];
3682 matrix4x4_t blendedmatrix;
3684 PRVM_G_FLOAT(OFS_RETURN) = 0;
3685 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3687 firstbone = max(0, firstbone);
3688 lastbone = min(lastbone, model->num_bones - 1);
3689 lastbone = min(lastbone, skeleton->model->num_bones - 1);
3690 VM_GenerateFrameGroupBlend(framegroupblend, ed);
3691 VM_FrameBlendFromFrameGroupBlend(frameblend, framegroupblend, model);
3692 blendfrac = 1.0f - retainfrac;
3693 for (numblends = 0;numblends < MAX_FRAMEBLENDS && frameblend[numblends].lerp;numblends++)
3694 frameblend[numblends].lerp *= blendfrac;
3695 for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
3697 memset(&blendedmatrix, 0, sizeof(blendedmatrix));
3698 Matrix4x4_Accumulate(&blendedmatrix, &skeleton->relativetransforms[bonenum], retainfrac);
3699 for (blendindex = 0;blendindex < numblends;blendindex++)
3701 Matrix4x4_FromArray12FloatD3D(&matrix, model->data_poses + 12 * (frameblend[blendindex].subframe * model->num_bones + bonenum));
3702 Matrix4x4_Accumulate(&blendedmatrix, &matrix, frameblend[blendindex].lerp);
3704 skeleton->relativetransforms[bonenum] = blendedmatrix;
3706 PRVM_G_FLOAT(OFS_RETURN) = skeletonindex;
3709 // #265 float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS) returns how many bones exist in the created skeleton
3710 static void VM_CL_skel_get_numbones(void)
3712 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3713 skeleton_t *skeleton;
3714 PRVM_G_FLOAT(OFS_RETURN) = 0;
3715 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3717 PRVM_G_FLOAT(OFS_RETURN) = skeleton->model->num_bones;
3720 // #266 string(float skel, float bonenum) skel_get_bonename = #266; // (FTE_CSQC_SKELETONOBJECTS) returns name of bone (as a tempstring)
3721 static void VM_CL_skel_get_bonename(void)
3723 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3724 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3725 skeleton_t *skeleton;
3726 PRVM_G_INT(OFS_RETURN) = 0;
3727 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3729 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3731 PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(skeleton->model->data_bones[bonenum].name);
3734 // #267 float(float skel, float bonenum) skel_get_boneparent = #267; // (FTE_CSQC_SKELETONOBJECTS) returns parent num for supplied bonenum, 0 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this)
3735 static void VM_CL_skel_get_boneparent(void)
3737 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3738 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3739 skeleton_t *skeleton;
3740 PRVM_G_FLOAT(OFS_RETURN) = 0;
3741 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3743 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3745 PRVM_G_FLOAT(OFS_RETURN) = skeleton->model->data_bones[bonenum].parent + 1;
3748 // #268 float(float skel, string tagname) skel_find_bone = #268; // (FTE_CSQC_SKELETONOBJECTS) get number of bone with specified name, 0 on failure, tagindex (bonenum+1) on success, same as using gettagindex on the modelindex
3749 static void VM_CL_skel_find_bone(void)
3751 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3752 const char *tagname = PRVM_G_STRING(OFS_PARM1);
3753 skeleton_t *skeleton;
3754 PRVM_G_FLOAT(OFS_RETURN) = 0;
3755 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3757 PRVM_G_FLOAT(OFS_RETURN) = Mod_Alias_GetTagIndexForName(skeleton->model, 0, tagname) + 1;
3760 // #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
3761 static void VM_CL_skel_get_bonerel(void)
3763 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3764 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3765 skeleton_t *skeleton;
3767 vec3_t forward, left, up, origin;
3768 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
3769 VectorClear(prog->globals.client->v_forward);
3770 VectorClear(prog->globals.client->v_right);
3771 VectorClear(prog->globals.client->v_up);
3772 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3774 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3776 matrix = skeleton->relativetransforms[bonenum];
3777 Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
3778 VectorCopy(forward, prog->globals.client->v_forward);
3779 VectorNegate(left, prog->globals.client->v_right);
3780 VectorCopy(up, prog->globals.client->v_up);
3781 VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
3784 // #270 vector(float skel, float bonenum) skel_get_boneabs = #270; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity)
3785 static void VM_CL_skel_get_boneabs(void)
3787 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3788 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3789 skeleton_t *skeleton;
3792 vec3_t forward, left, up, origin;
3793 VectorClear(PRVM_G_VECTOR(OFS_RETURN));
3794 VectorClear(prog->globals.client->v_forward);
3795 VectorClear(prog->globals.client->v_right);
3796 VectorClear(prog->globals.client->v_up);
3797 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3799 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3801 matrix = skeleton->relativetransforms[bonenum];
3802 // convert to absolute
3803 while ((bonenum = skeleton->model->data_bones[bonenum].parent) >= 0)
3806 Matrix4x4_Concat(&matrix, &skeleton->relativetransforms[bonenum], &temp);
3808 Matrix4x4_ToVectors(&matrix, forward, left, up, origin);
3809 VectorCopy(forward, prog->globals.client->v_forward);
3810 VectorNegate(left, prog->globals.client->v_right);
3811 VectorCopy(up, prog->globals.client->v_up);
3812 VectorCopy(origin, PRVM_G_VECTOR(OFS_RETURN));
3815 // #271 void(float skel, float bonenum, vector org) skel_set_bone = #271; // (FTE_CSQC_SKELETONOBJECTS) set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
3816 static void VM_CL_skel_set_bone(void)
3818 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3819 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3820 vec3_t forward, left, up, origin;
3821 skeleton_t *skeleton;
3823 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3825 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3827 VectorCopy(prog->globals.client->v_forward, forward);
3828 VectorNegate(prog->globals.client->v_right, left);
3829 VectorCopy(prog->globals.client->v_up, up);
3830 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
3831 Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
3832 skeleton->relativetransforms[bonenum] = matrix;
3835 // #272 void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
3836 static void VM_CL_skel_mul_bone(void)
3838 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3839 int bonenum = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3840 vec3_t forward, left, up, origin;
3841 skeleton_t *skeleton;
3844 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3846 if (bonenum < 0 || bonenum >= skeleton->model->num_bones)
3848 VectorCopy(PRVM_G_VECTOR(OFS_PARM2), origin);
3849 VectorCopy(prog->globals.client->v_forward, forward);
3850 VectorNegate(prog->globals.client->v_right, left);
3851 VectorCopy(prog->globals.client->v_up, up);
3852 Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
3853 temp = skeleton->relativetransforms[bonenum];
3854 Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
3857 // #273 void(float skel, float startbone, float endbone, vector org) skel_mul_bones = #273; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones)
3858 static void VM_CL_skel_mul_bones(void)
3860 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3861 int firstbone = PRVM_G_FLOAT(OFS_PARM1) - 1;
3862 int lastbone = PRVM_G_FLOAT(OFS_PARM2) - 1;
3864 vec3_t forward, left, up, origin;
3865 skeleton_t *skeleton;
3868 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3870 VectorCopy(PRVM_G_VECTOR(OFS_PARM3), origin);
3871 VectorCopy(prog->globals.client->v_forward, forward);
3872 VectorNegate(prog->globals.client->v_right, left);
3873 VectorCopy(prog->globals.client->v_up, up);
3874 Matrix4x4_FromVectors(&matrix, forward, left, up, origin);
3875 firstbone = max(0, firstbone);
3876 lastbone = min(lastbone, skeleton->model->num_bones - 1);
3877 for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
3879 temp = skeleton->relativetransforms[bonenum];
3880 Matrix4x4_Concat(&skeleton->relativetransforms[bonenum], &matrix, &temp);
3884 // #274 void(float skeldst, float skelsrc, float startbone, float endbone) skel_copybones = #274; // (FTE_CSQC_SKELETONOBJECTS) copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse
3885 static void VM_CL_skel_copybones(void)
3887 int skeletonindexdst = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3888 int skeletonindexsrc = (int)PRVM_G_FLOAT(OFS_PARM1) - 1;
3889 int firstbone = PRVM_G_FLOAT(OFS_PARM2) - 1;
3890 int lastbone = PRVM_G_FLOAT(OFS_PARM3) - 1;
3892 skeleton_t *skeletondst;
3893 skeleton_t *skeletonsrc;
3894 if (skeletonindexdst < 0 || skeletonindexdst >= MAX_EDICTS || !(skeletondst = prog->skeletons[skeletonindexdst]))
3896 if (skeletonindexsrc < 0 || skeletonindexsrc >= MAX_EDICTS || !(skeletonsrc = prog->skeletons[skeletonindexsrc]))
3898 firstbone = max(0, firstbone);
3899 lastbone = min(lastbone, skeletondst->model->num_bones - 1);
3900 lastbone = min(lastbone, skeletonsrc->model->num_bones - 1);
3901 for (bonenum = firstbone;bonenum <= lastbone;bonenum++)
3902 skeletondst->relativetransforms[bonenum] = skeletonsrc->relativetransforms[bonenum];
3905 // #275 void(float skel) skel_delete = #275; // (FTE_CSQC_SKELETONOBJECTS) deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work)
3906 static void VM_CL_skel_delete(void)
3908 int skeletonindex = (int)PRVM_G_FLOAT(OFS_PARM0) - 1;
3909 skeleton_t *skeleton;
3910 if (skeletonindex < 0 || skeletonindex >= MAX_EDICTS || !(skeleton = prog->skeletons[skeletonindex]))
3913 prog->skeletons[skeletonindex] = NULL;
3916 // #276 float(float modlindex, string framename) frameforname = #276; // (FTE_CSQC_SKELETONOBJECTS) finds number of a specified frame in the animation, returns -1 if no match found
3917 static void VM_CL_frameforname(void)
3919 int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
3920 dp_model_t *model = CL_GetModelByIndex(modelindex);
3921 const char *name = PRVM_G_STRING(OFS_PARM1);
3923 PRVM_G_FLOAT(OFS_RETURN) = -1;
3924 if (!model || !model->animscenes)
3926 for (i = 0;i < model->numframes;i++)
3928 if (!strcasecmp(model->animscenes[i].name, name))
3930 PRVM_G_FLOAT(OFS_RETURN) = i;
3936 // #277 float(float modlindex, float framenum) frameduration = #277; // (FTE_CSQC_SKELETONOBJECTS) returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0.
3937 static void VM_CL_frameduration(void)
3939 int modelindex = (int)PRVM_G_FLOAT(OFS_PARM0);
3940 dp_model_t *model = CL_GetModelByIndex(modelindex);
3941 int framenum = (int)PRVM_G_FLOAT(OFS_PARM1);
3942 PRVM_G_FLOAT(OFS_RETURN) = 0;
3943 if (!model || !model->animscenes || framenum < 0 || framenum >= model->numframes)
3945 if (model->animscenes[framenum].framerate)
3946 PRVM_G_FLOAT(OFS_RETURN) = model->animscenes[framenum].framecount / model->animscenes[framenum].framerate;
3949 //============================================================================
3951 // To create a almost working builtin file from this replace:
3952 // "^NULL.*" with ""
3953 // "^{.*//.*}:Wh\(.*\)" with "\1"
3955 // "^.*//:Wh{\#:d*}:Wh{.*}" with "\2 = \1;"
3956 // "\n\n+" with "\n\n"
3958 prvm_builtin_t vm_cl_builtins[] = {
3959 NULL, // #0 NULL function (not callable) (QUAKE)
3960 VM_CL_makevectors, // #1 void(vector ang) makevectors (QUAKE)
3961 VM_CL_setorigin, // #2 void(entity e, vector o) setorigin (QUAKE)
3962 VM_CL_setmodel, // #3 void(entity e, string m) setmodel (QUAKE)
3963 VM_CL_setsize, // #4 void(entity e, vector min, vector max) setsize (QUAKE)
3964 NULL, // #5 void(entity e, vector min, vector max) setabssize (QUAKE)
3965 VM_break, // #6 void() break (QUAKE)
3966 VM_random, // #7 float() random (QUAKE)
3967 VM_CL_sound, // #8 void(entity e, float chan, string samp) sound (QUAKE)
3968 VM_normalize, // #9 vector(vector v) normalize (QUAKE)
3969 VM_error, // #10 void(string e) error (QUAKE)
3970 VM_objerror, // #11 void(string e) objerror (QUAKE)
3971 VM_vlen, // #12 float(vector v) vlen (QUAKE)
3972 VM_vectoyaw, // #13 float(vector v) vectoyaw (QUAKE)
3973 VM_CL_spawn, // #14 entity() spawn (QUAKE)
3974 VM_remove, // #15 void(entity e) remove (QUAKE)
3975 VM_CL_traceline, // #16 void(vector v1, vector v2, float tryents, entity ignoreentity) traceline (QUAKE)
3976 NULL, // #17 entity() checkclient (QUAKE)
3977 VM_find, // #18 entity(entity start, .string fld, string match) find (QUAKE)
3978 VM_precache_sound, // #19 void(string s) precache_sound (QUAKE)
3979 VM_CL_precache_model, // #20 void(string s) precache_model (QUAKE)
3980 NULL, // #21 void(entity client, string s, ...) stuffcmd (QUAKE)
3981 VM_CL_findradius, // #22 entity(vector org, float rad) findradius (QUAKE)
3982 NULL, // #23 void(string s, ...) bprint (QUAKE)
3983 NULL, // #24 void(entity client, string s, ...) sprint (QUAKE)
3984 VM_dprint, // #25 void(string s, ...) dprint (QUAKE)
3985 VM_ftos, // #26 string(float f) ftos (QUAKE)
3986 VM_vtos, // #27 string(vector v) vtos (QUAKE)
3987 VM_coredump, // #28 void() coredump (QUAKE)
3988 VM_traceon, // #29 void() traceon (QUAKE)
3989 VM_traceoff, // #30 void() traceoff (QUAKE)
3990 VM_eprint, // #31 void(entity e) eprint (QUAKE)
3991 VM_CL_walkmove, // #32 float(float yaw, float dist[, float settrace]) walkmove (QUAKE)
3992 NULL, // #33 (QUAKE)
3993 VM_CL_droptofloor, // #34 float() droptofloor (QUAKE)
3994 VM_CL_lightstyle, // #35 void(float style, string value) lightstyle (QUAKE)
3995 VM_rint, // #36 float(float v) rint (QUAKE)
3996 VM_floor, // #37 float(float v) floor (QUAKE)
3997 VM_ceil, // #38 float(float v) ceil (QUAKE)
3998 NULL, // #39 (QUAKE)
3999 VM_CL_checkbottom, // #40 float(entity e) checkbottom (QUAKE)
4000 VM_CL_pointcontents, // #41 float(vector v) pointcontents (QUAKE)
4001 NULL, // #42 (QUAKE)
4002 VM_fabs, // #43 float(float f) fabs (QUAKE)
4003 NULL, // #44 vector(entity e, float speed) aim (QUAKE)
4004 VM_cvar, // #45 float(string s) cvar (QUAKE)
4005 VM_localcmd, // #46 void(string s) localcmd (QUAKE)
4006 VM_nextent, // #47 entity(entity e) nextent (QUAKE)
4007 VM_CL_particle, // #48 void(vector o, vector d, float color, float count) particle (QUAKE)
4008 VM_changeyaw, // #49 void() ChangeYaw (QUAKE)
4009 NULL, // #50 (QUAKE)
4010 VM_vectoangles, // #51 vector(vector v) vectoangles (QUAKE)
4011 NULL, // #52 void(float to, float f) WriteByte (QUAKE)
4012 NULL, // #53 void(float to, float f) WriteChar (QUAKE)
4013 NULL, // #54 void(float to, float f) WriteShort (QUAKE)
4014 NULL, // #55 void(float to, float f) WriteLong (QUAKE)
4015 NULL, // #56 void(float to, float f) WriteCoord (QUAKE)
4016 NULL, // #57 void(float to, float f) WriteAngle (QUAKE)
4017 NULL, // #58 void(float to, string s) WriteString (QUAKE)
4018 NULL, // #59 (QUAKE)
4019 VM_sin, // #60 float(float f) sin (DP_QC_SINCOSSQRTPOW)
4020 VM_cos, // #61 float(float f) cos (DP_QC_SINCOSSQRTPOW)
4021 VM_sqrt, // #62 float(float f) sqrt (DP_QC_SINCOSSQRTPOW)
4022 VM_changepitch, // #63 void(entity ent) changepitch (DP_QC_CHANGEPITCH)
4023 VM_CL_tracetoss, // #64 void(entity e, entity ignore) tracetoss (DP_QC_TRACETOSS)
4024 VM_etos, // #65 string(entity ent) etos (DP_QC_ETOS)
4025 NULL, // #66 (QUAKE)
4026 NULL, // #67 void(float step) movetogoal (QUAKE)
4027 VM_precache_file, // #68 string(string s) precache_file (QUAKE)
4028 VM_CL_makestatic, // #69 void(entity e) makestatic (QUAKE)
4029 NULL, // #70 void(string s) changelevel (QUAKE)
4030 NULL, // #71 (QUAKE)
4031 VM_cvar_set, // #72 void(string var, string val) cvar_set (QUAKE)
4032 NULL, // #73 void(entity client, strings) centerprint (QUAKE)
4033 VM_CL_ambientsound, // #74 void(vector pos, string samp, float vol, float atten) ambientsound (QUAKE)
4034 VM_CL_precache_model, // #75 string(string s) precache_model2 (QUAKE)
4035 VM_precache_sound, // #76 string(string s) precache_sound2 (QUAKE)
4036 VM_precache_file, // #77 string(string s) precache_file2 (QUAKE)
4037 NULL, // #78 void(entity e) setspawnparms (QUAKE)
4038 NULL, // #79 void(entity killer, entity killee) logfrag (QUAKEWORLD)
4039 NULL, // #80 string(entity e, string keyname) infokey (QUAKEWORLD)
4040 VM_stof, // #81 float(string s) stof (FRIK_FILE)
4041 NULL, // #82 void(vector where, float set) multicast (QUAKEWORLD)
4042 NULL, // #83 (QUAKE)
4043 NULL, // #84 (QUAKE)
4044 NULL, // #85 (QUAKE)
4045 NULL, // #86 (QUAKE)
4046 NULL, // #87 (QUAKE)
4047 NULL, // #88 (QUAKE)
4048 NULL, // #89 (QUAKE)
4049 VM_CL_tracebox, // #90 void(vector v1, vector min, vector max, vector v2, float nomonsters, entity forent) tracebox (DP_QC_TRACEBOX)
4050 VM_randomvec, // #91 vector() randomvec (DP_QC_RANDOMVEC)
4051 VM_CL_getlight, // #92 vector(vector org) getlight (DP_QC_GETLIGHT)
4052 VM_registercvar, // #93 float(string name, string value) registercvar (DP_REGISTERCVAR)
4053 VM_min, // #94 float(float a, floats) min (DP_QC_MINMAXBOUND)
4054 VM_max, // #95 float(float a, floats) max (DP_QC_MINMAXBOUND)
4055 VM_bound, // #96 float(float minimum, float val, float maximum) bound (DP_QC_MINMAXBOUND)
4056 VM_pow, // #97 float(float f, float f) pow (DP_QC_SINCOSSQRTPOW)
4057 VM_findfloat, // #98 entity(entity start, .float fld, float match) findfloat (DP_QC_FINDFLOAT)
4058 VM_checkextension, // #99 float(string s) checkextension (the basis of the extension system)
4059 // FrikaC and Telejano range #100-#199
4070 VM_fopen, // #110 float(string filename, float mode) fopen (FRIK_FILE)
4071 VM_fclose, // #111 void(float fhandle) fclose (FRIK_FILE)
4072 VM_fgets, // #112 string(float fhandle) fgets (FRIK_FILE)
4073 VM_fputs, // #113 void(float fhandle, string s) fputs (FRIK_FILE)
4074 VM_strlen, // #114 float(string s) strlen (FRIK_FILE)
4075 VM_strcat, // #115 string(string s1, string s2, ...) strcat (FRIK_FILE)
4076 VM_substring, // #116 string(string s, float start, float length) substring (FRIK_FILE)
4077 VM_stov, // #117 vector(string) stov (FRIK_FILE)
4078 VM_strzone, // #118 string(string s) strzone (FRIK_FILE)
4079 VM_strunzone, // #119 void(string s) strunzone (FRIK_FILE)
4160 // FTEQW range #200-#299
4179 VM_bitshift, // #218 float(float number, float quantity) bitshift (EXT_BITSHIFT)
4182 VM_strstrofs, // #221 float(string str, string sub[, float startpos]) strstrofs (FTE_STRINGS)
4183 VM_str2chr, // #222 float(string str, float ofs) str2chr (FTE_STRINGS)
4184 VM_chr2str, // #223 string(float c, ...) chr2str (FTE_STRINGS)
4185 VM_strconv, // #224 string(float ccase, float calpha, float cnum, string s, ...) strconv (FTE_STRINGS)
4186 VM_strpad, // #225 string(float chars, string s, ...) strpad (FTE_STRINGS)
4187 VM_infoadd, // #226 string(string info, string key, string value, ...) infoadd (FTE_STRINGS)
4188 VM_infoget, // #227 string(string info, string key) infoget (FTE_STRINGS)
4189 VM_strncmp, // #228 float(string s1, string s2, float len) strncmp (FTE_STRINGS)
4190 VM_strncasecmp, // #229 float(string s1, string s2) strcasecmp (FTE_STRINGS)
4191 VM_strncasecmp, // #230 float(string s1, string s2, float len) strncasecmp (FTE_STRINGS)
4193 NULL, // #232 void(float index, float type, .void field) SV_AddStat (EXT_CSQC)
4201 VM_CL_checkpvs, // #240
4224 VM_CL_skel_create, // #263 float(float modlindex) skel_create = #263; // (FTE_CSQC_SKELETONOBJECTS) create a skeleton (be sure to assign this value into .skeletonindex for use), returns skeleton index (1 or higher) on success, returns 0 on failure (for example if the modelindex is not skeletal), it is recommended that you create a new skeleton if you change modelindex.
4225 VM_CL_skel_build, // #264 float(float skel, entity ent, float modlindex, float retainfrac, float firstbone, float lastbone) skel_build = #264; // (FTE_CSQC_SKELETONOBJECTS) blend in a percentage of standard animation, 0 replaces entirely, 1 does nothing, 0.5 blends half, etc, and this only alters the bones in the specified range for which out of bounds values like 0,100000 are safe (uses .frame, .frame2, .frame3, .frame4, .lerpfrac, .lerpfrac3, .lerpfrac4, .frame1time, .frame2time, .frame3time, .frame4time), returns skel on success, 0 on failure
4226 VM_CL_skel_get_numbones, // #265 float(float skel) skel_get_numbones = #265; // (FTE_CSQC_SKELETONOBJECTS) returns how many bones exist in the created skeleton
4227 VM_CL_skel_get_bonename, // #266 string(float skel, float bonenum) skel_get_bonename = #266; // (FTE_CSQC_SKELETONOBJECTS) returns name of bone (as a tempstring)
4228 VM_CL_skel_get_boneparent, // #267 float(float skel, float bonenum) skel_get_boneparent = #267; // (FTE_CSQC_SKELETONOBJECTS) returns parent num for supplied bonenum, -1 if bonenum has no parent or bone does not exist (returned value is always less than bonenum, you can loop on this)
4229 VM_CL_skel_find_bone, // #268 float(float skel, string tagname) skel_find_bone = #268; // (FTE_CSQC_SKELETONOBJECTS) get number of bone with specified name, 0 on failure, tagindex (bonenum+1) on success, same as using gettagindex on the modelindex
4230 VM_CL_skel_get_bonerel, // #269 vector(float skel, float bonenum) skel_get_bonerel = #269; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton relative to its parent - sets v_forward, v_right, v_up, returns origin (relative to parent bone)
4231 VM_CL_skel_get_boneabs, // #270 vector(float skel, float bonenum) skel_get_boneabs = #270; // (FTE_CSQC_SKELETONOBJECTS) get matrix of bone in skeleton in model space - sets v_forward, v_right, v_up, returns origin (relative to entity)
4232 VM_CL_skel_set_bone, // #271 void(float skel, float bonenum, vector org) skel_set_bone = #271; // (FTE_CSQC_SKELETONOBJECTS) set matrix of bone relative to its parent, reads v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
4233 VM_CL_skel_mul_bone, // #272 void(float skel, float bonenum, vector org) skel_mul_bone = #272; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrix (relative to its parent) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bone)
4234 VM_CL_skel_mul_bones, // #273 void(float skel, float startbone, float endbone, vector org) skel_mul_bones = #273; // (FTE_CSQC_SKELETONOBJECTS) transform bone matrices (relative to their parents) by the supplied matrix in v_forward, v_right, v_up, takes origin as parameter (relative to parent bones)
4235 VM_CL_skel_copybones, // #274 void(float skeldst, float skelsrc, float startbone, float endbone) skel_copybones = #274; // (FTE_CSQC_SKELETONOBJECTS) copy bone matrices (relative to their parents) from one skeleton to another, useful for copying a skeleton to a corpse
4236 VM_CL_skel_delete, // #275 void(float skel) skel_delete = #275; // (FTE_CSQC_SKELETONOBJECTS) deletes skeleton at the beginning of the next frame (you can add the entity, delete the skeleton, renderscene, and it will still work)
4237 VM_CL_frameforname, // #276 float(float modlindex, string framename) frameforname = #276; // (FTE_CSQC_SKELETONOBJECTS) finds number of a specified frame in the animation, returns -1 if no match found
4238 VM_CL_frameduration, // #277 float(float modlindex, float framenum) frameduration = #277; // (FTE_CSQC_SKELETONOBJECTS) returns the intended play time (in seconds) of the specified framegroup, if it does not exist the result is 0, if it is a single frame it may be a small value around 0.1 or 0.
4261 // CSQC range #300-#399
4262 VM_CL_R_ClearScene, // #300 void() clearscene (EXT_CSQC)
4263 VM_CL_R_AddEntities, // #301 void(float mask) addentities (EXT_CSQC)
4264 VM_CL_R_AddEntity, // #302 void(entity ent) addentity (EXT_CSQC)
4265 VM_CL_R_SetView, // #303 float(float property, ...) setproperty (EXT_CSQC)
4266 VM_CL_R_RenderScene, // #304 void() renderscene (EXT_CSQC)
4267 VM_CL_R_AddDynamicLight, // #305 void(vector org, float radius, vector lightcolours) adddynamiclight (EXT_CSQC)
4268 VM_CL_R_PolygonBegin, // #306 void(string texturename, float flag[, float is2d, float lines]) R_BeginPolygon
4269 VM_CL_R_PolygonVertex, // #307 void(vector org, vector texcoords, vector rgb, float alpha) R_PolygonVertex
4270 VM_CL_R_PolygonEnd, // #308 void() R_EndPolygon
4271 NULL /* R_LoadWorldModel in menu VM, should stay unassigned in client*/, // #309
4272 VM_CL_unproject, // #310 vector (vector v) cs_unproject (EXT_CSQC)
4273 VM_CL_project, // #311 vector (vector v) cs_project (EXT_CSQC)
4277 VM_drawline, // #315 void(float width, vector pos1, vector pos2, float flag) drawline (EXT_CSQC)
4278 VM_iscachedpic, // #316 float(string name) iscachedpic (EXT_CSQC)
4279 VM_precache_pic, // #317 string(string name, float trywad) precache_pic (EXT_CSQC)
4280 VM_getimagesize, // #318 vector(string picname) draw_getimagesize (EXT_CSQC)
4281 VM_freepic, // #319 void(string name) freepic (EXT_CSQC)
4282 VM_drawcharacter, // #320 float(vector position, float character, vector scale, vector rgb, float alpha, float flag) drawcharacter (EXT_CSQC)
4283 VM_drawstring, // #321 float(vector position, string text, vector scale, vector rgb, float alpha, float flag) drawstring (EXT_CSQC)
4284 VM_drawpic, // #322 float(vector position, string pic, vector size, vector rgb, float alpha, float flag) drawpic (EXT_CSQC)
4285 VM_drawfill, // #323 float(vector position, vector size, vector rgb, float alpha, float flag) drawfill (EXT_CSQC)
4286 VM_drawsetcliparea, // #324 void(float x, float y, float width, float height) drawsetcliparea
4287 VM_drawresetcliparea, // #325 void(void) drawresetcliparea
4288 VM_drawcolorcodedstring, // #326 float drawcolorcodedstring(vector position, string text, vector scale, vector rgb, float alpha, float flag) (EXT_CSQC)
4289 VM_stringwidth, // #327 // FIXME is this okay?
4290 VM_drawsubpic, // #328 // FIXME is this okay?
4291 VM_drawrotpic, // #329 // FIXME is this okay?
4292 VM_CL_getstatf, // #330 float(float stnum) getstatf (EXT_CSQC)
4293 VM_CL_getstati, // #331 float(float stnum) getstati (EXT_CSQC)
4294 VM_CL_getstats, // #332 string(float firststnum) getstats (EXT_CSQC)
4295 VM_CL_setmodelindex, // #333 void(entity e, float mdlindex) setmodelindex (EXT_CSQC)
4296 VM_CL_modelnameforindex, // #334 string(float mdlindex) modelnameforindex (EXT_CSQC)
4297 VM_CL_particleeffectnum, // #335 float(string effectname) particleeffectnum (EXT_CSQC)
4298 VM_CL_trailparticles, // #336 void(entity ent, float effectnum, vector start, vector end) trailparticles (EXT_CSQC)
4299 VM_CL_pointparticles, // #337 void(float effectnum, vector origin [, vector dir, float count]) pointparticles (EXT_CSQC)
4300 VM_centerprint, // #338 void(string s, ...) centerprint (EXT_CSQC)
4301 VM_print, // #339 void(string s, ...) print (EXT_CSQC, DP_SV_PRINT)
4302 VM_keynumtostring, // #340 string(float keynum) keynumtostring (EXT_CSQC)
4303 VM_stringtokeynum, // #341 float(string keyname) stringtokeynum (EXT_CSQC)
4304 VM_CL_getkeybind, // #342 string(float keynum) getkeybind (EXT_CSQC)
4305 VM_CL_setcursormode, // #343 void(float usecursor) setcursormode (EXT_CSQC)
4306 VM_CL_getmousepos, // #344 vector() getmousepos (EXT_CSQC)
4307 VM_CL_getinputstate, // #345 float(float framenum) getinputstate (EXT_CSQC)
4308 VM_CL_setsensitivityscale, // #346 void(float sens) setsensitivityscale (EXT_CSQC)
4309 VM_CL_runplayerphysics, // #347 void() runstandardplayerphysics (EXT_CSQC)
4310 VM_CL_getplayerkey, // #348 string(float playernum, string keyname) getplayerkeyvalue (EXT_CSQC)
4311 VM_CL_isdemo, // #349 float() isdemo (EXT_CSQC)
4312 VM_isserver, // #350 float() isserver (EXT_CSQC)
4313 VM_CL_setlistener, // #351 void(vector origin, vector forward, vector right, vector up) SetListener (EXT_CSQC)
4314 VM_CL_registercmd, // #352 void(string cmdname) registercommand (EXT_CSQC)
4315 VM_wasfreed, // #353 float(entity ent) wasfreed (EXT_CSQC) (should be availabe on server too)
4316 VM_CL_serverkey, // #354 string(string key) serverkey (EXT_CSQC)
4322 VM_CL_ReadByte, // #360 float() readbyte (EXT_CSQC)
4323 VM_CL_ReadChar, // #361 float() readchar (EXT_CSQC)
4324 VM_CL_ReadShort, // #362 float() readshort (EXT_CSQC)
4325 VM_CL_ReadLong, // #363 float() readlong (EXT_CSQC)
4326 VM_CL_ReadCoord, // #364 float() readcoord (EXT_CSQC)
4327 VM_CL_ReadAngle, // #365 float() readangle (EXT_CSQC)
4328 VM_CL_ReadString, // #366 string() readstring (EXT_CSQC)
4329 VM_CL_ReadFloat, // #367 float() readfloat (EXT_CSQC)
4362 // LordHavoc's range #400-#499
4363 VM_CL_copyentity, // #400 void(entity from, entity to) copyentity (DP_QC_COPYENTITY)
4364 NULL, // #401 void(entity ent, float colors) setcolor (DP_QC_SETCOLOR)
4365 VM_findchain, // #402 entity(.string fld, string match) findchain (DP_QC_FINDCHAIN)
4366 VM_findchainfloat, // #403 entity(.float fld, float match) findchainfloat (DP_QC_FINDCHAINFLOAT)
4367 VM_CL_effect, // #404 void(vector org, string modelname, float startframe, float endframe, float framerate) effect (DP_SV_EFFECT)
4368 VM_CL_te_blood, // #405 void(vector org, vector velocity, float howmany) te_blood (DP_TE_BLOOD)
4369 VM_CL_te_bloodshower, // #406 void(vector mincorner, vector maxcorner, float explosionspeed, float howmany) te_bloodshower (DP_TE_BLOODSHOWER)
4370 VM_CL_te_explosionrgb, // #407 void(vector org, vector color) te_explosionrgb (DP_TE_EXPLOSIONRGB)
4371 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)
4372 VM_CL_te_particlerain, // #409 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlerain (DP_TE_PARTICLERAIN)
4373 VM_CL_te_particlesnow, // #410 void(vector mincorner, vector maxcorner, vector vel, float howmany, float color) te_particlesnow (DP_TE_PARTICLESNOW)
4374 VM_CL_te_spark, // #411 void(vector org, vector vel, float howmany) te_spark (DP_TE_SPARK)
4375 VM_CL_te_gunshotquad, // #412 void(vector org) te_gunshotquad (DP_QUADEFFECTS1)
4376 VM_CL_te_spikequad, // #413 void(vector org) te_spikequad (DP_QUADEFFECTS1)
4377 VM_CL_te_superspikequad, // #414 void(vector org) te_superspikequad (DP_QUADEFFECTS1)
4378 VM_CL_te_explosionquad, // #415 void(vector org) te_explosionquad (DP_QUADEFFECTS1)
4379 VM_CL_te_smallflash, // #416 void(vector org) te_smallflash (DP_TE_SMALLFLASH)
4380 VM_CL_te_customflash, // #417 void(vector org, float radius, float lifetime, vector color) te_customflash (DP_TE_CUSTOMFLASH)
4381 VM_CL_te_gunshot, // #418 void(vector org) te_gunshot (DP_TE_STANDARDEFFECTBUILTINS)
4382 VM_CL_te_spike, // #419 void(vector org) te_spike (DP_TE_STANDARDEFFECTBUILTINS)
4383 VM_CL_te_superspike, // #420 void(vector org) te_superspike (DP_TE_STANDARDEFFECTBUILTINS)
4384 VM_CL_te_explosion, // #421 void(vector org) te_explosion (DP_TE_STANDARDEFFECTBUILTINS)
4385 VM_CL_te_tarexplosion, // #422 void(vector org) te_tarexplosion (DP_TE_STANDARDEFFECTBUILTINS)
4386 VM_CL_te_wizspike, // #423 void(vector org) te_wizspike (DP_TE_STANDARDEFFECTBUILTINS)
4387 VM_CL_te_knightspike, // #424 void(vector org) te_knightspike (DP_TE_STANDARDEFFECTBUILTINS)
4388 VM_CL_te_lavasplash, // #425 void(vector org) te_lavasplash (DP_TE_STANDARDEFFECTBUILTINS)
4389 VM_CL_te_teleport, // #426 void(vector org) te_teleport (DP_TE_STANDARDEFFECTBUILTINS)
4390 VM_CL_te_explosion2, // #427 void(vector org, float colorstart, float colorlength) te_explosion2 (DP_TE_STANDARDEFFECTBUILTINS)
4391 VM_CL_te_lightning1, // #428 void(entity own, vector start, vector end) te_lightning1 (DP_TE_STANDARDEFFECTBUILTINS)
4392 VM_CL_te_lightning2, // #429 void(entity own, vector start, vector end) te_lightning2 (DP_TE_STANDARDEFFECTBUILTINS)
4393 VM_CL_te_lightning3, // #430 void(entity own, vector start, vector end) te_lightning3 (DP_TE_STANDARDEFFECTBUILTINS)
4394 VM_CL_te_beam, // #431 void(entity own, vector start, vector end) te_beam (DP_TE_STANDARDEFFECTBUILTINS)
4395 VM_vectorvectors, // #432 void(vector dir) vectorvectors (DP_QC_VECTORVECTORS)
4396 VM_CL_te_plasmaburn, // #433 void(vector org) te_plasmaburn (DP_TE_PLASMABURN)
4397 VM_CL_getsurfacenumpoints, // #434 float(entity e, float s) getsurfacenumpoints (DP_QC_GETSURFACE)
4398 VM_CL_getsurfacepoint, // #435 vector(entity e, float s, float n) getsurfacepoint (DP_QC_GETSURFACE)
4399 VM_CL_getsurfacenormal, // #436 vector(entity e, float s) getsurfacenormal (DP_QC_GETSURFACE)
4400 VM_CL_getsurfacetexture, // #437 string(entity e, float s) getsurfacetexture (DP_QC_GETSURFACE)
4401 VM_CL_getsurfacenearpoint, // #438 float(entity e, vector p) getsurfacenearpoint (DP_QC_GETSURFACE)
4402 VM_CL_getsurfaceclippedpoint, // #439 vector(entity e, float s, vector p) getsurfaceclippedpoint (DP_QC_GETSURFACE)
4403 NULL, // #440 void(entity e, string s) clientcommand (KRIMZON_SV_PARSECLIENTCOMMAND)
4404 VM_tokenize, // #441 float(string s) tokenize (KRIMZON_SV_PARSECLIENTCOMMAND)
4405 VM_argv, // #442 string(float n) argv (KRIMZON_SV_PARSECLIENTCOMMAND)
4406 VM_CL_setattachment, // #443 void(entity e, entity tagentity, string tagname) setattachment (DP_GFX_QUAKE3MODELTAGS)
4407 VM_search_begin, // #444 float(string pattern, float caseinsensitive, float quiet) search_begin (DP_QC_FS_SEARCH)
4408 VM_search_end, // #445 void(float handle) search_end (DP_QC_FS_SEARCH)
4409 VM_search_getsize, // #446 float(float handle) search_getsize (DP_QC_FS_SEARCH)
4410 VM_search_getfilename, // #447 string(float handle, float num) search_getfilename (DP_QC_FS_SEARCH)
4411 VM_cvar_string, // #448 string(string s) cvar_string (DP_QC_CVAR_STRING)
4412 VM_findflags, // #449 entity(entity start, .float fld, float match) findflags (DP_QC_FINDFLAGS)
4413 VM_findchainflags, // #450 entity(.float fld, float match) findchainflags (DP_QC_FINDCHAINFLAGS)
4414 VM_CL_gettagindex, // #451 float(entity ent, string tagname) gettagindex (DP_QC_GETTAGINFO)
4415 VM_CL_gettaginfo, // #452 vector(entity ent, float tagindex) gettaginfo (DP_QC_GETTAGINFO)
4416 NULL, // #453 void(entity clent) dropclient (DP_SV_DROPCLIENT)
4417 NULL, // #454 entity() spawnclient (DP_SV_BOTCLIENT)
4418 NULL, // #455 float(entity clent) clienttype (DP_SV_BOTCLIENT)
4419 NULL, // #456 void(float to, string s) WriteUnterminatedString (DP_SV_WRITEUNTERMINATEDSTRING)
4420 VM_CL_te_flamejet, // #457 void(vector org, vector vel, float howmany) te_flamejet (DP_TE_FLAMEJET)
4422 VM_ftoe, // #459 entity(float num) entitybyindex (DP_QC_EDICT_NUM)
4423 VM_buf_create, // #460 float() buf_create (DP_QC_STRINGBUFFERS)
4424 VM_buf_del, // #461 void(float bufhandle) buf_del (DP_QC_STRINGBUFFERS)
4425 VM_buf_getsize, // #462 float(float bufhandle) buf_getsize (DP_QC_STRINGBUFFERS)
4426 VM_buf_copy, // #463 void(float bufhandle_from, float bufhandle_to) buf_copy (DP_QC_STRINGBUFFERS)
4427 VM_buf_sort, // #464 void(float bufhandle, float sortpower, float backward) buf_sort (DP_QC_STRINGBUFFERS)
4428 VM_buf_implode, // #465 string(float bufhandle, string glue) buf_implode (DP_QC_STRINGBUFFERS)
4429 VM_bufstr_get, // #466 string(float bufhandle, float string_index) bufstr_get (DP_QC_STRINGBUFFERS)
4430 VM_bufstr_set, // #467 void(float bufhandle, float string_index, string str) bufstr_set (DP_QC_STRINGBUFFERS)
4431 VM_bufstr_add, // #468 float(float bufhandle, string str, float order) bufstr_add (DP_QC_STRINGBUFFERS)
4432 VM_bufstr_free, // #469 void(float bufhandle, float string_index) bufstr_free (DP_QC_STRINGBUFFERS)
4433 NULL, // #470 void(float index, float type, .void field) SV_AddStat (EXT_CSQC)
4434 VM_asin, // #471 float(float s) VM_asin (DP_QC_ASINACOSATANATAN2TAN)
4435 VM_acos, // #472 float(float c) VM_acos (DP_QC_ASINACOSATANATAN2TAN)
4436 VM_atan, // #473 float(float t) VM_atan (DP_QC_ASINACOSATANATAN2TAN)
4437 VM_atan2, // #474 float(float c, float s) VM_atan2 (DP_QC_ASINACOSATANATAN2TAN)
4438 VM_tan, // #475 float(float a) VM_tan (DP_QC_ASINACOSATANATAN2TAN)
4439 VM_strlennocol, // #476 float(string s) : DRESK - String Length (not counting color codes) (DP_QC_STRINGCOLORFUNCTIONS)
4440 VM_strdecolorize, // #477 string(string s) : DRESK - Decolorized String (DP_QC_STRINGCOLORFUNCTIONS)
4441 VM_strftime, // #478 string(float uselocaltime, string format, ...) (DP_QC_STRFTIME)
4442 VM_tokenizebyseparator, // #479 float(string s) tokenizebyseparator (DP_QC_TOKENIZEBYSEPARATOR)
4443 VM_strtolower, // #480 string(string s) VM_strtolower (DP_QC_STRING_CASE_FUNCTIONS)
4444 VM_strtoupper, // #481 string(string s) VM_strtoupper (DP_QC_STRING_CASE_FUNCTIONS)
4445 VM_cvar_defstring, // #482 string(string s) cvar_defstring (DP_QC_CVAR_DEFSTRING)
4446 VM_CL_pointsound, // #483 void(vector origin, string sample, float volume, float attenuation) pointsound (DP_SV_POINTSOUND)
4447 VM_strreplace, // #484 string(string search, string replace, string subject) strreplace (DP_QC_STRREPLACE)
4448 VM_strireplace, // #485 string(string search, string replace, string subject) strireplace (DP_QC_STRREPLACE)
4449 VM_CL_getsurfacepointattribute,// #486 vector(entity e, float s, float n, float a) getsurfacepointattribute
4450 VM_gecko_create, // #487 float gecko_create( string name )
4451 VM_gecko_destroy, // #488 void gecko_destroy( string name )
4452 VM_gecko_navigate, // #489 void gecko_navigate( string name, string URI )
4453 VM_gecko_keyevent, // #490 float gecko_keyevent( string name, float key, float eventtype )
4454 VM_gecko_movemouse, // #491 void gecko_mousemove( string name, float x, float y )
4455 VM_gecko_resize, // #492 void gecko_resize( string name, float w, float h )
4456 VM_gecko_get_texture_extent, // #493 vector gecko_get_texture_extent( string name )
4457 VM_crc16, // #494 float(float caseinsensitive, string s, ...) crc16 = #494 (DP_QC_CRC16)
4458 VM_cvar_type, // #495 float(string name) cvar_type = #495; (DP_QC_CVAR_TYPE)
4459 VM_numentityfields, // #496 float() numentityfields = #496; (QP_QC_ENTITYDATA)
4460 VM_entityfieldname, // #497 string(float fieldnum) entityfieldname = #497; (DP_QC_ENTITYDATA)
4461 VM_entityfieldtype, // #498 float(float fieldnum) entityfieldtype = #498; (DP_QC_ENTITYDATA)
4462 VM_getentityfieldstring, // #499 string(float fieldnum, entity ent) getentityfieldstring = #499; (DP_QC_ENTITYDATA)
4463 VM_putentityfieldstring, // #500 float(float fieldnum, entity ent, string s) putentityfieldstring = #500; (DP_QC_ENTITYDATA)
4464 VM_CL_ReadPicture, // #501 string() ReadPicture = #501;
4466 VM_whichpack, // #503 string(string) whichpack = #503;
4473 VM_uri_escape, // #510 string(string in) uri_escape = #510;
4474 VM_uri_unescape, // #511 string(string in) uri_unescape = #511;
4475 VM_etof, // #512 float(entity ent) num_for_edict = #512 (DP_QC_NUM_FOR_EDICT)
4476 VM_uri_get, // #513 float(string uril, float id) uri_get = #512; (DP_QC_URI_GET)
4477 VM_tokenize_console, // #514 float(string str) tokenize_console = #514; (DP_QC_TOKENIZE_CONSOLE)
4478 VM_argv_start_index, // #515 float(float idx) argv_start_index = #515; (DP_QC_TOKENIZE_CONSOLE)
4479 VM_argv_end_index, // #516 float(float idx) argv_end_index = #516; (DP_QC_TOKENIZE_CONSOLE)
4480 VM_buf_cvarlist, // #517 void(float buf, string prefix, string antiprefix) buf_cvarlist = #517; (DP_QC_STRINGBUFFERS_CVARLIST)
4481 VM_cvar_description, // #518 float(string name) cvar_description = #518; (DP_QC_CVAR_DESCRIPTION)
4482 VM_gettime, // #519 float(float timer) gettime = #519; (DP_QC_GETTIME)
4483 VM_keynumtostring, // #520 string keynumtostring(float keynum)
4484 VM_findkeysforcommand, // #521 string findkeysforcommand(string command)
4485 VM_CL_InitParticleSpawner, // #522 void(float max_themes) initparticlespawner (DP_CSQC_SPAWNPARTICLE)
4486 VM_CL_ResetParticle, // #523 void() resetparticle (DP_CSQC_SPAWNPARTICLE)
4487 VM_CL_ParticleTheme, // #524 void(float theme) particletheme (DP_CSQC_SPAWNPARTICLE)
4488 VM_CL_ParticleThemeSave, // #525 void() particlethemesave, void(float theme) particlethemeupdate (DP_CSQC_SPAWNPARTICLE)
4489 VM_CL_ParticleThemeFree, // #526 void() particlethemefree (DP_CSQC_SPAWNPARTICLE)
4490 VM_CL_SpawnParticle, // #527 float(vector org, vector vel, [float theme]) particle (DP_CSQC_SPAWNPARTICLE)
4491 VM_CL_SpawnParticleDelayed, // #528 float(vector org, vector vel, float delay, float collisiondelay, [float theme]) delayedparticle (DP_CSQC_SPAWNPARTICLE)
4492 VM_loadfromdata, // #529
4493 VM_loadfromfile, // #530
4568 VM_callfunction, // #605
4569 VM_writetofile, // #606
4570 VM_isfunction, // #607
4576 VM_parseentitydata, // #613
4587 VM_CL_getextresponse, // #624 string getextresponse(void)
4591 const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);
4593 void VM_Polygons_Reset(void)
4595 vmpolygons_t* polys = vmpolygons + PRVM_GetProgNr();
4597 // TODO: replace vm_polygons stuff with a more general debugging polygon system, and make vm_polygons functions use that system
4598 if(polys->initialized)
4600 Mem_FreePool(&polys->pool);
4601 polys->initialized = false;
4605 void VM_CL_Cmd_Init(void)
4608 VM_Polygons_Reset();
4611 void VM_CL_Cmd_Reset(void)
4613 World_End(&cl.world);
4615 VM_Polygons_Reset();