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", "1", "enables gun leaning"};
  49 cvar_t cl_leanmodel_side_speed = {CVAR_SAVE, "cl_leanmodel_side_speed", "1", "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", "5", "gun leaning sideways pre-highpass in 1/s"};
  52 cvar_t cl_leanmodel_side_highpass = {CVAR_SAVE, "cl_leanmodel_side_highpass", "15", "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", "1", "gun leaning upward speed"};
  55 cvar_t cl_leanmodel_up_limit = {CVAR_SAVE, "cl_leanmodel_up_limit", "25", "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", "1", "enables gun following"};
  61 cvar_t cl_followmodel_side_speed = {CVAR_SAVE, "cl_followmodel_side_speed", "1", "gun following sideways speed"};
  62 cvar_t cl_followmodel_side_limit = {CVAR_SAVE, "cl_followmodel_side_limit", "4", "gun following sideways limit"};
  63 cvar_t cl_followmodel_side_highpass1 = {CVAR_SAVE, "cl_followmodel_side_highpass1", "5", "gun following sideways pre-highpass in 1/s"};
  64 cvar_t cl_followmodel_side_highpass = {CVAR_SAVE, "cl_followmodel_side_highpass", "15", "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", "1", "gun following upward speed"};
  67 cvar_t cl_followmodel_up_limit = {CVAR_SAVE, "cl_followmodel_up_limit", "2", "gun following upward limit"};
  68 cvar_t cl_followmodel_up_highpass1 = {CVAR_SAVE, "cl_followmodel_up_highpass1", "5", "gun following upward pre-highpass in 1/s"};
  69 cvar_t cl_followmodel_up_highpass = {CVAR_SAVE, "cl_followmodel_up_highpass", "15", "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)
 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.movement_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(cl.viewangles, cl.gunangles_highpass);
 600                                                 VectorCopy(cl.movement_origin, cl.gunorg_highpass);
 601                                                 // prevent further CHANGES caused by the high/lowpasses
 602                                                 // - a highpass will return the diff, a lowpass will
 603                                                 // return the saved value; note: the first diff will be 0!
 604                                                 frametime = 0;
 605                                         }
 606
 607                                         // 2. for the gun origin, only keep the high frequency (non-DC) parts, which is "somewhat like velocity"
 608                                         highpass3_limited(cl.movement_origin, 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);
 609                                         cl.gunangles_highpass[PITCH] += 360 * floor((cl.viewangles[PITCH] - cl.gunangles_highpass[PITCH]) / 360 + 0.5);
 610                                         cl.gunangles_highpass[YAW] += 360 * floor((cl.viewangles[YAW] - cl.gunangles_highpass[YAW]) / 360 + 0.5);
 611                                         cl.gunangles_highpass[ROLL] += 360 * floor((cl.viewangles[ROLL] - cl.gunangles_highpass[ROLL]) / 360 + 0.5);
 612                                         highpass3_limited(cl.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);
 613
 614                                         // 3. calculate the RAW adjustment vectors
 615                                         gunorg[0] *= (cl_followmodel.value ? -cl_followmodel_side_speed.value : 0);
 616                                         gunorg[1] *= (cl_followmodel.value ? -cl_followmodel_side_speed.value : 0);
 617                                         gunorg[2] *= (cl_followmodel.value ? -cl_followmodel_up_speed.value : 0);
 618
 619                                         gunangles[PITCH] *= (cl_leanmodel.value ? -cl_leanmodel_up_speed.value : 0);
 620                                         gunangles[YAW] *= (cl_leanmodel.value ? -cl_leanmodel_side_speed.value : 0);
 621                                         gunangles[ROLL] = 0;
 622
 623                                         // 4. perform highpass/lowpass on the adjustment vectors (turning velocity into acceleration!)
 624                                         //    trick: we must do the lowpass LAST, so the lowpass vector IS the final vector!
 625                                         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);
 626                                         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);
 627                                         // we assume here: PITCH = 0, YAW = 1, ROLL = 2
 628                                         highpass3(gunangles, frametime*cl_leanmodel_up_highpass.value, frametime*cl_leanmodel_side_highpass.value, 0, cl.gunangles_adjustment_highpass, gunangles);
 629                                         lowpass3(gunangles, frametime*cl_leanmodel_up_lowpass.value, frametime*cl_leanmodel_side_lowpass.value, 0, cl.gunangles_adjustment_lowpass, gunangles);
 630
 631                                         // 5. use the adjusted vectors
 632                                         VectorAdd(vieworg, gunorg, gunorg);
 633                                         VectorAdd(cl.viewangles, gunangles, gunangles);
 634
 635                                         // view bobbing code
 636                                         xyspeed = sqrt(cl.movement_velocity[0]*cl.movement_velocity[0] + cl.movement_velocity[1]*cl.movement_velocity[1]);
 637                                         if (cl_bob.value && cl_bobcycle.value)
 638                                         {
 639                                                 float cycle;
 640                                                 // LordHavoc: this code is *weird*, but not replacable (I think it
 641                                                 // should be done in QC on the server, but oh well, quake is quake)
 642                                                 // LordHavoc: figured out bobup: the time at which the sin is at 180
 643                                                 // degrees (which allows lengthening or squishing the peak or valley)
 644                                                 cycle = cl.time / cl_bobcycle.value;
 645                                                 cycle -= (int) cycle;
 646                                                 if (cycle < cl_bobup.value)
 647                                                         cycle = sin(M_PI * cycle / cl_bobup.value);
 648                                                 else
 649                                                         cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
 650                                                 // bob is proportional to velocity in the xy plane
 651                                                 // (don't count Z, or jumping messes it up)
 652                                                 bob = xyspeed * cl_bob.value;
 653                                                 bob = bob*0.3 + bob*0.7*cycle;
 654                                                 vieworg[2] += bound(-7, bob, 4);
 655                                                 // we also need to adjust gunorg, or this appears like pushing the gun!
 656                                                 // In the old code, this was applied to vieworg BEFORE copying to gunorg,
 657                                                 // but this is not viable with the new followmodel code as that would mean
 658                                                 // that followmodel would work on the munged-by-bob vieworg and do feedback
 659                                                 gunorg[2] += bound(-7, bob, 4);
 660                                         }
 661
 662                                         // gun model bobbing code
 663                                         if (cl_bob.value && cl_bobmodel.value)
 664                                         {
 665                                                 // calculate for swinging gun model
 666                                                 // the gun bobs when running on the ground, but doesn't bob when you're in the air.
 667                                                 // Sajt: I tried to smooth out the transitions between bob and no bob, which works
 668                                                 // for the most part, but for some reason when you go through a message trigger or
 669                                                 // pick up an item or anything like that it will momentarily jolt the gun.
 670                                                 vec3_t forward, right, up;
 671                                                 float bspeed;
 672                                                 float s;
 673                                                 float t;
 674
 675                                                 s = cl.time * cl_bobmodel_speed.value;
 676                                                 if (cl.onground)
 677                                                 {
 678                                                         if (cl.time - cl.hitgroundtime < 0.2)
 679                                                         {
 680                                                                 // just hit the ground, speed the bob back up over the next 0.2 seconds
 681                                                                 t = cl.time - cl.hitgroundtime;
 682                                                                 t = bound(0, t, 0.2);
 683                                                                 t *= 5;
 684                                                         }
 685                                                         else
 686                                                                 t = 1;
 687                                                 }
 688                                                 else
 689                                                 {
 690                                                         // recently left the ground, slow the bob down over the next 0.2 seconds
 691                                                         t = cl.time - cl.lastongroundtime;
 692                                                         t = 0.2 - bound(0, t, 0.2);
 693                                                         t *= 5;
 694                                                 }
 695
 696                                                 bspeed = bound (0, xyspeed, 400) * 0.01f;
 697                                                 AngleVectors (gunangles, forward, right, up);
 698                                                 bob = bspeed * cl_bobmodel_side.value * cl_viewmodel_scale.value * sin (s) * t;
 699                                                 VectorMA (gunorg, bob, right, gunorg);
 700                                                 bob = bspeed * cl_bobmodel_up.value * cl_viewmodel_scale.value * cos (s * 2) * t;
 701                                                 VectorMA (gunorg, bob, up, gunorg);
 702                                         }
 703                                 }
 704                         }
 705                         // calculate a view matrix for rendering the scene
 706                         if (v_idlescale.value)
 707                                 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);
 708                         else
 709                                 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);
 710                         // calculate a viewmodel matrix for use in view-attached entities
 711                         Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix, gunorg[0], gunorg[1], gunorg[2], gunangles[0], gunangles[1], gunangles[2], cl_viewmodel_scale.value);
 712                         VectorCopy(vieworg, cl.csqc_origin);
 713                         VectorCopy(viewangles, cl.csqc_angles);
 714                 }
 715         }
 716 }
 717
 718 void V_FadeViewFlashs(void)
 719 {
 720         // don't flash if time steps backwards
 721         if (cl.time <= cl.oldtime)
 722                 return;
 723         // drop the damage value
 724         cl.cshifts[CSHIFT_DAMAGE].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_DAMAGE].alphafade;
 725         if (cl.cshifts[CSHIFT_DAMAGE].percent <= 0)
 726                 cl.cshifts[CSHIFT_DAMAGE].percent = 0;
 727         // drop the bonus value
 728         cl.cshifts[CSHIFT_BONUS].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_BONUS].alphafade;
 729         if (cl.cshifts[CSHIFT_BONUS].percent <= 0)
 730                 cl.cshifts[CSHIFT_BONUS].percent = 0;
 731 }
 732
 733 void V_CalcViewBlend(void)
 734 {
 735         float a2;
 736         int j;
 737         r_refdef.viewblend[0] = 0;
 738         r_refdef.viewblend[1] = 0;
 739         r_refdef.viewblend[2] = 0;
 740         r_refdef.viewblend[3] = 0;
 741         r_refdef.frustumscale_x = 1;
 742         r_refdef.frustumscale_y = 1;
 743         if (cls.state == ca_connected && cls.signon == SIGNONS)
 744         {
 745                 // set contents color
 746                 int supercontents;
 747                 vec3_t vieworigin;
 748                 Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, vieworigin);
 749                 supercontents = CL_PointSuperContents(vieworigin);
 750                 if (supercontents & SUPERCONTENTS_LIQUIDSMASK)
 751                 {
 752                         r_refdef.frustumscale_x *= 1 - (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value);
 753                         r_refdef.frustumscale_y *= 1 - (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value);
 754                         if (supercontents & SUPERCONTENTS_LAVA)
 755                         {
 756                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 255;
 757                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
 758                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
 759                         }
 760                         else if (supercontents & SUPERCONTENTS_SLIME)
 761                         {
 762                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
 763                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 25;
 764                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 5;
 765                         }
 766                         else
 767                         {
 768                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 130;
 769                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
 770                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 50;
 771                         }
 772                         cl.cshifts[CSHIFT_CONTENTS].percent = 150 * 0.5;
 773                 }
 774                 else
 775                 {
 776                         cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
 777                         cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 0;
 778                         cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
 779                         cl.cshifts[CSHIFT_CONTENTS].percent = 0;
 780                 }
 781
 782                 if (gamemode != GAME_TRANSFUSION)
 783                 {
 784                         if (cl.stats[STAT_ITEMS] & IT_QUAD)
 785                         {
 786                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
 787                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 0;
 788                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 255;
 789                                 cl.cshifts[CSHIFT_POWERUP].percent = 30;
 790                         }
 791                         else if (cl.stats[STAT_ITEMS] & IT_SUIT)
 792                         {
 793                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
 794                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
 795                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
 796                                 cl.cshifts[CSHIFT_POWERUP].percent = 20;
 797                         }
 798                         else if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
 799                         {
 800                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 100;
 801                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 100;
 802                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 100;
 803                                 cl.cshifts[CSHIFT_POWERUP].percent = 100;
 804                         }
 805                         else if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)
 806                         {
 807                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 255;
 808                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
 809                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
 810                                 cl.cshifts[CSHIFT_POWERUP].percent = 30;
 811                         }
 812                         else
 813                                 cl.cshifts[CSHIFT_POWERUP].percent = 0;
 814                 }
 815
 816                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[0] = v_cshift.destcolor[0];
 817                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[1] = v_cshift.destcolor[1];
 818                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[2] = v_cshift.destcolor[2];
 819                 cl.cshifts[CSHIFT_VCSHIFT].percent = v_cshift.percent;
 820
 821                 // LordHavoc: fixed V_CalcBlend
 822                 for (j = 0;j < NUM_CSHIFTS;j++)
 823                 {
 824                         a2 = bound(0.0f, cl.cshifts[j].percent * (1.0f / 255.0f), 1.0f);
 825                         if (a2 > 0)
 826                         {
 827                                 VectorLerp(r_refdef.viewblend, a2, cl.cshifts[j].destcolor, r_refdef.viewblend);
 828                                 r_refdef.viewblend[3] = (1 - (1 - r_refdef.viewblend[3]) * (1 - a2)); // correct alpha multiply...  took a while to find it on the web
 829                         }
 830                 }
 831                 // saturate color (to avoid blending in black)
 832                 if (r_refdef.viewblend[3])
 833                 {
 834                         a2 = 1 / r_refdef.viewblend[3];
 835                         VectorScale(r_refdef.viewblend, a2, r_refdef.viewblend);
 836                 }
 837                 r_refdef.viewblend[0] = bound(0.0f, r_refdef.viewblend[0] * (1.0f/255.0f), 1.0f);
 838                 r_refdef.viewblend[1] = bound(0.0f, r_refdef.viewblend[1] * (1.0f/255.0f), 1.0f);
 839                 r_refdef.viewblend[2] = bound(0.0f, r_refdef.viewblend[2] * (1.0f/255.0f), 1.0f);
 840                 r_refdef.viewblend[3] = bound(0.0f, r_refdef.viewblend[3] * gl_polyblend.value, 1.0f);
 841
 842                 // Samual: Ugly hack, I know. But it's the best we can do since
 843                 // there is no way to detect client states from the engine.
 844                 if (cl.stats[STAT_HEALTH] <= 0 && cl.stats[STAT_HEALTH] != -666 &&
 845                         cl.stats[STAT_HEALTH] != -2342 && cl_deathfade.value > 0)
 846                 {
 847                         cl.deathfade += cl_deathfade.value * max(0.00001, cl.time - cl.oldtime);
 848                         cl.deathfade = bound(0.0f, cl.deathfade, 0.9f);
 849                 }
 850                 else
 851                         cl.deathfade = 0.0f;
 852
 853                 if(cl.deathfade > 0)
 854                 {
 855                         float a;
 856                         float deathfadevec[3] = {0.3f, 0.0f, 0.0f};
 857                         a = r_refdef.viewblend[3] + cl.deathfade - r_refdef.viewblend[3]*cl.deathfade;
 858                         if(a > 0)
 859                                 VectorMAM(r_refdef.viewblend[3] * (1 - cl.deathfade) / a, r_refdef.viewblend, cl.deathfade / a, deathfadevec, r_refdef.viewblend);
 860                         r_refdef.viewblend[3] = a;
 861                 }
 862         }
 863 }
 864
 865 //============================================================================
 866
 867 /*
 868 =============
 869 V_Init
 870 =============
 871 */
 872 void V_Init (void)
 873 {
 874         Cmd_AddCommand ("v_cshift", V_cshift_f, "sets tint color of view");
 875         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");
 876         Cmd_AddCommand ("centerview", V_StartPitchDrift, "gradually recenter view (stop looking up/down)");
 877
 878         Cvar_RegisterVariable (&v_centermove);
 879         Cvar_RegisterVariable (&v_centerspeed);
 880
 881         Cvar_RegisterVariable (&v_iyaw_cycle);
 882         Cvar_RegisterVariable (&v_iroll_cycle);
 883         Cvar_RegisterVariable (&v_ipitch_cycle);
 884         Cvar_RegisterVariable (&v_iyaw_level);
 885         Cvar_RegisterVariable (&v_iroll_level);
 886         Cvar_RegisterVariable (&v_ipitch_level);
 887
 888         Cvar_RegisterVariable (&v_idlescale);
 889         Cvar_RegisterVariable (&crosshair);
 890
 891         Cvar_RegisterVariable (&cl_rollspeed);
 892         Cvar_RegisterVariable (&cl_rollangle);
 893         Cvar_RegisterVariable (&cl_bob);
 894         Cvar_RegisterVariable (&cl_bobcycle);
 895         Cvar_RegisterVariable (&cl_bobup);
 896         Cvar_RegisterVariable (&cl_bobmodel);
 897         Cvar_RegisterVariable (&cl_bobmodel_side);
 898         Cvar_RegisterVariable (&cl_bobmodel_up);
 899         Cvar_RegisterVariable (&cl_bobmodel_speed);
 900
 901         Cvar_RegisterVariable (&cl_leanmodel);
 902         Cvar_RegisterVariable (&cl_leanmodel_side_speed);
 903         Cvar_RegisterVariable (&cl_leanmodel_side_limit);
 904         Cvar_RegisterVariable (&cl_leanmodel_side_highpass1);
 905         Cvar_RegisterVariable (&cl_leanmodel_side_lowpass);
 906         Cvar_RegisterVariable (&cl_leanmodel_side_highpass);
 907         Cvar_RegisterVariable (&cl_leanmodel_up_speed);
 908         Cvar_RegisterVariable (&cl_leanmodel_up_limit);
 909         Cvar_RegisterVariable (&cl_leanmodel_up_highpass1);
 910         Cvar_RegisterVariable (&cl_leanmodel_up_lowpass);
 911         Cvar_RegisterVariable (&cl_leanmodel_up_highpass);
 912
 913         Cvar_RegisterVariable (&cl_followmodel);
 914         Cvar_RegisterVariable (&cl_followmodel_side_speed);
 915         Cvar_RegisterVariable (&cl_followmodel_side_limit);
 916         Cvar_RegisterVariable (&cl_followmodel_side_highpass1);
 917         Cvar_RegisterVariable (&cl_followmodel_side_lowpass);
 918         Cvar_RegisterVariable (&cl_followmodel_side_highpass);
 919         Cvar_RegisterVariable (&cl_followmodel_up_speed);
 920         Cvar_RegisterVariable (&cl_followmodel_up_limit);
 921         Cvar_RegisterVariable (&cl_followmodel_up_highpass1);
 922         Cvar_RegisterVariable (&cl_followmodel_up_lowpass);
 923         Cvar_RegisterVariable (&cl_followmodel_up_highpass);
 924
 925         Cvar_RegisterVariable (&cl_viewmodel_scale);
 926
 927         Cvar_RegisterVariable (&v_kicktime);
 928         Cvar_RegisterVariable (&v_kickroll);
 929         Cvar_RegisterVariable (&v_kickpitch);
 930
 931         Cvar_RegisterVariable (&cl_stairsmoothspeed);
 932
 933         Cvar_RegisterVariable (&chase_back);
 934         Cvar_RegisterVariable (&chase_up);
 935         Cvar_RegisterVariable (&chase_active);
 936         Cvar_RegisterVariable (&chase_overhead);
 937         Cvar_RegisterVariable (&chase_pitchangle);
 938         if (gamemode == GAME_GOODVSBAD2)
 939                 Cvar_RegisterVariable (&chase_stevie);
 940
 941         Cvar_RegisterVariable (&v_deathtilt);
 942         Cvar_RegisterVariable (&v_deathtiltangle);
 943 }
 944