Group effects in a folder
[xonotic/xonotic-data.pk3dir.git] / qcsrc / client / csqcmodel_hooks.qc
1 #include "csqcmodel_hooks.qh"
2 #include "_all.qh"
3
4 #include "gibs.qh"
5 #include "player_skeleton.qh"
6
7 #include "weapons/projectile.qh"
8
9 #include "../common/animdecide.qh"
10 #include "../common/csqcmodel_settings.qh"
11 #include "../common/effects/effects.qh"
12 #include "../common/teams.qh"
13 #include "../common/triggers/trigger/viewloc.qh"
14
15 #include "mutators/events.qh"
16
17 #include "../csqcmodellib/cl_model.qh"
18 #include "../csqcmodellib/cl_player.qh"
19 #include "../csqcmodellib/interpolate.qh"
20
21
22 .float death_time;
23 .int modelflags;
24
25 void CSQCModel_Hook_PreDraw(bool isplayer);
26
27 .bool isplayermodel;
28
29 // FEATURE: LOD
30 .int lodmodelindex0;
31 .int lodmodelindex1;
32 .int lodmodelindex2;
33 void CSQCPlayer_LOD_Apply(void)
34 {SELFPARAM();
35         // LOD model loading
36         if(self.lodmodelindex0 != self.modelindex)
37         {
38                 string modelname = self.model;
39                 string s;
40
41                 vector mi = self.mins;
42                 vector ma = self.maxs;
43
44                 // set modelindex
45                 self.lodmodelindex0 = self.modelindex;
46                 self.lodmodelindex1 = self.modelindex;
47                 self.lodmodelindex2 = self.modelindex;
48
49                 // FIXME: this only supports 3-letter extensions
50                 s = strcat(substring(modelname, 0, strlen(modelname)-4), "_lod1", substring(modelname, -4, 4));
51                 if(fexists(s))
52                 {
53                         precache_model(s);
54                         setmodel(self, s);
55                         if(self.modelindex)
56                                 self.lodmodelindex1 = self.modelindex;
57                 }
58
59                 s = strcat(substring(modelname, 0, strlen(modelname)-4), "_lod2", substring(modelname, -4, 4));
60                 if(fexists(s))
61                 {
62                         precache_model(s);
63                         setmodel(self, s);
64                         if(self.modelindex)
65                                 self.lodmodelindex2 = self.modelindex;
66                 }
67
68                 setmodel(self, modelname); // make everything normal again
69                 setsize(self, mi, ma);
70         }
71
72         // apply LOD
73         if(autocvar_cl_playerdetailreduction <= 0)
74         {
75                 if(autocvar_cl_playerdetailreduction <= -2)
76                         self.modelindex = self.lodmodelindex2;
77                 else if(autocvar_cl_playerdetailreduction <= -1)
78                         self.modelindex = self.lodmodelindex1;
79                 else
80                         self.modelindex = self.lodmodelindex0;
81         }
82         else
83         {
84                 float distance = vlen(self.origin - view_origin);
85                 float f = (distance * current_viewzoom + 100.0) * autocvar_cl_playerdetailreduction;
86                 f *= 1.0 / bound(0.01, view_quality, 1);
87                 if(f > autocvar_cl_loddistance2)
88                         self.modelindex = self.lodmodelindex2;
89                 else if(f > autocvar_cl_loddistance1)
90                         self.modelindex = self.lodmodelindex1;
91                 else
92                         self.modelindex = self.lodmodelindex0;
93         }
94 }
95
96 // FEATURE: forcemodel and model color selection (MUST be called BEFORE LOD!)
97 string forceplayermodels_model;
98 bool forceplayermodels_modelisgoodmodel;
99 int forceplayermodels_modelindex;
100 int forceplayermodels_skin;
101
102 string forceplayermodels_mymodel;
103 bool forceplayermodels_myisgoodmodel;
104 int forceplayermodels_mymodelindex;
105
106 bool forceplayermodels_attempted;
107
108 .string forceplayermodels_savemodel;
109 .int forceplayermodels_savemodelindex;
110 .int forceplayermodels_saveskin;
111 .int forceplayermodels_savecolormap;
112
113 .string forceplayermodels_isgoodmodel_mdl;
114 .bool forceplayermodels_isgoodmodel;
115
116 string forceplayermodels_goodmodel;
117 int forceplayermodels_goodmodelindex;
118
119 .vector glowmod;
120 .vector old_glowmod;
121
122 void CSQCPlayer_ModelAppearance_PreUpdate(void)
123 {SELFPARAM();
124         self.model = self.forceplayermodels_savemodel;
125         self.modelindex = self.forceplayermodels_savemodelindex;
126         self.skin = self.forceplayermodels_saveskin;
127         self.colormap = self.forceplayermodels_savecolormap;
128 }
129 void CSQCPlayer_ModelAppearance_PostUpdate(void)
130 {SELFPARAM();
131         self.forceplayermodels_savemodel = self.model;
132         self.forceplayermodels_savemodelindex = self.modelindex;
133         self.forceplayermodels_saveskin = self.skin;
134         self.forceplayermodels_savecolormap = self.colormap;
135
136         if(self.forceplayermodels_savemodel != self.forceplayermodels_isgoodmodel_mdl)
137         {
138                 self.forceplayermodels_isgoodmodel = fexists(self.forceplayermodels_savemodel);
139                 self.forceplayermodels_isgoodmodel_mdl = self.forceplayermodels_savemodel;
140                 if(!self.forceplayermodels_isgoodmodel)
141                         LOG_INFOF("Warning: missing model %s has been used\n", self.forceplayermodels_savemodel);
142         }
143 }
144 void CSQCPlayer_ModelAppearance_Apply(bool islocalplayer)
145 {SELFPARAM();
146         // FORCEMODEL
147         // which one is ALWAYS good?
148         if (!forceplayermodels_goodmodel)
149         {
150                 entity e;
151                 e = spawn();
152                 precache_model(cvar_defstring("_cl_playermodel"));
153                 setmodel(e, cvar_defstring("_cl_playermodel"));
154                 forceplayermodels_goodmodel = e.model;
155                 forceplayermodels_goodmodelindex = e.modelindex;
156                 remove(e);
157         }
158
159         // first, try finding it from the server
160         if(self.forceplayermodels_savemodelindex && self.forceplayermodels_savemodel != "null")
161         {
162                 if(islocalplayer)
163                 {
164                         if(!isdemo()) // this is mainly cheat protection; not needed for demos
165                         {
166                                 // trust server's idea of "own player model"
167                                 forceplayermodels_modelisgoodmodel = self.forceplayermodels_isgoodmodel;
168                                 forceplayermodels_model = self.forceplayermodels_savemodel;
169                                 forceplayermodels_modelindex = self.forceplayermodels_savemodelindex;
170                                 forceplayermodels_skin = self.forceplayermodels_saveskin;
171                                 forceplayermodels_attempted = 1;
172                         }
173                 }
174         }
175
176         // forcemodel finding
177         if(!forceplayermodels_attempted)
178         {
179                 forceplayermodels_attempted = 1;
180
181                 // only if this failed, find it out on our own
182                 entity e;
183                 e = spawn();
184                 setmodel(e, autocvar__cl_playermodel); // this is harmless, see below
185                 forceplayermodels_modelisgoodmodel = fexists(e.model);
186                 forceplayermodels_model = e.model;
187                 forceplayermodels_modelindex = e.modelindex;
188                 forceplayermodels_skin = autocvar__cl_playerskin;
189                 remove(e);
190         }
191
192         if(autocvar_cl_forcemyplayermodel != "" && autocvar_cl_forcemyplayermodel != forceplayermodels_mymodel)
193         {
194                 entity e;
195                 e = spawn();
196                 setmodel(e, autocvar_cl_forcemyplayermodel); // this is harmless, see below
197                 forceplayermodels_myisgoodmodel = fexists(e.model);
198                 forceplayermodels_mymodel = e.model;
199                 forceplayermodels_mymodelindex = e.modelindex;
200                 remove(e);
201         }
202
203         // apply it
204         bool isfriend;
205         int cm;
206         cm = self.forceplayermodels_savecolormap;
207         cm = (cm >= 1024) ? cm : (stof(getplayerkeyvalue(cm - 1, "colors")) + 1024);
208
209         if(teamplay)
210                 isfriend = (cm == 1024 + 17 * myteam);
211         else
212                 isfriend = islocalplayer;
213
214         if(autocvar_cl_forcemyplayermodel != "" && forceplayermodels_myisgoodmodel && isfriend)
215         {
216                 self.model = forceplayermodels_mymodel;
217                 self.modelindex = forceplayermodels_mymodelindex;
218                 self.skin = autocvar_cl_forcemyplayerskin;
219         }
220         else if(autocvar_cl_forceplayermodels && forceplayermodels_modelisgoodmodel)
221         {
222                 self.model = forceplayermodels_model;
223                 self.modelindex = forceplayermodels_modelindex;
224                 self.skin = forceplayermodels_skin;
225         }
226         else if(self.forceplayermodels_isgoodmodel)
227         {
228                 self.model = self.forceplayermodels_savemodel;
229                 self.modelindex = self.forceplayermodels_savemodelindex;
230                 self.skin = self.forceplayermodels_saveskin;
231         }
232         else
233         {
234                 self.model = forceplayermodels_goodmodel;
235                 self.modelindex = forceplayermodels_goodmodelindex;
236                 self.skin = self.forceplayermodels_saveskin;
237         }
238
239         // forceplayercolors too
240         if(teamplay)
241         {
242                 // own team's color is never forced
243                 int forcecolor_friend = 0;
244                 int forcecolor_enemy = 0;
245                 entity tm;
246
247                 if(autocvar_cl_forcemyplayercolors)
248                         forcecolor_friend = 1024 + autocvar_cl_forcemyplayercolors;
249                 if(autocvar_cl_forceplayercolors && team_count == 2)
250                         forcecolor_enemy = 1024 + autocvar__cl_color;
251
252                 if(forcecolor_enemy && !forcecolor_friend)
253                 {
254                         // only enemy color is forced?
255                         // verify it is not equal to the friend color
256                         if(forcecolor_enemy == 1024 + 17 * myteam)
257                                 forcecolor_enemy = 0;
258                 }
259
260                 if(forcecolor_friend && !forcecolor_enemy)
261                 {
262                         // only friend color is forced?
263                         // verify it is not equal to the enemy color
264                         for(tm = teams.sort_next; tm; tm = tm.sort_next)
265                                 // note: we even compare against our own team.
266                                 // if we rejected because we matched our OWN team color,
267                                 // this is not bad; we then simply keep our color as is
268                                 // anyway.
269                                 if(forcecolor_friend == 1024 + 17 * tm.team)
270                                         forcecolor_friend = 0;
271                 }
272
273                 if(cm == 1024 + 17 * myteam)
274                 {
275                         if(forcecolor_friend)
276                                 self.colormap = forcecolor_friend;
277                 }
278                 else
279                 {
280                         if(forcecolor_enemy)
281                                 self.colormap = forcecolor_enemy;
282                 }
283         }
284         else
285         {
286                 if(autocvar_cl_forcemyplayercolors && islocalplayer)
287                         self.colormap = 1024 + autocvar_cl_forcemyplayercolors;
288                 else if(autocvar_cl_forceplayercolors)
289                         self.colormap = player_localnum + 1;
290         }
291
292         // GLOWMOD AND DEATH FADING
293         if(self.colormap > 0)
294                 self.glowmod = colormapPaletteColor(((self.colormap >= 1024) ? self.colormap : stof(getplayerkeyvalue(self.colormap - 1, "colors"))) & 0x0F, true) * 2;
295         else
296                 self.glowmod = '1 1 1';
297
298         if(autocvar_cl_deathglow > 0)
299         {
300                 if(self.csqcmodel_isdead)
301                 {
302                         // Fade out to black now...
303                         if(self.old_glowmod == '0 0 0') { self.old_glowmod = self.glowmod; }
304                         self.colormap = 0;
305
306                         self.glowmod = self.old_glowmod * bound(0, 1 - (time - self.death_time) / autocvar_cl_deathglow, 1);
307                         self.glowmod_x = max(self.glowmod.x, 0.0001);
308                         self.glowmod_y = max(self.glowmod.y, 0.0001);
309                         self.glowmod_z = max(self.glowmod.z, 0.0001);
310                 }
311                 else if(self.old_glowmod != '0 0 0') { self.old_glowmod = '0 0 0'; }
312         }
313
314         //printf("CSQCPlayer_ModelAppearance_Apply(): state = %s, colormap = %f, glowmod = %s\n", (self.csqcmodel_isdead ? "DEAD" : "ALIVE"), self.colormap, vtos(self.glowmod));
315 }
316
317 // FEATURE: fallback frames
318 .int csqcmodel_saveframe;
319 .int csqcmodel_saveframe2;
320 #ifdef CSQCMODEL_HAVE_TWO_FRAMES
321 .int csqcmodel_saveframe3;
322 .int csqcmodel_saveframe4;
323 #endif
324 .int csqcmodel_framecount;
325
326 #define IS_DEAD_FRAME(f) ((f) == 0 || (f) == 1)
327 void CSQCPlayer_FallbackFrame_PreUpdate(void)
328 {SELFPARAM();
329         self.frame = self.csqcmodel_saveframe;
330         self.frame2 = self.csqcmodel_saveframe2;
331 #ifdef CSQCMODEL_HAVE_TWO_FRAMES
332         self.frame3 = self.csqcmodel_saveframe3;
333         self.frame4 = self.csqcmodel_saveframe4;
334 #endif
335 }
336 void CSQCPlayer_FallbackFrame_PostUpdate(bool isnew)
337 {SELFPARAM();
338         self.csqcmodel_saveframe = self.frame;
339         self.csqcmodel_saveframe2 = self.frame2;
340 #ifdef CSQCMODEL_HAVE_TWO_FRAMES
341         self.csqcmodel_saveframe3 = self.frame3;
342         self.csqcmodel_saveframe4 = self.frame4;
343 #endif
344
345         // hack for death animations: set their frametime to zero in case a
346         // player "pops in"
347         if(isnew)
348         {
349 #define FIX_FRAMETIME(f,ft) do {                                                                                                                                                                        \
350                 if(IS_DEAD_FRAME(self.f) && self.ft != 0 && self.death_time != 0)                                                                                       \
351                         self.ft = self.death_time;                                                                                                                                                              \
352 } while(0)
353                 FIX_FRAMETIME(frame, frame1time);
354                 FIX_FRAMETIME(frame2, frame2time);
355 #ifdef CSQCMODEL_HAVE_TWO_FRAMES
356                 FIX_FRAMETIME(frame3, frame3time);
357                 FIX_FRAMETIME(frame4, frame4time);
358 #endif
359         }
360         self.csqcmodel_isdead = IS_DEAD_FRAME(self.frame);
361 }
362 void CSQCPlayer_AnimDecide_PostUpdate(bool isnew)
363 {SELFPARAM();
364         self.csqcmodel_isdead = !!(self.anim_state & (ANIMSTATE_DEAD1 | ANIMSTATE_DEAD2));
365 }
366 int CSQCPlayer_FallbackFrame(int f)
367 {SELFPARAM();
368         if(frameduration(self.modelindex, f) > 0)
369                 return f; // goooooood
370         if(frameduration(self.modelindex, 1) <= 0)
371                 return f; // this is a static model. We can't fix it if we wanted to
372         switch(f)
373         {
374                 case 23: return 11; // anim_melee -> anim_shoot
375                 case 24: return 4; // anim_duckwalkbackwards -> anim_duckwalk
376                 case 25: return 4; // anim_duckwalkstrafeleft -> anim_duckwalk
377                 case 26: return 4; // anim_duckwalkstraferight -> anim_duckwalk
378                 case 27: return 4; // anim_duckwalkforwardright -> anim_duckwalk
379                 case 28: return 4; // anim_duckwalkforwardleft -> anim_duckwalk
380                 case 29: return 4; // anim_duckwalkbackright -> anim_duckwalk
381                 case 30: return 4; // anim_duckwalkbackleft -> anim_duckwalk
382         }
383         LOG_INFOF("Frame %d missing in model %s, and we have no fallback - FAIL!\n", f, self.model);
384         return f;
385 }
386 void CSQCPlayer_FallbackFrame_Apply(void)
387 {SELFPARAM();
388         self.frame = CSQCPlayer_FallbackFrame(self.frame);
389         self.frame2 = CSQCPlayer_FallbackFrame(self.frame2);
390 #ifdef CSQCMODEL_HAVE_TWO_FRAMES
391         self.frame3 = CSQCPlayer_FallbackFrame(self.frame3);
392         self.frame4 = CSQCPlayer_FallbackFrame(self.frame4);
393 #endif
394 }
395
396 // FEATURE: auto tag_index
397 .entity tag_entity;
398 .int tag_entity_lastmodelindex;
399 .int tag_index;
400 void CSQCModel_AutoTagIndex_Apply(void)
401 {SELFPARAM();
402         if(self.tag_entity && wasfreed(self.tag_entity))
403                 self.tag_entity = world;
404
405         if(self.viewloc && wasfreed(self.viewloc))
406                 self.viewloc = world;
407
408         if(self.viewloc.entnum != self.tag_networkviewloc)
409                 self.viewloc = findfloat(world, entnum, self.tag_networkviewloc);
410
411         MUTATOR_CALLHOOK(TagIndex_Update, self);
412
413         if(self.tag_networkentity)
414         {
415                 // we are ATTACHED!
416                 bool changed = 0;
417                 if(self.tag_entity.entnum != self.tag_networkentity)
418                 {
419                         self.tag_entity = findfloat(world, entnum, self.tag_networkentity);
420                         changed = 1;
421                 }
422
423                 // recursive predraw call to fix issues with forcemodels and LOD if bone indexes mismatch
424                 if(self.tag_entity.classname == "csqcmodel")
425                 {
426                         WITH(entity, self, self.tag_entity, CSQCModel_Hook_PreDraw((self.entnum >= 1 && self.entnum <= maxclients)));
427                 }
428
429                 if(self.tag_entity.modelindex != self.tag_entity_lastmodelindex)
430                 {
431                         self.tag_entity_lastmodelindex = self.tag_entity.modelindex;
432                         changed = 1;
433                 }
434                 if(changed)
435                 {
436                         if(self.tag_entity)
437                         {
438                                 // the best part is: IT EXISTS
439                                 if(substring(self.model, 0, 14) == "models/weapons")
440                                 {
441                                         if(substring(self.tag_entity.model, 0, 14) == "models/weapons")
442                                         {
443                                                 self.tag_index = gettagindex(self.tag_entity, "weapon");
444                                                 if(!self.tag_index)
445                                                         self.tag_index = gettagindex(self.tag_entity, "tag_weapon");
446                                                 if(!self.tag_index)
447                                                 {
448                                                         // we need to prevent this from 'appening
449                                                         self.tag_entity = world;
450                                                         self.drawmask = 0;
451                                                         LOG_TRACE("h_ model lacks weapon attachment, but v_ model is attached to it\n");
452                                                 }
453                                         }
454                                         else if(self.tag_entity.isplayermodel)
455                                         {
456                                                 skeleton_loadinfo(self.tag_entity);
457                                                 self.tag_index = self.tag_entity.bone_weapon;
458                                         }
459                                 }
460
461                                 if(substring(self.tag_entity.model, 0, 14) == "models/weapons")
462                                 {
463                                         self.tag_index = gettagindex(self.tag_entity, "shot");
464                                         if(!self.tag_index)
465                                                 self.tag_index = gettagindex(self.tag_entity, "tag_shot");
466                                 }
467
468                                 MUTATOR_CALLHOOK(TagIndex_Apply, self);
469                         }
470                         else
471                         {
472                                 // damn, see you next frame
473                                 self.drawmask = 0;
474                         }
475                 }
476         }
477 }
478
479 // FEATURE: EF_NODRAW workalike
480 const int EF_BRIGHTFIELD        = 1;
481 const int EF_BRIGHTLIGHT        = 4;
482 const int EF_DIMLIGHT           = 8;
483 const int EF_DOUBLESIDED        = 32768;
484 const int EF_NOSELFSHADOW       = 65536;
485 const int EF_DYNAMICMODELLIGHT = 131072;
486 const int EF_RESTARTANIM_BIT = 1048576;
487 const int EF_TELEPORT_BIT = 2097152;
488 const int MF_ROCKET  =   1; // leave a trail
489 const int MF_GRENADE =   2; // leave a trail
490 const int MF_GIB     =   4; // leave a trail
491 const int MF_ROTATE  =   8; // rotate (bonus items)
492 const int MF_TRACER  =  16; // green split trail
493 const int MF_ZOMGIB  =  32; // small blood trail
494 const int MF_TRACER2 =  64; // orange split trail
495 const int MF_TRACER3 = 128; // purple trail
496 .int csqcmodel_effects;
497 .int csqcmodel_modelflags;
498 void CSQCModel_Effects_PreUpdate(void)
499 {SELFPARAM();
500         self.effects = self.csqcmodel_effects;
501         self.modelflags = self.csqcmodel_modelflags;
502 }
503 void Reset_ArcBeam(void);
504 void CSQCModel_Effects_PostUpdate(void)
505 {SELFPARAM();
506         if (self == csqcplayer) {
507                 if (self.csqcmodel_teleported) {
508                         Reset_ArcBeam();
509                 }
510         }
511         self.csqcmodel_effects = self.effects;
512         self.csqcmodel_modelflags = self.modelflags;
513         self.effects = 0;
514         self.modelflags = 0;
515         if(self.csqcmodel_teleported)
516                 Projectile_ResetTrail(self.origin);
517 }
518 .int snd_looping;
519 void CSQCModel_Effects_Apply(void)
520 {SELFPARAM();
521         int eff = self.csqcmodel_effects & ~CSQCMODEL_EF_RESPAWNGHOST;
522
523         self.renderflags &= ~(RF_DEPTHHACK | RF_ADDITIVE | RF_FULLBRIGHT | EF_NOSHADOW | RF_USEAXIS);
524         self.effects = 0;
525         self.traileffect = 0;
526
527         if(eff & EF_BRIGHTFIELD)
528                 self.traileffect = particleeffectnum(EFFECT_TR_NEXUIZPLASMA);
529         // ignoring EF_MUZZLEFLASH
530         if(eff & EF_BRIGHTLIGHT)
531                 adddynamiclight(self.origin, 400, '3 3 3');
532         if(eff & EF_DIMLIGHT)
533                 adddynamiclight(self.origin, 200, '1.5 1.5 1.5');
534         if((eff & EF_NODRAW) || (self.alpha < 0))
535                 self.drawmask = 0;
536         if(eff & EF_ADDITIVE)
537                 self.renderflags |= RF_ADDITIVE;
538         if(eff & EF_BLUE)
539                 adddynamiclight(self.origin, 200, '0.15 0.15 1.5');
540         if(eff & EF_RED)
541                 adddynamiclight(self.origin, 200, '1.5 0.15 0.15');
542         // ignoring EF_NOGUNBOB
543         if(eff & EF_FULLBRIGHT)
544                 self.renderflags |= RF_FULLBRIGHT;
545         if(eff & EF_FLAME)
546                 pointparticles(particleeffectnum(EFFECT_EF_FLAME), self.origin, '0 0 0', bound(0, frametime, 0.1));
547         if(eff & EF_STARDUST)
548                 pointparticles(particleeffectnum(EFFECT_EF_STARDUST), self.origin, '0 0 0', bound(0, frametime, 0.1));
549         if(eff & EF_NOSHADOW)
550                 self.renderflags |= RF_NOSHADOW;
551         if(eff & EF_NODEPTHTEST)
552                 self.renderflags |= RF_DEPTHHACK;
553         // ignoring EF_SELECTABLE
554         if(eff & EF_DOUBLESIDED)
555                 self.effects |= EF_DOUBLESIDED;
556         if(eff & EF_NOSELFSHADOW)
557                 self.effects |= EF_NOSELFSHADOW;
558         if(eff & EF_DYNAMICMODELLIGHT)
559                 self.renderflags |= RF_DYNAMICMODELLIGHT;
560         // ignoring EF_UNUSED18, EF_UNUSED19, EF_RESTARTANIM_BIT, EF_TELEPORT_BIT, EF_LOWPRECISION
561         if(self.csqcmodel_modelflags & MF_ROCKET)
562                 self.traileffect = particleeffectnum(EFFECT_TR_ROCKET);
563         if(self.csqcmodel_modelflags & MF_GRENADE)
564                 self.traileffect = particleeffectnum(EFFECT_TR_GRENADE);
565         if(self.csqcmodel_modelflags & MF_GIB)
566                 self.traileffect = particleeffectnum(EFFECT_TR_BLOOD);
567         if(self.csqcmodel_modelflags & MF_ROTATE)
568         {
569                 self.renderflags |= RF_USEAXIS;
570                 makevectors(self.angles + '0 100 0' * fmod(time, 3.6));
571         }
572         if(self.csqcmodel_modelflags & MF_TRACER)
573                 self.traileffect = particleeffectnum(EFFECT_TR_WIZSPIKE);
574         if(self.csqcmodel_modelflags & MF_ZOMGIB)
575                 self.traileffect = particleeffectnum(EFFECT_TR_SLIGHTBLOOD);
576         if(self.csqcmodel_modelflags & MF_TRACER2)
577                 self.traileffect = particleeffectnum(EFFECT_TR_KNIGHTSPIKE);
578         if(self.csqcmodel_modelflags & MF_TRACER3)
579                 self.traileffect = particleeffectnum(EFFECT_TR_VORESPIKE);
580
581         if(self.drawmask)
582                 Projectile_DrawTrail(self.origin);
583         else
584                 Projectile_ResetTrail(self.origin);
585
586         if(self.csqcmodel_effects & CSQCMODEL_EF_RESPAWNGHOST)
587                 self.renderflags |= RF_ADDITIVE;
588                 // also special in CSQCPlayer_GlowMod_Apply
589
590         if(self.csqcmodel_modelflags & MF_ROCKET)
591         {
592                 if(!self.snd_looping)
593                 {
594                         sound(self, CH_TRIGGER_SINGLE, "misc/jetpack_fly.wav", VOL_BASE, autocvar_g_jetpack_attenuation);
595                         self.snd_looping = CH_TRIGGER_SINGLE;
596                 }
597         }
598         else
599         {
600                 if(self.snd_looping)
601                 {
602                         sound(self, self.snd_looping, "misc/null.wav", VOL_BASE, autocvar_g_jetpack_attenuation);
603                         self.snd_looping = 0;
604                 }
605         }
606 }
607
608 void CSQCPlayer_Precache()
609 {
610         precache_sound("misc/jetpack_fly.wav");
611 }
612
613 // general functions
614 .int csqcmodel_predraw_run;
615 .int anim_frame;
616 .int anim_frame1time;
617 .int anim_frame2;
618 .int anim_frame2time;
619 .int anim_saveframe;
620 .int anim_saveframe1time;
621 .int anim_saveframe2;
622 .int anim_saveframe2time;
623 .int anim_prev_pmove_flags;
624 void CSQCModel_Hook_PreDraw(bool isplayer)
625 {SELFPARAM();
626         if(self.csqcmodel_predraw_run == framecount)
627                 return;
628         self.csqcmodel_predraw_run = framecount;
629
630         if(!self.modelindex || self.model == "null")
631         {
632                 self.drawmask = 0;
633                 return;
634         }
635         else
636                 self.drawmask = MASK_NORMAL;
637
638         if(self.isplayermodel) // this checks if it's a player MODEL!
639         {
640                 CSQCPlayer_ModelAppearance_Apply(self.entnum == player_localnum + 1);
641                 CSQCPlayer_LOD_Apply();
642
643                 if(!isplayer)
644                 {
645                         skeleton_loadinfo(self);
646                         bool doblend = (self.bone_upperbody >= 0);
647                         CSQCPlayer_FallbackFrame_Apply();
648                         if(doblend)
649                         {
650                                 skeleton_from_frames(self, self.csqcmodel_isdead);
651                         }
652                         else
653                         {
654                                 free_skeleton_from_frames(self);
655                                 // just in case, clear these (we're animating in frame and frame3)
656                                 self.lerpfrac = 0;
657                                 self.lerpfrac4 = 0;
658                         }
659                 }
660                 else
661                 {
662                         // we know that frame3 and frame4 fields, used by InterpolateAnimation, are left alone - but that is all we know!
663                         skeleton_loadinfo(self);
664                         bool doblend = (self.bone_upperbody >= 0);
665                         bool onground = 0;
666                         if(self == csqcplayer)
667                         {
668                                 if(self.flags & FL_ONGROUND)
669                                         onground = 1;
670                                 self.anim_prev_pmove_flags = self.flags;
671                                 if(self.flags & FL_DUCKED)
672                                         animdecide_setstate(self, self.anim_state | ANIMSTATE_DUCK, false);
673                                 else if(self.anim_state & ANIMSTATE_DUCK)
674                                         animdecide_setstate(self, self.anim_state - ANIMSTATE_DUCK, false);
675                         }
676                         else
677                         {
678                                 tracebox(self.origin + '0 0 1', self.mins, self.maxs, self.origin - '0 0 4', MOVE_NORMAL, self);
679                                 if(trace_startsolid || trace_fraction < 1)
680                                         onground = 1;
681                         }
682                         animdecide_load_if_needed(self);
683                         animdecide_setimplicitstate(self, onground);
684                         animdecide_setframes(self, doblend, anim_frame, anim_frame1time, anim_frame2, anim_frame2time);
685                         int sf = 0;
686                         if(self.anim_saveframe != self.anim_frame || self.anim_saveframe1time != self.anim_frame1time)
687                                 sf |= CSQCMODEL_PROPERTY_FRAME;
688                         if(self.anim_saveframe2 != self.anim_frame2 || self.anim_saveframe2time != self.anim_frame2time)
689                                 sf |= CSQCMODEL_PROPERTY_FRAME2;
690                         self.anim_saveframe = self.anim_frame;
691                         self.anim_saveframe1time = self.anim_frame1time;
692                         self.anim_saveframe2 = self.anim_frame2;
693                         self.anim_saveframe2time = self.anim_frame2time;
694                         // Note: we always consider lerpfrac "changed", as it uses fixed values every time anyway.
695                         // This ensures that .frame etc. are always written.
696                         CSQCModel_InterpolateAnimation_2To4_PreNote(sf | CSQCMODEL_PROPERTY_LERPFRAC);
697                         self.lerpfrac = (doblend ? 0.5 : 0);
698                         self.frame = self.anim_frame;
699                         self.frame1time = self.anim_frame1time;
700                         self.frame2 = self.anim_frame2;
701                         self.frame2time = self.anim_frame2time;
702                         CSQCModel_InterpolateAnimation_2To4_Note(sf | CSQCMODEL_PROPERTY_LERPFRAC, false);
703                         CSQCModel_InterpolateAnimation_2To4_Do();
704                         if(doblend)
705                         {
706                                 skeleton_from_frames(self, self.csqcmodel_isdead);
707                         }
708                         else
709                         {
710                                 free_skeleton_from_frames(self);
711                                 // just in case, clear these (we're animating in frame and frame3)
712                                 self.lerpfrac = 0;
713                                 self.lerpfrac4 = 0;
714                         }
715                 }
716         }
717
718         CSQCModel_AutoTagIndex_Apply();
719
720         CSQCModel_Effects_Apply();
721 }
722
723 void CSQCModel_Hook_PreUpdate(bool isnew, bool isplayer, bool islocalplayer)
724 {SELFPARAM();
725         // interpolate v_angle
726         self.iflags |= IFLAG_V_ANGLE_X;
727         // revert to values from server
728         CSQCModel_Effects_PreUpdate();
729         if(self.isplayermodel)
730         {
731                 if(!isplayer)
732                         CSQCPlayer_FallbackFrame_PreUpdate();
733                 CSQCPlayer_ModelAppearance_PreUpdate();
734         }
735 }
736
737 void CSQCModel_Hook_PostUpdate(bool isnew, bool isplayer, bool islocalplayer)
738 {SELFPARAM();
739         // is it a player model? (shared state)
740         self.isplayermodel = (substring(self.model, 0, 14) == "models/player/" || substring(self.model, 0, 17) == "models/ok_player/" || (substring(self.model, 0, 16) == "models/monsters/" && (self.entnum >= 1 && self.entnum <= maxclients)));
741
742         // save values set by server
743         if(self.isplayermodel)
744         {
745                 CSQCPlayer_ModelAppearance_PostUpdate();
746                 if(isplayer)
747                         CSQCPlayer_AnimDecide_PostUpdate(isnew);
748                 else
749                         CSQCPlayer_FallbackFrame_PostUpdate(isnew);
750         }
751         CSQCModel_Effects_PostUpdate();
752 }