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