use dynamic eye position-centered bouncegrid when rendering in dynamic
[xonotic/darkplaces.git] / view.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12
13 See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
18
19 */
20 // view.c -- player eye positioning
21
22 #include "quakedef.h"
23 #include "cl_collision.h"
24
25 void CL_VM_UpdateDmgGlobals (int dmg_take, int dmg_save, vec3_t dmg_origin);
26
27 /*
28
29 The view is allowed to move slightly from it's true position for bobbing,
30 but if it exceeds 8 pixels linear distance (spherical, not box), the list of
31 entities sent from the server may not include everything in the pvs, especially
32 when crossing a water boudnary.
33
34 */
35
36 cvar_t cl_rollspeed = {0, "cl_rollspeed", "200", "how much strafing is necessary to tilt the view"};
37 cvar_t cl_rollangle = {0, "cl_rollangle", "2.0", "how much to tilt the view when strafing"};
38
39 cvar_t cl_bob = {CVAR_SAVE, "cl_bob","0.02", "view bobbing amount"};
40 cvar_t cl_bobcycle = {CVAR_SAVE, "cl_bobcycle","0.6", "view bobbing speed"};
41 cvar_t cl_bobup = {CVAR_SAVE, "cl_bobup","0.5", "view bobbing adjustment that makes the up or down swing of the bob last longer"};
42 cvar_t cl_bob2 = {CVAR_SAVE, "cl_bob2","0", "sideways view bobbing amount"};
43 cvar_t cl_bob2cycle = {CVAR_SAVE, "cl_bob2cycle","0.6", "sideways view bobbing speed"};
44 cvar_t cl_bob2smooth = {CVAR_SAVE, "cl_bob2smooth","0.05", "how fast the view goes back when you stop touching the ground"};
45 cvar_t cl_bobfall = {CVAR_SAVE, "cl_bobfall","0", "how much the view swings down when falling (influenced by the speed you hit the ground with)"};
46 cvar_t cl_bobfallcycle = {CVAR_SAVE, "cl_bobfallcycle","3", "speed of the bobfall swing"};
47 cvar_t cl_bobfallminspeed = {CVAR_SAVE, "cl_bobfallminspeed","200", "necessary amount of speed for bob-falling to occur"};
48 cvar_t cl_bobmodel = {CVAR_SAVE, "cl_bobmodel", "1", "enables gun bobbing"};
49 cvar_t cl_bobmodel_side = {CVAR_SAVE, "cl_bobmodel_side", "0.15", "gun bobbing sideways sway amount"};
50 cvar_t cl_bobmodel_up = {CVAR_SAVE, "cl_bobmodel_up", "0.06", "gun bobbing upward movement amount"};
51 cvar_t cl_bobmodel_speed = {CVAR_SAVE, "cl_bobmodel_speed", "7", "gun bobbing speed"};
52
53 cvar_t cl_leanmodel = {CVAR_SAVE, "cl_leanmodel", "0", "enables gun leaning"};
54 cvar_t cl_leanmodel_side_speed = {CVAR_SAVE, "cl_leanmodel_side_speed", "0.7", "gun leaning sideways speed"};
55 cvar_t cl_leanmodel_side_limit = {CVAR_SAVE, "cl_leanmodel_side_limit", "35", "gun leaning sideways limit"};
56 cvar_t cl_leanmodel_side_highpass1 = {CVAR_SAVE, "cl_leanmodel_side_highpass1", "30", "gun leaning sideways pre-highpass in 1/s"};
57 cvar_t cl_leanmodel_side_highpass = {CVAR_SAVE, "cl_leanmodel_side_highpass", "3", "gun leaning sideways highpass in 1/s"};
58 cvar_t cl_leanmodel_side_lowpass = {CVAR_SAVE, "cl_leanmodel_side_lowpass", "20", "gun leaning sideways lowpass in 1/s"};
59 cvar_t cl_leanmodel_up_speed = {CVAR_SAVE, "cl_leanmodel_up_speed", "0.65", "gun leaning upward speed"};
60 cvar_t cl_leanmodel_up_limit = {CVAR_SAVE, "cl_leanmodel_up_limit", "50", "gun leaning upward limit"};
61 cvar_t cl_leanmodel_up_highpass1 = {CVAR_SAVE, "cl_leanmodel_up_highpass1", "5", "gun leaning upward pre-highpass in 1/s"};
62 cvar_t cl_leanmodel_up_highpass = {CVAR_SAVE, "cl_leanmodel_up_highpass", "15", "gun leaning upward highpass in 1/s"};
63 cvar_t cl_leanmodel_up_lowpass = {CVAR_SAVE, "cl_leanmodel_up_lowpass", "20", "gun leaning upward lowpass in 1/s"};
64
65 cvar_t cl_followmodel = {CVAR_SAVE, "cl_followmodel", "0", "enables gun following"};
66 cvar_t cl_followmodel_side_speed = {CVAR_SAVE, "cl_followmodel_side_speed", "0.25", "gun following sideways speed"};
67 cvar_t cl_followmodel_side_limit = {CVAR_SAVE, "cl_followmodel_side_limit", "6", "gun following sideways limit"};
68 cvar_t cl_followmodel_side_highpass1 = {CVAR_SAVE, "cl_followmodel_side_highpass1", "30", "gun following sideways pre-highpass in 1/s"};
69 cvar_t cl_followmodel_side_highpass = {CVAR_SAVE, "cl_followmodel_side_highpass", "5", "gun following sideways highpass in 1/s"};
70 cvar_t cl_followmodel_side_lowpass = {CVAR_SAVE, "cl_followmodel_side_lowpass", "10", "gun following sideways lowpass in 1/s"};
71 cvar_t cl_followmodel_up_speed = {CVAR_SAVE, "cl_followmodel_up_speed", "0.5", "gun following upward speed"};
72 cvar_t cl_followmodel_up_limit = {CVAR_SAVE, "cl_followmodel_up_limit", "5", "gun following upward limit"};
73 cvar_t cl_followmodel_up_highpass1 = {CVAR_SAVE, "cl_followmodel_up_highpass1", "60", "gun following upward pre-highpass in 1/s"};
74 cvar_t cl_followmodel_up_highpass = {CVAR_SAVE, "cl_followmodel_up_highpass", "2", "gun following upward highpass in 1/s"};
75 cvar_t cl_followmodel_up_lowpass = {CVAR_SAVE, "cl_followmodel_up_lowpass", "10", "gun following upward lowpass in 1/s"};
76
77 cvar_t cl_viewmodel_scale = {0, "cl_viewmodel_scale", "1", "changes size of gun model, lower values prevent poking into walls but cause strange artifacts on lighting and especially r_stereo/vid_stereobuffer options where the size of the gun becomes visible"};
78
79 cvar_t v_kicktime = {0, "v_kicktime", "0.5", "how long a view kick from damage lasts"};
80 cvar_t v_kickroll = {0, "v_kickroll", "0.6", "how much a view kick from damage rolls your view"};
81 cvar_t v_kickpitch = {0, "v_kickpitch", "0.6", "how much a view kick from damage pitches your view"};
82
83 cvar_t v_iyaw_cycle = {0, "v_iyaw_cycle", "2", "v_idlescale yaw speed"};
84 cvar_t v_iroll_cycle = {0, "v_iroll_cycle", "0.5", "v_idlescale roll speed"};
85 cvar_t v_ipitch_cycle = {0, "v_ipitch_cycle", "1", "v_idlescale pitch speed"};
86 cvar_t v_iyaw_level = {0, "v_iyaw_level", "0.3", "v_idlescale yaw amount"};
87 cvar_t v_iroll_level = {0, "v_iroll_level", "0.1", "v_idlescale roll amount"};
88 cvar_t v_ipitch_level = {0, "v_ipitch_level", "0.3", "v_idlescale pitch amount"};
89
90 cvar_t v_idlescale = {0, "v_idlescale", "0", "how much of the quake 'drunken view' effect to use"};
91
92 cvar_t crosshair = {CVAR_SAVE, "crosshair", "0", "selects crosshair to use (0 is none)"};
93
94 cvar_t v_centermove = {0, "v_centermove", "0.15", "how long before the view begins to center itself (if freelook/+mlook/+jlook/+klook are off)"};
95 cvar_t v_centerspeed = {0, "v_centerspeed","500", "how fast the view centers itself"};
96
97 cvar_t cl_stairsmoothspeed = {CVAR_SAVE, "cl_stairsmoothspeed", "160", "how fast your view moves upward/downward when running up/down stairs"};
98
99 cvar_t cl_smoothviewheight = {CVAR_SAVE, "cl_smoothviewheight", "0", "time of the averaging to the viewheight value so that it creates a smooth transition. higher values = longer transition, 0 for instant transition."};
100
101 cvar_t chase_back = {CVAR_SAVE, "chase_back", "48", "chase cam distance from the player"};
102 cvar_t chase_up = {CVAR_SAVE, "chase_up", "24", "chase cam distance from the player"};
103 cvar_t chase_active = {CVAR_SAVE, "chase_active", "0", "enables chase cam"};
104 cvar_t chase_overhead = {CVAR_SAVE, "chase_overhead", "0", "chase cam looks straight down if this is not zero"};
105 // GAME_GOODVSBAD2
106 cvar_t chase_stevie = {0, "chase_stevie", "0", "chase cam view from above (used only by GoodVsBad2)"};
107
108 cvar_t v_deathtilt = {0, "v_deathtilt", "1", "whether to use sideways view when dead"};
109 cvar_t v_deathtiltangle = {0, "v_deathtiltangle", "80", "what roll angle to use when tilting the view while dead"};
110
111 // Prophecy camera pitchangle by Alexander "motorsep" Zubov
112 cvar_t chase_pitchangle = {CVAR_SAVE, "chase_pitchangle", "55", "chase cam pitch angle"};
113
114 float   v_dmg_time, v_dmg_roll, v_dmg_pitch;
115
116
117 /*
118 ===============
119 V_CalcRoll
120
121 Used by view and sv_user
122 ===============
123 */
124 float V_CalcRoll (vec3_t angles, vec3_t velocity)
125 {
126         vec3_t  right;
127         float   sign;
128         float   side;
129         float   value;
130
131         AngleVectors (angles, NULL, right, NULL);
132         side = DotProduct (velocity, right);
133         sign = side < 0 ? -1 : 1;
134         side = fabs(side);
135
136         value = cl_rollangle.value;
137
138         if (side < cl_rollspeed.value)
139                 side = side * value / cl_rollspeed.value;
140         else
141                 side = value;
142
143         return side*sign;
144
145 }
146
147 void V_StartPitchDrift (void)
148 {
149         if (cl.laststop == cl.time)
150                 return;         // something else is keeping it from drifting
151
152         if (cl.nodrift || !cl.pitchvel)
153         {
154                 cl.pitchvel = v_centerspeed.value;
155                 cl.nodrift = false;
156                 cl.driftmove = 0;
157         }
158 }
159
160 void V_StopPitchDrift (void)
161 {
162         cl.laststop = cl.time;
163         cl.nodrift = true;
164         cl.pitchvel = 0;
165 }
166
167 /*
168 ===============
169 V_DriftPitch
170
171 Moves the client pitch angle towards cl.idealpitch sent by the server.
172
173 If the user is adjusting pitch manually, either with lookup/lookdown,
174 mlook and mouse, or klook and keyboard, pitch drifting is constantly stopped.
175
176 Drifting is enabled when the center view key is hit, mlook is released and
177 lookspring is non 0, or when
178 ===============
179 */
180 void V_DriftPitch (void)
181 {
182         float           delta, move;
183
184         if (noclip_anglehack || !cl.onground || cls.demoplayback )
185         {
186                 cl.driftmove = 0;
187                 cl.pitchvel = 0;
188                 return;
189         }
190
191 // don't count small mouse motion
192         if (cl.nodrift)
193         {
194                 if ( fabs(cl.cmd.forwardmove) < cl_forwardspeed.value)
195                         cl.driftmove = 0;
196                 else
197                         cl.driftmove += cl.realframetime;
198
199                 if ( cl.driftmove > v_centermove.value)
200                 {
201                         V_StartPitchDrift ();
202                 }
203                 return;
204         }
205
206         delta = cl.idealpitch - cl.viewangles[PITCH];
207
208         if (!delta)
209         {
210                 cl.pitchvel = 0;
211                 return;
212         }
213
214         move = cl.realframetime * cl.pitchvel;
215         cl.pitchvel += cl.realframetime * v_centerspeed.value;
216
217         if (delta > 0)
218         {
219                 if (move > delta)
220                 {
221                         cl.pitchvel = 0;
222                         move = delta;
223                 }
224                 cl.viewangles[PITCH] += move;
225         }
226         else if (delta < 0)
227         {
228                 if (move > -delta)
229                 {
230                         cl.pitchvel = 0;
231                         move = -delta;
232                 }
233                 cl.viewangles[PITCH] -= move;
234         }
235 }
236
237
238 /*
239 ==============================================================================
240
241                                                 SCREEN FLASHES
242
243 ==============================================================================
244 */
245
246
247 /*
248 ===============
249 V_ParseDamage
250 ===============
251 */
252 void V_ParseDamage (void)
253 {
254         int armor, blood;
255         vec3_t from;
256         //vec3_t forward, right;
257         vec3_t localfrom;
258         entity_t *ent;
259         //float side;
260         float count;
261
262         armor = MSG_ReadByte ();
263         blood = MSG_ReadByte ();
264         MSG_ReadVector(from, cls.protocol);
265
266         // Send the Dmg Globals to CSQC
267         CL_VM_UpdateDmgGlobals(blood, armor, from);
268
269         count = blood*0.5 + armor*0.5;
270         if (count < 10)
271                 count = 10;
272
273         cl.faceanimtime = cl.time + 0.2;                // put sbar face into pain frame
274
275         cl.cshifts[CSHIFT_DAMAGE].percent += 3*count;
276         cl.cshifts[CSHIFT_DAMAGE].alphafade = 150;
277         if (cl.cshifts[CSHIFT_DAMAGE].percent < 0)
278                 cl.cshifts[CSHIFT_DAMAGE].percent = 0;
279         if (cl.cshifts[CSHIFT_DAMAGE].percent > 150)
280                 cl.cshifts[CSHIFT_DAMAGE].percent = 150;
281
282         if (armor > blood)
283         {
284                 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 200;
285                 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 100;
286                 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 100;
287         }
288         else if (armor)
289         {
290                 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 220;
291                 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 50;
292                 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 50;
293         }
294         else
295         {
296                 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 255;
297                 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 0;
298                 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 0;
299         }
300
301         // calculate view angle kicks
302         if (cl.entities[cl.viewentity].state_current.active)
303         {
304                 ent = &cl.entities[cl.viewentity];
305                 Matrix4x4_Transform(&ent->render.inversematrix, from, localfrom);
306                 VectorNormalize(localfrom);
307                 v_dmg_pitch = count * localfrom[0] * v_kickpitch.value;
308                 v_dmg_roll = count * localfrom[1] * v_kickroll.value;
309                 v_dmg_time = v_kicktime.value;
310         }
311 }
312
313 static cshift_t v_cshift;
314
315 /*
316 ==================
317 V_cshift_f
318 ==================
319 */
320 static void V_cshift_f (void)
321 {
322         v_cshift.destcolor[0] = atof(Cmd_Argv(1));
323         v_cshift.destcolor[1] = atof(Cmd_Argv(2));
324         v_cshift.destcolor[2] = atof(Cmd_Argv(3));
325         v_cshift.percent = atof(Cmd_Argv(4));
326 }
327
328
329 /*
330 ==================
331 V_BonusFlash_f
332
333 When you run over an item, the server sends this command
334 ==================
335 */
336 static void V_BonusFlash_f (void)
337 {
338         if(Cmd_Argc() == 1)
339         {
340                 cl.cshifts[CSHIFT_BONUS].destcolor[0] = 215;
341                 cl.cshifts[CSHIFT_BONUS].destcolor[1] = 186;
342                 cl.cshifts[CSHIFT_BONUS].destcolor[2] = 69;
343                 cl.cshifts[CSHIFT_BONUS].percent = 50;
344                 cl.cshifts[CSHIFT_BONUS].alphafade = 100;
345         }
346         else if(Cmd_Argc() >= 4 && Cmd_Argc() <= 6)
347         {
348                 cl.cshifts[CSHIFT_BONUS].destcolor[0] = atof(Cmd_Argv(1)) * 255;
349                 cl.cshifts[CSHIFT_BONUS].destcolor[1] = atof(Cmd_Argv(2)) * 255;
350                 cl.cshifts[CSHIFT_BONUS].destcolor[2] = atof(Cmd_Argv(3)) * 255;
351                 if(Cmd_Argc() >= 5)
352                         cl.cshifts[CSHIFT_BONUS].percent = atof(Cmd_Argv(4)) * 255; // yes, these are HEXADECIMAL percent ;)
353                 else
354                         cl.cshifts[CSHIFT_BONUS].percent = 50;
355                 if(Cmd_Argc() >= 6)
356                         cl.cshifts[CSHIFT_BONUS].alphafade = atof(Cmd_Argv(5)) * 255;
357                 else
358                         cl.cshifts[CSHIFT_BONUS].alphafade = 100;
359         }
360         else
361                 Con_Printf("usage:\nbf, or bf R G B [A [alphafade]]\n");
362 }
363
364 /*
365 ==============================================================================
366
367                                                 VIEW RENDERING
368
369 ==============================================================================
370 */
371
372 extern matrix4x4_t viewmodelmatrix;
373
374 #include "cl_collision.h"
375 #include "csprogs.h"
376
377 /*
378 ==================
379 V_CalcRefdef
380
381 ==================
382 */
383 #if 0
384 static vec3_t eyeboxmins = {-16, -16, -24};
385 static vec3_t eyeboxmaxs = { 16,  16,  32};
386 #endif
387
388 static vec_t lowpass(vec_t value, vec_t frac, vec_t *store)
389 {
390         frac = bound(0, frac, 1);
391         return (*store = *store * (1 - frac) + value * frac);
392 }
393
394 static vec_t lowpass_limited(vec_t value, vec_t frac, vec_t limit, vec_t *store)
395 {
396         lowpass(value, frac, store);
397         return (*store = bound(value - limit, *store, value + limit));
398 }
399
400 static vec_t highpass(vec_t value, vec_t frac, vec_t *store)
401 {
402         return value - lowpass(value, frac, store);
403 }
404
405 static vec_t highpass_limited(vec_t value, vec_t frac, vec_t limit, vec_t *store)
406 {
407         return value - lowpass_limited(value, frac, limit, store);
408 }
409
410 static void lowpass3(vec3_t value, vec_t fracx, vec_t fracy, vec_t fracz, vec3_t store, vec3_t out)
411 {
412         out[0] = lowpass(value[0], fracx, &store[0]);
413         out[1] = lowpass(value[1], fracy, &store[1]);
414         out[2] = lowpass(value[2], fracz, &store[2]);
415 }
416
417 static void highpass3(vec3_t value, vec_t fracx, vec_t fracy, vec_t fracz, vec3_t store, vec3_t out)
418 {
419         out[0] = highpass(value[0], fracx, &store[0]);
420         out[1] = highpass(value[1], fracy, &store[1]);
421         out[2] = highpass(value[2], fracz, &store[2]);
422 }
423
424 static void highpass3_limited(vec3_t value, vec_t fracx, vec_t limitx, vec_t fracy, vec_t limity, vec_t fracz, vec_t limitz, vec3_t store, vec3_t out)
425 {
426         out[0] = highpass_limited(value[0], fracx, limitx, &store[0]);
427         out[1] = highpass_limited(value[1], fracy, limity, &store[1]);
428         out[2] = highpass_limited(value[2], fracz, limitz, &store[2]);
429 }
430
431 void V_CalcRefdef (void)
432 {
433         entity_t *ent;
434         float vieworg[3], viewangles[3], smoothtime;
435         float gunorg[3], gunangles[3];
436         
437         static float viewheightavg;
438         float viewheight;       
439 #if 0
440 // begin of chase camera bounding box size for proper collisions by Alexander Zubov
441         vec3_t camboxmins = {-3, -3, -3};
442         vec3_t camboxmaxs = {3, 3, 3};
443 // end of chase camera bounding box size for proper collisions by Alexander Zubov
444 #endif
445         trace_t trace;
446         VectorClear(gunorg);
447         viewmodelmatrix = identitymatrix;
448         r_refdef.view.matrix = identitymatrix;
449         if (cls.state == ca_connected && cls.signon == SIGNONS)
450         {
451                 // ent is the view entity (visible when out of body)
452                 ent = &cl.entities[cl.viewentity];
453                 // player can look around, so take the origin from the entity,
454                 // and the angles from the input system
455                 Matrix4x4_OriginFromMatrix(&ent->render.matrix, vieworg);
456                 VectorCopy(cl.viewangles, viewangles);
457
458                 // calculate how much time has passed since the last V_CalcRefdef
459                 smoothtime = bound(0, cl.time - cl.stairsmoothtime, 0.1);
460                 cl.stairsmoothtime = cl.time;
461
462                 // fade damage flash
463                 if (v_dmg_time > 0)
464                         v_dmg_time -= bound(0, smoothtime, 0.1);
465
466                 if (cl.intermission)
467                 {
468                         // entity is a fixed camera, just copy the matrix
469                         if (cls.protocol == PROTOCOL_QUAKEWORLD)
470                                 Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, cl.qw_intermission_origin[0], cl.qw_intermission_origin[1], cl.qw_intermission_origin[2], cl.qw_intermission_angles[0], cl.qw_intermission_angles[1], cl.qw_intermission_angles[2], 1);
471                         else
472                         {
473                                 r_refdef.view.matrix = ent->render.matrix;
474                                 Matrix4x4_AdjustOrigin(&r_refdef.view.matrix, 0, 0, cl.stats[STAT_VIEWHEIGHT]);
475                         }
476                         viewmodelmatrix = r_refdef.view.matrix;
477                 }
478                 else
479                 {
480                         // smooth stair stepping, but only if onground and enabled
481                         if (!cl.onground || cl_stairsmoothspeed.value <= 0 || !ent->persistent.trail_allowed) // FIXME use a better way to detect teleport/warp
482                                 cl.stairsmoothz = vieworg[2];
483                         else
484                         {
485                                 if (cl.stairsmoothz < vieworg[2])
486                                         vieworg[2] = cl.stairsmoothz = bound(vieworg[2] - cl.movevars_stepheight, cl.stairsmoothz + smoothtime * cl_stairsmoothspeed.value, vieworg[2]);
487                                 else if (cl.stairsmoothz > vieworg[2])
488                                         vieworg[2] = cl.stairsmoothz = bound(vieworg[2], cl.stairsmoothz - smoothtime * cl_stairsmoothspeed.value, vieworg[2] + cl.movevars_stepheight);
489                         }
490
491                         // apply qw weapon recoil effect (this did not work in QW)
492                         // TODO: add a cvar to disable this
493                         viewangles[PITCH] += cl.qw_weaponkick;
494
495                         // apply the viewofs (even if chasecam is used)
496                         // Samual: Lets add smoothing for this too so that things like crouching are done with a transition.
497                         viewheight = bound(0, (cl.time - cl.oldtime) / max(0.0001, cl_smoothviewheight.value), 1);
498                         viewheightavg = viewheightavg * (1 - viewheight) + cl.stats[STAT_VIEWHEIGHT] * viewheight;
499                         vieworg[2] += viewheightavg;
500
501                         if (chase_active.value)
502                         {
503                                 // observing entity from third person. Added "campitch" by Alexander "motorsep" Zubov
504                                 vec_t camback, camup, dist, campitch, forward[3], chase_dest[3];
505
506                                 camback = chase_back.value;
507                                 camup = chase_up.value;
508                                 campitch = chase_pitchangle.value;
509
510                                 AngleVectors(viewangles, forward, NULL, NULL);
511
512                                 if (chase_overhead.integer)
513                                 {
514 #if 1
515                                         vec3_t offset;
516                                         vec3_t bestvieworg;
517 #endif
518                                         vec3_t up;
519                                         viewangles[PITCH] = 0;
520                                         AngleVectors(viewangles, forward, NULL, up);
521                                         // trace a little further so it hits a surface more consistently (to avoid 'snapping' on the edge of the range)
522                                         chase_dest[0] = vieworg[0] - forward[0] * camback + up[0] * camup;
523                                         chase_dest[1] = vieworg[1] - forward[1] * camback + up[1] * camup;
524                                         chase_dest[2] = vieworg[2] - forward[2] * camback + up[2] * camup;
525 #if 0
526 #if 1
527                                         //trace = CL_TraceLine(vieworg, eyeboxmins, eyeboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_SKY, true, false, NULL, false);
528                                         trace = CL_TraceLine(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_SKY, true, false, NULL, false);
529 #else
530                                         //trace = CL_TraceBox(vieworg, eyeboxmins, eyeboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_SKY, true, false, NULL, false);
531                                         trace = CL_TraceBox(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_SKY, true, false, NULL, false);
532 #endif
533                                         VectorCopy(trace.endpos, vieworg);
534                                         vieworg[2] -= 8;
535 #else
536                                         // trace from first person view location to our chosen third person view location
537 #if 1
538                                         trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_SKY, true, false, NULL, false);
539 #else
540                                         trace = CL_TraceBox(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_SKY, true, false, NULL, false);
541 #endif
542                                         VectorCopy(trace.endpos, bestvieworg);
543                                         offset[2] = 0;
544                                         for (offset[0] = -16;offset[0] <= 16;offset[0] += 8)
545                                         {
546                                                 for (offset[1] = -16;offset[1] <= 16;offset[1] += 8)
547                                                 {
548                                                         AngleVectors(viewangles, NULL, NULL, up);
549                                                         chase_dest[0] = vieworg[0] - forward[0] * camback + up[0] * camup + offset[0];
550                                                         chase_dest[1] = vieworg[1] - forward[1] * camback + up[1] * camup + offset[1];
551                                                         chase_dest[2] = vieworg[2] - forward[2] * camback + up[2] * camup + offset[2];
552 #if 1
553                                                         trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_SKY, true, false, NULL, false);
554 #else
555                                                         trace = CL_TraceBox(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_SKY, true, false, NULL, false);
556 #endif
557                                                         if (bestvieworg[2] > trace.endpos[2])
558                                                                 bestvieworg[2] = trace.endpos[2];
559                                                 }
560                                         }
561                                         bestvieworg[2] -= 8;
562                                         VectorCopy(bestvieworg, vieworg);
563 #endif
564                                         viewangles[PITCH] = campitch;
565                                 }
566                                 else
567                                 {
568                                         if (gamemode == GAME_GOODVSBAD2 && chase_stevie.integer)
569                                         {
570                                                 // look straight down from high above
571                                                 viewangles[PITCH] = 90;
572                                                 camback = 2048;
573                                                 VectorSet(forward, 0, 0, -1);
574                                         }
575
576                                         // trace a little further so it hits a surface more consistently (to avoid 'snapping' on the edge of the range)
577                                         dist = -camback - 8;
578                                         chase_dest[0] = vieworg[0] + forward[0] * dist;
579                                         chase_dest[1] = vieworg[1] + forward[1] * dist;
580                                         chase_dest[2] = vieworg[2] + forward[2] * dist + camup;
581                                         trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_SKY, true, false, NULL, false);
582                                         VectorMAMAM(1, trace.endpos, 8, forward, 4, trace.plane.normal, vieworg);
583                                 }
584                         }
585                         else
586                         {
587                                 // first person view from entity
588                                 // angles
589                                 if (cl.stats[STAT_HEALTH] <= 0 && v_deathtilt.integer)
590                                         viewangles[ROLL] = v_deathtiltangle.value;
591                                 VectorAdd(viewangles, cl.punchangle, viewangles);
592                                 viewangles[ROLL] += V_CalcRoll(cl.viewangles, cl.velocity);
593                                 if (v_dmg_time > 0)
594                                 {
595                                         viewangles[ROLL] += v_dmg_time/v_kicktime.value*v_dmg_roll;
596                                         viewangles[PITCH] += v_dmg_time/v_kicktime.value*v_dmg_pitch;
597                                 }
598                                 // origin
599                                 VectorAdd(vieworg, cl.punchvector, vieworg);
600                                 if (cl.stats[STAT_HEALTH] > 0)
601                                 {
602                                         double xyspeed, bob, bobfall;
603                                         float cycle;
604                                         vec_t frametime;
605
606                                         //frametime = cl.realframetime * cl.movevars_timescale;
607                                         frametime = (cl.time - cl.oldtime) * cl.movevars_timescale;
608                                         
609                                         // 1. if we teleported, clear the frametime... the lowpass will recover the previous value then
610                                         if(!ent->persistent.trail_allowed) // FIXME improve this check
611                                         {
612                                                 // try to fix the first highpass; result is NOT
613                                                 // perfect! TODO find a better fix
614                                                 VectorCopy(viewangles, cl.gunangles_prev);
615                                                 VectorCopy(vieworg, cl.gunorg_prev);
616                                         }
617
618                                         // 2. for the gun origin, only keep the high frequency (non-DC) parts, which is "somewhat like velocity"
619                                         VectorAdd(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
620                                         highpass3_limited(vieworg, frametime*cl_followmodel_side_highpass1.value, cl_followmodel_side_limit.value, frametime*cl_followmodel_side_highpass1.value, cl_followmodel_side_limit.value, frametime*cl_followmodel_up_highpass1.value, cl_followmodel_up_limit.value, cl.gunorg_highpass, gunorg);
621                                         VectorCopy(vieworg, cl.gunorg_prev);
622                                         VectorSubtract(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
623
624                                         // in the highpass, we _store_ the DIFFERENCE to the actual view angles...
625                                         VectorAdd(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
626                                         cl.gunangles_highpass[PITCH] += 360 * floor((viewangles[PITCH] - cl.gunangles_highpass[PITCH]) / 360 + 0.5);
627                                         cl.gunangles_highpass[YAW] += 360 * floor((viewangles[YAW] - cl.gunangles_highpass[YAW]) / 360 + 0.5);
628                                         cl.gunangles_highpass[ROLL] += 360 * floor((viewangles[ROLL] - cl.gunangles_highpass[ROLL]) / 360 + 0.5);
629                                         highpass3_limited(viewangles, frametime*cl_leanmodel_up_highpass1.value, cl_leanmodel_up_limit.value, frametime*cl_leanmodel_side_highpass1.value, cl_leanmodel_side_limit.value, 0, 0, cl.gunangles_highpass, gunangles);
630                                         VectorCopy(viewangles, cl.gunangles_prev);
631                                         VectorSubtract(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
632
633                                         // 3. calculate the RAW adjustment vectors
634                                         gunorg[0] *= (cl_followmodel.value ? -cl_followmodel_side_speed.value : 0);
635                                         gunorg[1] *= (cl_followmodel.value ? -cl_followmodel_side_speed.value : 0);
636                                         gunorg[2] *= (cl_followmodel.value ? -cl_followmodel_up_speed.value : 0);
637
638                                         gunangles[PITCH] *= (cl_leanmodel.value ? -cl_leanmodel_up_speed.value : 0);
639                                         gunangles[YAW] *= (cl_leanmodel.value ? -cl_leanmodel_side_speed.value : 0);
640                                         gunangles[ROLL] = 0;
641
642                                         // 4. perform highpass/lowpass on the adjustment vectors (turning velocity into acceleration!)
643                                         //    trick: we must do the lowpass LAST, so the lowpass vector IS the final vector!
644                                         highpass3(gunorg, frametime*cl_followmodel_side_highpass.value, frametime*cl_followmodel_side_highpass.value, frametime*cl_followmodel_up_highpass.value, cl.gunorg_adjustment_highpass, gunorg);
645                                         lowpass3(gunorg, frametime*cl_followmodel_side_lowpass.value, frametime*cl_followmodel_side_lowpass.value, frametime*cl_followmodel_up_lowpass.value, cl.gunorg_adjustment_lowpass, gunorg);
646                                         // we assume here: PITCH = 0, YAW = 1, ROLL = 2
647                                         highpass3(gunangles, frametime*cl_leanmodel_up_highpass.value, frametime*cl_leanmodel_side_highpass.value, 0, cl.gunangles_adjustment_highpass, gunangles);
648                                         lowpass3(gunangles, frametime*cl_leanmodel_up_lowpass.value, frametime*cl_leanmodel_side_lowpass.value, 0, cl.gunangles_adjustment_lowpass, gunangles);
649
650                                         // 5. use the adjusted vectors
651                                         VectorAdd(vieworg, gunorg, gunorg);
652                                         VectorAdd(viewangles, gunangles, gunangles);
653
654                                         // bounded XY speed, used by several effects below
655                                         xyspeed = bound (0, sqrt(cl.velocity[0]*cl.velocity[0] + cl.velocity[1]*cl.velocity[1]), 400);
656
657                                         // vertical view bobbing code
658                                         if (cl_bob.value && cl_bobcycle.value)
659                                         {
660                                                 // LordHavoc: this code is *weird*, but not replacable (I think it
661                                                 // should be done in QC on the server, but oh well, quake is quake)
662                                                 // LordHavoc: figured out bobup: the time at which the sin is at 180
663                                                 // degrees (which allows lengthening or squishing the peak or valley)
664                                                 cycle = cl.time / cl_bobcycle.value;
665                                                 cycle -= (int) cycle;
666                                                 if (cycle < cl_bobup.value)
667                                                         cycle = sin(M_PI * cycle / cl_bobup.value);
668                                                 else
669                                                         cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
670                                                 // bob is proportional to velocity in the xy plane
671                                                 // (don't count Z, or jumping messes it up)
672                                                 bob = xyspeed * bound(0, cl_bob.value, 0.05);
673                                                 bob = bob*0.3 + bob*0.7*cycle;
674                                                 vieworg[2] += bob;
675                                                 // we also need to adjust gunorg, or this appears like pushing the gun!
676                                                 // In the old code, this was applied to vieworg BEFORE copying to gunorg,
677                                                 // but this is not viable with the new followmodel code as that would mean
678                                                 // that followmodel would work on the munged-by-bob vieworg and do feedback
679                                                 gunorg[2] += bob;
680                                         }
681
682                                         // horizontal view bobbing code
683                                         if (cl_bob2.value && cl_bob2cycle.value)
684                                         {
685                                                 vec3_t bob2vel;
686                                                 vec3_t forward, right, up;
687                                                 float side, front;
688
689                                                 cycle = cl.time / cl_bob2cycle.value;
690                                                 cycle -= (int) cycle;
691                                                 if (cycle < 0.5)
692                                                         cycle = cos(M_PI * cycle / 0.5); // cos looks better here with the other view bobbing using sin
693                                                 else
694                                                         cycle = cos(M_PI + M_PI * (cycle-0.5)/0.5);
695                                                 bob = bound(0, cl_bob2.value, 0.05) * cycle;
696
697                                                 // this value slowly decreases from 1 to 0 when we stop touching the ground.
698                                                 // The cycle is later multiplied with it so the view smooths back to normal
699                                                 if (cl.onground && !cl.cmd.jump) // also block the effect while the jump button is pressed, to avoid twitches when bunny-hopping
700                                                         cl.bob2_smooth = 1;
701                                                 else
702                                                 {
703                                                         if(cl.bob2_smooth > 0)
704                                                                 cl.bob2_smooth -= bound(0, cl_bob2smooth.value, 1);
705                                                         else
706                                                                 cl.bob2_smooth = 0;
707                                                 }
708
709                                                 // calculate the front and side of the player between the X and Y axes
710                                                 AngleVectors(viewangles, forward, right, up);
711                                                 // now get the speed based on those angles. The bounds should match the same value as xyspeed's
712                                                 side = bound(-400, DotProduct (cl.velocity, right) * cl.bob2_smooth, 400);
713                                                 front = bound(-400, DotProduct (cl.velocity, forward) * cl.bob2_smooth, 400);
714                                                 VectorScale(forward, bob, forward);
715                                                 VectorScale(right, bob, right);
716                                                 // we use side with forward and front with right, so the bobbing goes
717                                                 // to the side when we walk forward and to the front when we strafe
718                                                 VectorMAMAM(side, forward, front, right, 0, up, bob2vel);
719                                                 vieworg[0] += bob2vel[0];
720                                                 vieworg[1] += bob2vel[1];
721                                                 // we also need to adjust gunorg, or this appears like pushing the gun!
722                                                 // In the old code, this was applied to vieworg BEFORE copying to gunorg,
723                                                 // but this is not viable with the new followmodel code as that would mean
724                                                 // that followmodel would work on the munged-by-bob vieworg and do feedback
725                                                 gunorg[0] += bob2vel[0];
726                                                 gunorg[1] += bob2vel[1];
727                                         }
728
729                                         // fall bobbing code
730                                         // causes the view to swing down and back up when touching the ground
731                                         if (cl_bobfall.value && cl_bobfallcycle.value)
732                                         {
733                                                 if (!cl.onground)
734                                                 {
735                                                         cl.bobfall_speed = bound(-400, cl.velocity[2], 0) * bound(0, cl_bobfall.value, 0.1);
736                                                         if (cl.velocity[2] < -cl_bobfallminspeed.value)
737                                                                 cl.bobfall_swing = 1;
738                                                         else
739                                                                 cl.bobfall_swing = 0; // TODO really?
740                                                 }
741                                                 else
742                                                 {
743                                                         cl.bobfall_swing = max(0, cl.bobfall_swing - cl_bobfallcycle.value * frametime);
744
745                                                         bobfall = sin(M_PI * cl.bobfall_swing) * cl.bobfall_speed;
746                                                         vieworg[2] += bobfall;
747                                                         gunorg[2] += bobfall;
748                                                 }
749                                         }
750
751                                         // gun model bobbing code
752                                         if (cl_bobmodel.value)
753                                         {
754                                                 // calculate for swinging gun model
755                                                 // the gun bobs when running on the ground, but doesn't bob when you're in the air.
756                                                 // Sajt: I tried to smooth out the transitions between bob and no bob, which works
757                                                 // for the most part, but for some reason when you go through a message trigger or
758                                                 // pick up an item or anything like that it will momentarily jolt the gun.
759                                                 vec3_t forward, right, up;
760                                                 float bspeed;
761                                                 float s;
762                                                 float t;
763
764                                                 s = cl.time * cl_bobmodel_speed.value;
765                                                 if (cl.onground)
766                                                 {
767                                                         if (cl.time - cl.hitgroundtime < 0.2)
768                                                         {
769                                                                 // just hit the ground, speed the bob back up over the next 0.2 seconds
770                                                                 t = cl.time - cl.hitgroundtime;
771                                                                 t = bound(0, t, 0.2);
772                                                                 t *= 5;
773                                                         }
774                                                         else
775                                                                 t = 1;
776                                                 }
777                                                 else
778                                                 {
779                                                         // recently left the ground, slow the bob down over the next 0.2 seconds
780                                                         t = cl.time - cl.lastongroundtime;
781                                                         t = 0.2 - bound(0, t, 0.2);
782                                                         t *= 5;
783                                                 }
784
785                                                 bspeed = xyspeed * 0.01f;
786                                                 AngleVectors (gunangles, forward, right, up);
787                                                 bob = bspeed * cl_bobmodel_side.value * cl_viewmodel_scale.value * sin (s) * t;
788                                                 VectorMA (gunorg, bob, right, gunorg);
789                                                 bob = bspeed * cl_bobmodel_up.value * cl_viewmodel_scale.value * cos (s * 2) * t;
790                                                 VectorMA (gunorg, bob, up, gunorg);
791                                         }
792                                 }
793                         }
794                         // calculate a view matrix for rendering the scene
795                         if (v_idlescale.value)
796                                 Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, vieworg[0], vieworg[1], vieworg[2], viewangles[0] + v_idlescale.value * sin(cl.time*v_ipitch_cycle.value) * v_ipitch_level.value, viewangles[1] + v_idlescale.value * sin(cl.time*v_iyaw_cycle.value) * v_iyaw_level.value, viewangles[2] + v_idlescale.value * sin(cl.time*v_iroll_cycle.value) * v_iroll_level.value, 1);
797                         else
798                                 Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, vieworg[0], vieworg[1], vieworg[2], viewangles[0], viewangles[1], viewangles[2], 1);
799                         // calculate a viewmodel matrix for use in view-attached entities
800                         Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix, gunorg[0], gunorg[1], gunorg[2], gunangles[0], gunangles[1], gunangles[2], cl_viewmodel_scale.value);
801                         VectorCopy(vieworg, cl.csqc_origin);
802                         VectorCopy(viewangles, cl.csqc_angles);
803                 }
804         }
805 }
806
807 void V_FadeViewFlashs(void)
808 {
809         // don't flash if time steps backwards
810         if (cl.time <= cl.oldtime)
811                 return;
812         // drop the damage value
813         cl.cshifts[CSHIFT_DAMAGE].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_DAMAGE].alphafade;
814         if (cl.cshifts[CSHIFT_DAMAGE].percent <= 0)
815                 cl.cshifts[CSHIFT_DAMAGE].percent = 0;
816         // drop the bonus value
817         cl.cshifts[CSHIFT_BONUS].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_BONUS].alphafade;
818         if (cl.cshifts[CSHIFT_BONUS].percent <= 0)
819                 cl.cshifts[CSHIFT_BONUS].percent = 0;
820 }
821
822 void V_CalcViewBlend(void)
823 {
824         float a2;
825         int j;
826         r_refdef.viewblend[0] = 0;
827         r_refdef.viewblend[1] = 0;
828         r_refdef.viewblend[2] = 0;
829         r_refdef.viewblend[3] = 0;
830         r_refdef.frustumscale_x = 1;
831         r_refdef.frustumscale_y = 1;
832         if (cls.state == ca_connected && cls.signon == SIGNONS)
833         {
834                 // set contents color
835                 int supercontents;
836                 vec3_t vieworigin;
837                 Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, vieworigin);
838                 supercontents = CL_PointSuperContents(vieworigin);
839                 if (supercontents & SUPERCONTENTS_LIQUIDSMASK)
840                 {
841                         r_refdef.frustumscale_x *= 1 - (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value);
842                         r_refdef.frustumscale_y *= 1 - (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value);
843                         if (supercontents & SUPERCONTENTS_LAVA)
844                         {
845                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 255;
846                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
847                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
848                         }
849                         else if (supercontents & SUPERCONTENTS_SLIME)
850                         {
851                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
852                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 25;
853                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 5;
854                         }
855                         else
856                         {
857                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 130;
858                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
859                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 50;
860                         }
861                         cl.cshifts[CSHIFT_CONTENTS].percent = 150 * 0.5;
862                 }
863                 else
864                 {
865                         cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
866                         cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 0;
867                         cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
868                         cl.cshifts[CSHIFT_CONTENTS].percent = 0;
869                 }
870
871                 if (gamemode != GAME_TRANSFUSION)
872                 {
873                         if (cl.stats[STAT_ITEMS] & IT_QUAD)
874                         {
875                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
876                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 0;
877                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 255;
878                                 cl.cshifts[CSHIFT_POWERUP].percent = 30;
879                         }
880                         else if (cl.stats[STAT_ITEMS] & IT_SUIT)
881                         {
882                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
883                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
884                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
885                                 cl.cshifts[CSHIFT_POWERUP].percent = 20;
886                         }
887                         else if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
888                         {
889                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 100;
890                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 100;
891                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 100;
892                                 cl.cshifts[CSHIFT_POWERUP].percent = 100;
893                         }
894                         else if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)
895                         {
896                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 255;
897                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
898                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
899                                 cl.cshifts[CSHIFT_POWERUP].percent = 30;
900                         }
901                         else
902                                 cl.cshifts[CSHIFT_POWERUP].percent = 0;
903                 }
904
905                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[0] = v_cshift.destcolor[0];
906                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[1] = v_cshift.destcolor[1];
907                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[2] = v_cshift.destcolor[2];
908                 cl.cshifts[CSHIFT_VCSHIFT].percent = v_cshift.percent;
909
910                 // LordHavoc: fixed V_CalcBlend
911                 for (j = 0;j < NUM_CSHIFTS;j++)
912                 {
913                         a2 = bound(0.0f, cl.cshifts[j].percent * (1.0f / 255.0f), 1.0f);
914                         if (a2 > 0)
915                         {
916                                 VectorLerp(r_refdef.viewblend, a2, cl.cshifts[j].destcolor, r_refdef.viewblend);
917                                 r_refdef.viewblend[3] = (1 - (1 - r_refdef.viewblend[3]) * (1 - a2)); // correct alpha multiply...  took a while to find it on the web
918                         }
919                 }
920                 // saturate color (to avoid blending in black)
921                 if (r_refdef.viewblend[3])
922                 {
923                         a2 = 1 / r_refdef.viewblend[3];
924                         VectorScale(r_refdef.viewblend, a2, r_refdef.viewblend);
925                 }
926                 r_refdef.viewblend[0] = bound(0.0f, r_refdef.viewblend[0] * (1.0f/255.0f), 1.0f);
927                 r_refdef.viewblend[1] = bound(0.0f, r_refdef.viewblend[1] * (1.0f/255.0f), 1.0f);
928                 r_refdef.viewblend[2] = bound(0.0f, r_refdef.viewblend[2] * (1.0f/255.0f), 1.0f);
929                 r_refdef.viewblend[3] = bound(0.0f, r_refdef.viewblend[3] * gl_polyblend.value, 1.0f);
930                 
931                 // Samual: Ugly hack, I know. But it's the best we can do since
932                 // there is no way to detect client states from the engine.
933                 if (cl.stats[STAT_HEALTH] <= 0 && cl.stats[STAT_HEALTH] != -666 && 
934                         cl.stats[STAT_HEALTH] != -2342 && cl_deathfade.value > 0)
935                 {
936                         cl.deathfade += cl_deathfade.value * max(0.00001, cl.time - cl.oldtime);
937                         cl.deathfade = bound(0.0f, cl.deathfade, 0.9f);
938                 }
939                 else
940                         cl.deathfade = 0.0f;
941
942                 if(cl.deathfade > 0)
943                 {
944                         float a;
945                         float deathfadevec[3] = {0.3f, 0.0f, 0.0f};
946                         a = r_refdef.viewblend[3] + cl.deathfade - r_refdef.viewblend[3]*cl.deathfade;
947                         if(a > 0)
948                                 VectorMAM(r_refdef.viewblend[3] * (1 - cl.deathfade) / a, r_refdef.viewblend, cl.deathfade / a, deathfadevec, r_refdef.viewblend);
949                         r_refdef.viewblend[3] = a;
950                 }
951         }
952 }
953
954 //============================================================================
955
956 /*
957 =============
958 V_Init
959 =============
960 */
961 void V_Init (void)
962 {
963         Cmd_AddCommand ("v_cshift", V_cshift_f, "sets tint color of view");
964         Cmd_AddCommand ("bf", V_BonusFlash_f, "briefly flashes a bright color tint on view (used when items are picked up); optionally takes R G B [A [alphafade]] arguments to specify how the flash looks");
965         Cmd_AddCommand ("centerview", V_StartPitchDrift, "gradually recenter view (stop looking up/down)");
966
967         Cvar_RegisterVariable (&v_centermove);
968         Cvar_RegisterVariable (&v_centerspeed);
969
970         Cvar_RegisterVariable (&v_iyaw_cycle);
971         Cvar_RegisterVariable (&v_iroll_cycle);
972         Cvar_RegisterVariable (&v_ipitch_cycle);
973         Cvar_RegisterVariable (&v_iyaw_level);
974         Cvar_RegisterVariable (&v_iroll_level);
975         Cvar_RegisterVariable (&v_ipitch_level);
976
977         Cvar_RegisterVariable (&v_idlescale);
978         Cvar_RegisterVariable (&crosshair);
979
980         Cvar_RegisterVariable (&cl_rollspeed);
981         Cvar_RegisterVariable (&cl_rollangle);
982         Cvar_RegisterVariable (&cl_bob);
983         Cvar_RegisterVariable (&cl_bobcycle);
984         Cvar_RegisterVariable (&cl_bobup);
985         Cvar_RegisterVariable (&cl_bob2);
986         Cvar_RegisterVariable (&cl_bob2cycle);
987         Cvar_RegisterVariable (&cl_bob2smooth);
988         Cvar_RegisterVariable (&cl_bobfall);
989         Cvar_RegisterVariable (&cl_bobfallcycle);
990         Cvar_RegisterVariable (&cl_bobfallminspeed);
991         Cvar_RegisterVariable (&cl_bobmodel);
992         Cvar_RegisterVariable (&cl_bobmodel_side);
993         Cvar_RegisterVariable (&cl_bobmodel_up);
994         Cvar_RegisterVariable (&cl_bobmodel_speed);
995
996         Cvar_RegisterVariable (&cl_leanmodel);
997         Cvar_RegisterVariable (&cl_leanmodel_side_speed);
998         Cvar_RegisterVariable (&cl_leanmodel_side_limit);
999         Cvar_RegisterVariable (&cl_leanmodel_side_highpass1);
1000         Cvar_RegisterVariable (&cl_leanmodel_side_lowpass);
1001         Cvar_RegisterVariable (&cl_leanmodel_side_highpass);
1002         Cvar_RegisterVariable (&cl_leanmodel_up_speed);
1003         Cvar_RegisterVariable (&cl_leanmodel_up_limit);
1004         Cvar_RegisterVariable (&cl_leanmodel_up_highpass1);
1005         Cvar_RegisterVariable (&cl_leanmodel_up_lowpass);
1006         Cvar_RegisterVariable (&cl_leanmodel_up_highpass);
1007
1008         Cvar_RegisterVariable (&cl_followmodel);
1009         Cvar_RegisterVariable (&cl_followmodel_side_speed);
1010         Cvar_RegisterVariable (&cl_followmodel_side_limit);
1011         Cvar_RegisterVariable (&cl_followmodel_side_highpass1);
1012         Cvar_RegisterVariable (&cl_followmodel_side_lowpass);
1013         Cvar_RegisterVariable (&cl_followmodel_side_highpass);
1014         Cvar_RegisterVariable (&cl_followmodel_up_speed);
1015         Cvar_RegisterVariable (&cl_followmodel_up_limit);
1016         Cvar_RegisterVariable (&cl_followmodel_up_highpass1);
1017         Cvar_RegisterVariable (&cl_followmodel_up_lowpass);
1018         Cvar_RegisterVariable (&cl_followmodel_up_highpass);
1019
1020         Cvar_RegisterVariable (&cl_viewmodel_scale);
1021
1022         Cvar_RegisterVariable (&v_kicktime);
1023         Cvar_RegisterVariable (&v_kickroll);
1024         Cvar_RegisterVariable (&v_kickpitch);
1025
1026         Cvar_RegisterVariable (&cl_stairsmoothspeed);
1027         
1028         Cvar_RegisterVariable (&cl_smoothviewheight);
1029
1030         Cvar_RegisterVariable (&chase_back);
1031         Cvar_RegisterVariable (&chase_up);
1032         Cvar_RegisterVariable (&chase_active);
1033         Cvar_RegisterVariable (&chase_overhead);
1034         Cvar_RegisterVariable (&chase_pitchangle);
1035         if (gamemode == GAME_GOODVSBAD2)
1036                 Cvar_RegisterVariable (&chase_stevie);
1037
1038         Cvar_RegisterVariable (&v_deathtilt);
1039         Cvar_RegisterVariable (&v_deathtiltangle);
1040 }
1041