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