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