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 #include "image.h"
  25
  26 /*
  27
  28 The view is allowed to move slightly from it's true position for bobbing,
  29 but if it exceeds 8 pixels linear distance (spherical, not box), the list of
  30 entities sent from the server may not include everything in the pvs, especially
  31 when crossing a water boudnary.
  32
  33 */
  34
  35 cvar_t cl_rollspeed = {CVAR_CLIENT, "cl_rollspeed", "200", "how much strafing is necessary to tilt the view"};
  36 cvar_t cl_rollangle = {CVAR_CLIENT, "cl_rollangle", "2.0", "how much to tilt the view when strafing"};
  37
  38 cvar_t cl_bob = {CVAR_CLIENT | CVAR_SAVE, "cl_bob","0.02", "view bobbing amount"};
  39 cvar_t cl_bobcycle = {CVAR_CLIENT | CVAR_SAVE, "cl_bobcycle","0.6", "view bobbing speed"};
  40 cvar_t cl_bobup = {CVAR_CLIENT | CVAR_SAVE, "cl_bobup","0.5", "view bobbing adjustment that makes the up or down swing of the bob last longer"};
  41 cvar_t cl_bob2 = {CVAR_CLIENT | CVAR_SAVE, "cl_bob2","0", "sideways view bobbing amount"};
  42 cvar_t cl_bob2cycle = {CVAR_CLIENT | CVAR_SAVE, "cl_bob2cycle","0.6", "sideways view bobbing speed"};
  43 cvar_t cl_bob2smooth = {CVAR_CLIENT | CVAR_SAVE, "cl_bob2smooth","0.05", "how fast the view goes back when you stop touching the ground"};
  44 cvar_t cl_bobfall = {CVAR_CLIENT | CVAR_SAVE, "cl_bobfall","0", "how much the view swings down when falling (influenced by the speed you hit the ground with)"};
  45 cvar_t cl_bobfallcycle = {CVAR_CLIENT | CVAR_SAVE, "cl_bobfallcycle","3", "speed of the bobfall swing"};
  46 cvar_t cl_bobfallminspeed = {CVAR_CLIENT | CVAR_SAVE, "cl_bobfallminspeed","200", "necessary amount of speed for bob-falling to occur"};
  47 cvar_t cl_bobmodel = {CVAR_CLIENT | CVAR_SAVE, "cl_bobmodel", "1", "enables gun bobbing"};
  48 cvar_t cl_bobmodel_side = {CVAR_CLIENT | CVAR_SAVE, "cl_bobmodel_side", "0.15", "gun bobbing sideways sway amount"};
  49 cvar_t cl_bobmodel_up = {CVAR_CLIENT | CVAR_SAVE, "cl_bobmodel_up", "0.06", "gun bobbing upward movement amount"};
  50 cvar_t cl_bobmodel_speed = {CVAR_CLIENT | CVAR_SAVE, "cl_bobmodel_speed", "7", "gun bobbing speed"};
  51 cvar_t cl_bob_limit = {CVAR_CLIENT | CVAR_SAVE, "cl_bob_limit", "7", "limits bobbing to this much distance from view_ofs"};
  52 cvar_t cl_bob_limit_heightcheck = {CVAR_CLIENT | CVAR_SAVE, "cl_bob_limit_heightcheck", "0", "check ceiling and floor height against cl_bob_limit and scale down all view bobbing if could result in camera being in solid"};
  53 cvar_t cl_bob_limit_heightcheck_dontcrosswatersurface = {CVAR_CLIENT | CVAR_SAVE, "cl_bob_limit_heightcheck_dontcrosswatersurface", "1", "limit cl_bob_limit to not crossing liquid surfaces also"};
  54 cvar_t cl_bob_velocity_limit = {CVAR_CLIENT | CVAR_SAVE, "cl_bob_velocity_limit", "400", "limits the xyspeed value in the bobbing code"};
  55
  56 cvar_t cl_leanmodel = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel", "0", "enables gun leaning"};
  57 cvar_t cl_leanmodel_side_speed = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_side_speed", "0.7", "gun leaning sideways speed"};
  58 cvar_t cl_leanmodel_side_limit = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_side_limit", "35", "gun leaning sideways limit"};
  59 cvar_t cl_leanmodel_side_highpass1 = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_side_highpass1", "30", "gun leaning sideways pre-highpass in 1/s"};
  60 cvar_t cl_leanmodel_side_highpass = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_side_highpass", "3", "gun leaning sideways highpass in 1/s"};
  61 cvar_t cl_leanmodel_side_lowpass = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_side_lowpass", "20", "gun leaning sideways lowpass in 1/s"};
  62 cvar_t cl_leanmodel_up_speed = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_up_speed", "0.65", "gun leaning upward speed"};
  63 cvar_t cl_leanmodel_up_limit = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_up_limit", "50", "gun leaning upward limit"};
  64 cvar_t cl_leanmodel_up_highpass1 = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_up_highpass1", "5", "gun leaning upward pre-highpass in 1/s"};
  65 cvar_t cl_leanmodel_up_highpass = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_up_highpass", "15", "gun leaning upward highpass in 1/s"};
  66 cvar_t cl_leanmodel_up_lowpass = {CVAR_CLIENT | CVAR_SAVE, "cl_leanmodel_up_lowpass", "20", "gun leaning upward lowpass in 1/s"};
  67
  68 cvar_t cl_followmodel = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel", "0", "enables gun following"};
  69 cvar_t cl_followmodel_side_speed = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_side_speed", "0.25", "gun following sideways speed"};
  70 cvar_t cl_followmodel_side_limit = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_side_limit", "6", "gun following sideways limit"};
  71 cvar_t cl_followmodel_side_highpass1 = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_side_highpass1", "30", "gun following sideways pre-highpass in 1/s"};
  72 cvar_t cl_followmodel_side_highpass = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_side_highpass", "5", "gun following sideways highpass in 1/s"};
  73 cvar_t cl_followmodel_side_lowpass = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_side_lowpass", "10", "gun following sideways lowpass in 1/s"};
  74 cvar_t cl_followmodel_up_speed = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_up_speed", "0.5", "gun following upward speed"};
  75 cvar_t cl_followmodel_up_limit = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_up_limit", "5", "gun following upward limit"};
  76 cvar_t cl_followmodel_up_highpass1 = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_up_highpass1", "60", "gun following upward pre-highpass in 1/s"};
  77 cvar_t cl_followmodel_up_highpass = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_up_highpass", "2", "gun following upward highpass in 1/s"};
  78 cvar_t cl_followmodel_up_lowpass = {CVAR_CLIENT | CVAR_SAVE, "cl_followmodel_up_lowpass", "10", "gun following upward lowpass in 1/s"};
  79
  80 cvar_t cl_viewmodel_scale = {CVAR_CLIENT, "cl_viewmodel_scale", "1", "changes size of gun model, lower values prevent poking into walls but cause strange artifacts on lighting and especially r_stereo/vid_stereobuffer options where the size of the gun becomes visible"};
  81
  82 cvar_t v_kicktime = {CVAR_CLIENT, "v_kicktime", "0.5", "how long a view kick from damage lasts"};
  83 cvar_t v_kickroll = {CVAR_CLIENT, "v_kickroll", "0.6", "how much a view kick from damage rolls your view"};
  84 cvar_t v_kickpitch = {CVAR_CLIENT, "v_kickpitch", "0.6", "how much a view kick from damage pitches your view"};
  85
  86 cvar_t v_iyaw_cycle = {CVAR_CLIENT, "v_iyaw_cycle", "2", "v_idlescale yaw speed"};
  87 cvar_t v_iroll_cycle = {CVAR_CLIENT, "v_iroll_cycle", "0.5", "v_idlescale roll speed"};
  88 cvar_t v_ipitch_cycle = {CVAR_CLIENT, "v_ipitch_cycle", "1", "v_idlescale pitch speed"};
  89 cvar_t v_iyaw_level = {CVAR_CLIENT, "v_iyaw_level", "0.3", "v_idlescale yaw amount"};
  90 cvar_t v_iroll_level = {CVAR_CLIENT, "v_iroll_level", "0.1", "v_idlescale roll amount"};
  91 cvar_t v_ipitch_level = {CVAR_CLIENT, "v_ipitch_level", "0.3", "v_idlescale pitch amount"};
  92
  93 cvar_t v_idlescale = {CVAR_CLIENT, "v_idlescale", "0", "how much of the quake 'drunken view' effect to use"};
  94
  95 cvar_t v_isometric = {CVAR_CLIENT, "v_isometric", "0", "changes view to isometric (non-perspective)"};
  96 cvar_t v_isometric_verticalfov = {CVAR_CLIENT, "v_isometric_verticalfov", "512", "vertical field of view in game units (horizontal is computed using aspect ratio based on this)"};
  97 cvar_t v_isometric_xx = {CVAR_CLIENT, "v_isometric_xx", "1", "camera matrix"};
  98 cvar_t v_isometric_xy = {CVAR_CLIENT, "v_isometric_xy", "0", "camera matrix"};
  99 cvar_t v_isometric_xz = {CVAR_CLIENT, "v_isometric_xz", "0", "camera matrix"};
 100 cvar_t v_isometric_yx = {CVAR_CLIENT, "v_isometric_yx", "0", "camera matrix"};
 101 cvar_t v_isometric_yy = {CVAR_CLIENT, "v_isometric_yy", "1", "camera matrix"};
 102 cvar_t v_isometric_yz = {CVAR_CLIENT, "v_isometric_yz", "0", "camera matrix"};
 103 cvar_t v_isometric_zx = {CVAR_CLIENT, "v_isometric_zx", "0", "camera matrix"};
 104 cvar_t v_isometric_zy = {CVAR_CLIENT, "v_isometric_zy", "0", "camera matrix"};
 105 cvar_t v_isometric_zz = {CVAR_CLIENT, "v_isometric_zz", "1", "camera matrix"};
 106 cvar_t v_isometric_tx = {CVAR_CLIENT, "v_isometric_tx", "0", "camera position (player-relative)"};
 107 cvar_t v_isometric_ty = {CVAR_CLIENT, "v_isometric_ty", "0", "camera position (player-relative)"};
 108 cvar_t v_isometric_tz = {CVAR_CLIENT, "v_isometric_tz", "0", "camera position (player-relative)"};
 109 cvar_t v_isometric_rot_pitch = {CVAR_CLIENT, "v_isometric_rot_pitch", "60", "camera rotation"};
 110 cvar_t v_isometric_rot_yaw = {CVAR_CLIENT, "v_isometric_rot_yaw", "135", "camera rotation"};
 111 cvar_t v_isometric_rot_roll = {CVAR_CLIENT, "v_isometric_rot_roll", "0", "camera rotation"};
 112 cvar_t v_isometric_relx = {CVAR_CLIENT, "v_isometric_relx", "0", "camera position*forward"};
 113 cvar_t v_isometric_rely = {CVAR_CLIENT, "v_isometric_rely", "0", "camera position*left"};
 114 cvar_t v_isometric_relz = {CVAR_CLIENT, "v_isometric_relz", "0", "camera position*up"};
 115 cvar_t v_isometric_flipcullface = {CVAR_CLIENT, "v_isometric_flipcullface", "0", "flips the backface culling"};
 116 cvar_t v_isometric_locked_orientation = {CVAR_CLIENT, "v_isometric_locked_orientation", "1", "camera rotation is fixed"};
 117 cvar_t v_isometric_usevieworiginculling = {CVAR_CLIENT, "v_isometric_usevieworiginculling", "0", "check visibility to the player location (can look pretty weird)"};
 118
 119 cvar_t crosshair = {CVAR_CLIENT | CVAR_SAVE, "crosshair", "0", "selects crosshair to use (0 is none)"};
 120
 121 cvar_t v_centermove = {CVAR_CLIENT, "v_centermove", "0.15", "how long before the view begins to center itself (if freelook/+mlook/+jlook/+klook are off)"};
 122 cvar_t v_centerspeed = {CVAR_CLIENT, "v_centerspeed","500", "how fast the view centers itself"};
 123
 124 cvar_t cl_stairsmoothspeed = {CVAR_CLIENT | CVAR_SAVE, "cl_stairsmoothspeed", "160", "how fast your view moves upward/downward when running up/down stairs"};
 125
 126 cvar_t cl_smoothviewheight = {CVAR_CLIENT | CVAR_SAVE, "cl_smoothviewheight", "0", "time of the averaging to the viewheight value so that it creates a smooth transition. higher values = longer transition, 0 for instant transition."};
 127
 128 cvar_t chase_back = {CVAR_CLIENT | CVAR_SAVE, "chase_back", "48", "chase cam distance from the player"};
 129 cvar_t chase_up = {CVAR_CLIENT | CVAR_SAVE, "chase_up", "24", "chase cam distance from the player"};
 130 cvar_t chase_active = {CVAR_CLIENT | CVAR_SAVE, "chase_active", "0", "enables chase cam"};
 131 cvar_t chase_overhead = {CVAR_CLIENT | CVAR_SAVE, "chase_overhead", "0", "chase cam looks straight down if this is not zero"};
 132 // GAME_GOODVSBAD2
 133 cvar_t chase_stevie = {CVAR_CLIENT, "chase_stevie", "0", "(GOODVSBAD2 only) chase cam view from above"};
 134
 135 cvar_t v_deathtilt = {CVAR_CLIENT, "v_deathtilt", "1", "whether to use sideways view when dead"};
 136 cvar_t v_deathtiltangle = {CVAR_CLIENT, "v_deathtiltangle", "80", "what roll angle to use when tilting the view while dead"};
 137
 138 // Prophecy camera pitchangle by Alexander "motorsep" Zubov
 139 cvar_t chase_pitchangle = {CVAR_CLIENT | CVAR_SAVE, "chase_pitchangle", "55", "chase cam pitch angle"};
 140
 141 cvar_t v_yshearing = {CVAR_CLIENT, "v_yshearing", "0", "be all out of gum (set this to the maximum angle to allow Y shearing for - try values like 75)"};
 142
 143 float   v_dmg_time, v_dmg_roll, v_dmg_pitch;
 144
 145
 146 /*
 147 ===============
 148 V_CalcRoll
 149
 150 Used by view and sv_user
 151 ===============
 152 */
 153 float V_CalcRoll (const vec3_t angles, const vec3_t velocity)
 154 {
 155         vec3_t  right;
 156         float   sign;
 157         float   side;
 158         float   value;
 159
 160         AngleVectors (angles, NULL, right, NULL);
 161         side = DotProduct (velocity, right);
 162         sign = side < 0 ? -1 : 1;
 163         side = fabs(side);
 164
 165         value = cl_rollangle.value;
 166
 167         if (side < cl_rollspeed.value)
 168                 side = side * value / cl_rollspeed.value;
 169         else
 170                 side = value;
 171
 172         return side*sign;
 173
 174 }
 175
 176 void V_StartPitchDrift (void)
 177 {
 178         if (cl.laststop == cl.time)
 179                 return;         // something else is keeping it from drifting
 180
 181         if (cl.nodrift || !cl.pitchvel)
 182         {
 183                 cl.pitchvel = v_centerspeed.value;
 184                 cl.nodrift = false;
 185                 cl.driftmove = 0;
 186         }
 187 }
 188
 189 void V_StartPitchDrift_f(cmd_state_t *cmd)
 190 {
 191         V_StartPitchDrift();
 192 }
 193
 194 void V_StopPitchDrift (void)
 195 {
 196         cl.laststop = cl.time;
 197         cl.nodrift = true;
 198         cl.pitchvel = 0;
 199 }
 200
 201 /*
 202 ===============
 203 V_DriftPitch
 204
 205 Moves the client pitch angle towards cl.idealpitch sent by the server.
 206
 207 If the user is adjusting pitch manually, either with lookup/lookdown,
 208 mlook and mouse, or klook and keyboard, pitch drifting is constantly stopped.
 209
 210 Drifting is enabled when the center view key is hit, mlook is released and
 211 lookspring is non 0, or when
 212 ===============
 213 */
 214 void V_DriftPitch (void)
 215 {
 216         float           delta, move;
 217
 218         if (noclip_anglehack || !cl.onground || cls.demoplayback )
 219         {
 220                 cl.driftmove = 0;
 221                 cl.pitchvel = 0;
 222                 return;
 223         }
 224
 225 // don't count small mouse motion
 226         if (cl.nodrift)
 227         {
 228                 if ( fabs(cl.cmd.forwardmove) < cl_forwardspeed.value)
 229                         cl.driftmove = 0;
 230                 else
 231                         cl.driftmove += cl.realframetime;
 232
 233                 if ( cl.driftmove > v_centermove.value)
 234                 {
 235                         V_StartPitchDrift ();
 236                 }
 237                 return;
 238         }
 239
 240         delta = cl.idealpitch - cl.viewangles[PITCH];
 241
 242         if (!delta)
 243         {
 244                 cl.pitchvel = 0;
 245                 return;
 246         }
 247
 248         move = cl.realframetime * cl.pitchvel;
 249         cl.pitchvel += cl.realframetime * v_centerspeed.value;
 250
 251         if (delta > 0)
 252         {
 253                 if (move > delta)
 254                 {
 255                         cl.pitchvel = 0;
 256                         move = delta;
 257                 }
 258                 cl.viewangles[PITCH] += move;
 259         }
 260         else if (delta < 0)
 261         {
 262                 if (move > -delta)
 263                 {
 264                         cl.pitchvel = 0;
 265                         move = -delta;
 266                 }
 267                 cl.viewangles[PITCH] -= move;
 268         }
 269 }
 270
 271
 272 /*
 273 ==============================================================================
 274
 275                                                 SCREEN FLASHES
 276
 277 ==============================================================================
 278 */
 279
 280
 281 /*
 282 ===============
 283 V_ParseDamage
 284 ===============
 285 */
 286 void V_ParseDamage (void)
 287 {
 288         int armor, blood;
 289         vec3_t from;
 290         //vec3_t forward, right;
 291         vec3_t localfrom;
 292         entity_t *ent;
 293         //float side;
 294         float count;
 295
 296         armor = MSG_ReadByte(&cl_message);
 297         blood = MSG_ReadByte(&cl_message);
 298         MSG_ReadVector(&cl_message, from, cls.protocol);
 299
 300         // Send the Dmg Globals to CSQC
 301         CL_VM_UpdateDmgGlobals(blood, armor, from);
 302
 303         count = blood*0.5 + armor*0.5;
 304         if (count < 10)
 305                 count = 10;
 306
 307         cl.faceanimtime = cl.time + 0.2;                // put sbar face into pain frame
 308
 309         cl.cshifts[CSHIFT_DAMAGE].percent += 3*count;
 310         cl.cshifts[CSHIFT_DAMAGE].alphafade = 150;
 311         if (cl.cshifts[CSHIFT_DAMAGE].percent < 0)
 312                 cl.cshifts[CSHIFT_DAMAGE].percent = 0;
 313         if (cl.cshifts[CSHIFT_DAMAGE].percent > 150)
 314                 cl.cshifts[CSHIFT_DAMAGE].percent = 150;
 315
 316         if (armor > blood)
 317         {
 318                 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 200;
 319                 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 100;
 320                 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 100;
 321         }
 322         else if (armor)
 323         {
 324                 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 220;
 325                 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 50;
 326                 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 50;
 327         }
 328         else
 329         {
 330                 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 255;
 331                 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 0;
 332                 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 0;
 333         }
 334
 335         // calculate view angle kicks
 336         if (cl.entities[cl.viewentity].state_current.active)
 337         {
 338                 ent = &cl.entities[cl.viewentity];
 339                 Matrix4x4_Transform(&ent->render.inversematrix, from, localfrom);
 340                 VectorNormalize(localfrom);
 341                 v_dmg_pitch = count * localfrom[0] * v_kickpitch.value;
 342                 v_dmg_roll = count * localfrom[1] * v_kickroll.value;
 343                 v_dmg_time = v_kicktime.value;
 344         }
 345 }
 346
 347 static cshift_t v_cshift;
 348
 349 /*
 350 ==================
 351 V_cshift_f
 352 ==================
 353 */
 354 static void V_cshift_f(cmd_state_t *cmd)
 355 {
 356         v_cshift.destcolor[0] = atof(Cmd_Argv(cmd, 1));
 357         v_cshift.destcolor[1] = atof(Cmd_Argv(cmd, 2));
 358         v_cshift.destcolor[2] = atof(Cmd_Argv(cmd, 3));
 359         v_cshift.percent = atof(Cmd_Argv(cmd, 4));
 360 }
 361
 362
 363 /*
 364 ==================
 365 V_BonusFlash_f
 366
 367 When you run over an item, the server sends this command
 368 ==================
 369 */
 370 static void V_BonusFlash_f(cmd_state_t *cmd)
 371 {
 372         if(Cmd_Argc(cmd) == 1)
 373         {
 374                 cl.cshifts[CSHIFT_BONUS].destcolor[0] = 215;
 375                 cl.cshifts[CSHIFT_BONUS].destcolor[1] = 186;
 376                 cl.cshifts[CSHIFT_BONUS].destcolor[2] = 69;
 377                 cl.cshifts[CSHIFT_BONUS].percent = 50;
 378                 cl.cshifts[CSHIFT_BONUS].alphafade = 100;
 379         }
 380         else if(Cmd_Argc(cmd) >= 4 && Cmd_Argc(cmd) <= 6)
 381         {
 382                 cl.cshifts[CSHIFT_BONUS].destcolor[0] = atof(Cmd_Argv(cmd, 1)) * 255;
 383                 cl.cshifts[CSHIFT_BONUS].destcolor[1] = atof(Cmd_Argv(cmd, 2)) * 255;
 384                 cl.cshifts[CSHIFT_BONUS].destcolor[2] = atof(Cmd_Argv(cmd, 3)) * 255;
 385                 if(Cmd_Argc(cmd) >= 5)
 386                         cl.cshifts[CSHIFT_BONUS].percent = atof(Cmd_Argv(cmd, 4)) * 255; // yes, these are HEXADECIMAL percent ;)
 387                 else
 388                         cl.cshifts[CSHIFT_BONUS].percent = 50;
 389                 if(Cmd_Argc(cmd) >= 6)
 390                         cl.cshifts[CSHIFT_BONUS].alphafade = atof(Cmd_Argv(cmd, 5)) * 255;
 391                 else
 392                         cl.cshifts[CSHIFT_BONUS].alphafade = 100;
 393         }
 394         else
 395                 Con_Printf("usage:\nbf, or bf R G B [A [alphafade]]\n");
 396 }
 397
 398 /*
 399 ==============================================================================
 400
 401                                                 VIEW RENDERING
 402
 403 ==============================================================================
 404 */
 405
 406 extern matrix4x4_t viewmodelmatrix_nobob;
 407 extern matrix4x4_t viewmodelmatrix_withbob;
 408
 409 #include "cl_collision.h"
 410 #include "csprogs.h"
 411
 412 /*
 413 ==================
 414 V_CalcRefdef
 415
 416 ==================
 417 */
 418 #if 0
 419 static vec3_t eyeboxmins = {-16, -16, -24};
 420 static vec3_t eyeboxmaxs = { 16,  16,  32};
 421 #endif
 422
 423 static vec_t lowpass(vec_t value, vec_t frac, vec_t *store)
 424 {
 425         frac = bound(0, frac, 1);
 426         return (*store = *store * (1 - frac) + value * frac);
 427 }
 428
 429 static vec_t lowpass_limited(vec_t value, vec_t frac, vec_t limit, vec_t *store)
 430 {
 431         lowpass(value, frac, store);
 432         return (*store = bound(value - limit, *store, value + limit));
 433 }
 434
 435 static vec_t highpass(vec_t value, vec_t frac, vec_t *store)
 436 {
 437         return value - lowpass(value, frac, store);
 438 }
 439
 440 static vec_t highpass_limited(vec_t value, vec_t frac, vec_t limit, vec_t *store)
 441 {
 442         return value - lowpass_limited(value, frac, limit, store);
 443 }
 444
 445 static void lowpass3(vec3_t value, vec_t fracx, vec_t fracy, vec_t fracz, vec3_t store, vec3_t out)
 446 {
 447         out[0] = lowpass(value[0], fracx, &store[0]);
 448         out[1] = lowpass(value[1], fracy, &store[1]);
 449         out[2] = lowpass(value[2], fracz, &store[2]);
 450 }
 451
 452 static void highpass3(vec3_t value, vec_t fracx, vec_t fracy, vec_t fracz, vec3_t store, vec3_t out)
 453 {
 454         out[0] = highpass(value[0], fracx, &store[0]);
 455         out[1] = highpass(value[1], fracy, &store[1]);
 456         out[2] = highpass(value[2], fracz, &store[2]);
 457 }
 458
 459 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)
 460 {
 461         out[0] = highpass_limited(value[0], fracx, limitx, &store[0]);
 462         out[1] = highpass_limited(value[1], fracy, limity, &store[1]);
 463         out[2] = highpass_limited(value[2], fracz, limitz, &store[2]);
 464 }
 465
 466 /*
 467  * State:
 468  *   cl.bob2_smooth
 469  *   cl.bobfall_speed
 470  *   cl.bobfall_swing
 471  *   cl.gunangles_adjustment_highpass
 472  *   cl.gunangles_adjustment_lowpass
 473  *   cl.gunangles_highpass
 474  *   cl.gunangles_prev
 475  *   cl.gunorg_adjustment_highpass
 476  *   cl.gunorg_adjustment_lowpass
 477  *   cl.gunorg_highpass
 478  *   cl.gunorg_prev
 479  *   cl.hitgroundtime
 480  *   cl.lastongroundtime
 481  *   cl.oldongrounbd
 482  *   cl.stairsmoothtime
 483  *   cl.stairsmoothz
 484  *   cl.calcrefdef_prevtime
 485  * Extra input:
 486  *   cl.movecmd[0].time
 487  *   cl.movevars_stepheight
 488  *   cl.movevars_timescale
 489  *   cl.oldtime
 490  *   cl.punchangle
 491  *   cl.punchvector
 492  *   cl.qw_intermission_angles
 493  *   cl.qw_intermission_origin
 494  *   cl.qw_weaponkick
 495  *   cls.protocol
 496  *   cl.time
 497  * Output:
 498  *   cl.csqc_viewanglesfromengine
 499  *   cl.csqc_viewmodelmatrixfromengine
 500  *   cl.csqc_vieworiginfromengine
 501  *   r_refdef.view.matrix
 502  *   viewmodelmatrix_nobob
 503  *   viewmodelmatrix_withbob
 504  */
 505 void V_CalcRefdefUsing (const matrix4x4_t *entrendermatrix, const vec3_t clviewangles, qboolean teleported, qboolean clonground, qboolean clcmdjump, float clstatsviewheight, qboolean cldead, qboolean clintermission, const vec3_t clvelocity)
 506 {
 507         float vieworg[3], viewangles[3], smoothtime;
 508         float gunorg[3], gunangles[3];
 509         matrix4x4_t tmpmatrix;
 510
 511         static float viewheightavg;
 512         float viewheight;
 513 #if 0
 514 // begin of chase camera bounding box size for proper collisions by Alexander Zubov
 515         vec3_t camboxmins = {-3, -3, -3};
 516         vec3_t camboxmaxs = {3, 3, 3};
 517 // end of chase camera bounding box size for proper collisions by Alexander Zubov
 518 #endif
 519         trace_t trace;
 520
 521         // react to clonground state changes (for gun bob)
 522         if (clonground)
 523         {
 524                 if (!cl.oldonground)
 525                         cl.hitgroundtime = cl.movecmd[0].time;
 526                 cl.lastongroundtime = cl.movecmd[0].time;
 527         }
 528         cl.oldonground = clonground;
 529         cl.calcrefdef_prevtime = max(cl.calcrefdef_prevtime, cl.oldtime);
 530
 531         VectorClear(gunangles);
 532         VectorClear(gunorg);
 533         viewmodelmatrix_nobob = identitymatrix;
 534         viewmodelmatrix_withbob = identitymatrix;
 535         r_refdef.view.matrix = identitymatrix;
 536
 537         // player can look around, so take the origin from the entity,
 538         // and the angles from the input system
 539         Matrix4x4_OriginFromMatrix(entrendermatrix, vieworg);
 540         VectorCopy(clviewangles, viewangles);
 541
 542         // calculate how much time has passed since the last V_CalcRefdef
 543         smoothtime = bound(0, cl.time - cl.stairsmoothtime, 0.1);
 544         cl.stairsmoothtime = cl.time;
 545
 546         // fade damage flash
 547         if (v_dmg_time > 0)
 548                 v_dmg_time -= bound(0, smoothtime, 0.1);
 549
 550         if (clintermission)
 551         {
 552                 // entity is a fixed camera, just copy the matrix
 553                 if (cls.protocol == PROTOCOL_QUAKEWORLD)
 554                         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);
 555                 else
 556                 {
 557                         r_refdef.view.matrix = *entrendermatrix;
 558                         Matrix4x4_AdjustOrigin(&r_refdef.view.matrix, 0, 0, clstatsviewheight);
 559                 }
 560                 if (v_yshearing.value > 0)
 561                         Matrix4x4_QuakeToDuke3D(&r_refdef.view.matrix, &r_refdef.view.matrix, v_yshearing.value);
 562                 Matrix4x4_Copy(&viewmodelmatrix_nobob, &r_refdef.view.matrix);
 563                 Matrix4x4_ConcatScale(&viewmodelmatrix_nobob, cl_viewmodel_scale.value);
 564                 Matrix4x4_Copy(&viewmodelmatrix_withbob, &viewmodelmatrix_nobob);
 565
 566                 VectorCopy(vieworg, cl.csqc_vieworiginfromengine);
 567                 VectorCopy(viewangles, cl.csqc_viewanglesfromengine);
 568
 569                 Matrix4x4_Invert_Simple(&tmpmatrix, &r_refdef.view.matrix);
 570                 Matrix4x4_CreateScale(&cl.csqc_viewmodelmatrixfromengine, cl_viewmodel_scale.value);
 571         }
 572         else
 573         {
 574                 // smooth stair stepping, but only if clonground and enabled
 575                 if (!clonground || cl_stairsmoothspeed.value <= 0 || teleported)
 576                         cl.stairsmoothz = vieworg[2];
 577                 else
 578                 {
 579                         if (cl.stairsmoothz < vieworg[2])
 580                                 vieworg[2] = cl.stairsmoothz = bound(vieworg[2] - cl.movevars_stepheight, cl.stairsmoothz + smoothtime * cl_stairsmoothspeed.value, vieworg[2]);
 581                         else if (cl.stairsmoothz > vieworg[2])
 582                                 vieworg[2] = cl.stairsmoothz = bound(vieworg[2], cl.stairsmoothz - smoothtime * cl_stairsmoothspeed.value, vieworg[2] + cl.movevars_stepheight);
 583                 }
 584
 585                 // apply qw weapon recoil effect (this did not work in QW)
 586                 // TODO: add a cvar to disable this
 587                 viewangles[PITCH] += cl.qw_weaponkick;
 588
 589                 // apply the viewofs (even if chasecam is used)
 590                 // Samual: Lets add smoothing for this too so that things like crouching are done with a transition.
 591                 viewheight = bound(0, (cl.time - cl.calcrefdef_prevtime) / max(0.0001, cl_smoothviewheight.value), 1);
 592                 viewheightavg = viewheightavg * (1 - viewheight) + clstatsviewheight * viewheight;
 593                 vieworg[2] += viewheightavg;
 594
 595                 if (chase_active.value)
 596                 {
 597                         // observing entity from third person. Added "campitch" by Alexander "motorsep" Zubov
 598                         vec_t camback, camup, dist, campitch, forward[3], chase_dest[3];
 599
 600                         camback = chase_back.value;
 601                         camup = chase_up.value;
 602                         campitch = chase_pitchangle.value;
 603
 604                         AngleVectors(viewangles, forward, NULL, NULL);
 605
 606                         if (chase_overhead.integer)
 607                         {
 608 #if 1
 609                                 vec3_t offset;
 610                                 vec3_t bestvieworg;
 611 #endif
 612                                 vec3_t up;
 613                                 viewangles[PITCH] = 0;
 614                                 AngleVectors(viewangles, forward, NULL, up);
 615                                 // trace a little further so it hits a surface more consistently (to avoid 'snapping' on the edge of the range)
 616                                 chase_dest[0] = vieworg[0] - forward[0] * camback + up[0] * camup;
 617                                 chase_dest[1] = vieworg[1] - forward[1] * camback + up[1] * camup;
 618                                 chase_dest[2] = vieworg[2] - forward[2] * camback + up[2] * camup;
 619 #if 0
 620 #if 1
 621                                 //trace = CL_TraceLine(vieworg, eyeboxmins, eyeboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, true, false, NULL, false);
 622                                 trace = CL_TraceLine(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, true, false, NULL, false);
 623 #else
 624                                 //trace = CL_TraceBox(vieworg, eyeboxmins, eyeboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, true, false, NULL, false);
 625                                 trace = CL_TraceBox(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, true, false, NULL, false);
 626 #endif
 627                                 VectorCopy(trace.endpos, vieworg);
 628                                 vieworg[2] -= 8;
 629 #else
 630                                 // trace from first person view location to our chosen third person view location
 631 #if 1
 632                                 trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
 633 #else
 634                                 trace = CL_TraceBox(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false);
 635 #endif
 636                                 VectorCopy(trace.endpos, bestvieworg);
 637                                 offset[2] = 0;
 638                                 for (offset[0] = -16;offset[0] <= 16;offset[0] += 8)
 639                                 {
 640                                         for (offset[1] = -16;offset[1] <= 16;offset[1] += 8)
 641                                         {
 642                                                 AngleVectors(viewangles, NULL, NULL, up);
 643                                                 chase_dest[0] = vieworg[0] - forward[0] * camback + up[0] * camup + offset[0];
 644                                                 chase_dest[1] = vieworg[1] - forward[1] * camback + up[1] * camup + offset[1];
 645                                                 chase_dest[2] = vieworg[2] - forward[2] * camback + up[2] * camup + offset[2];
 646 #if 1
 647                                                 trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
 648 #else
 649                                                 trace = CL_TraceBox(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false);
 650 #endif
 651                                                 if (bestvieworg[2] > trace.endpos[2])
 652                                                         bestvieworg[2] = trace.endpos[2];
 653                                         }
 654                                 }
 655                                 bestvieworg[2] -= 8;
 656                                 VectorCopy(bestvieworg, vieworg);
 657 #endif
 658                                 viewangles[PITCH] = campitch;
 659                         }
 660                         else
 661                         {
 662                                 if (gamemode == GAME_GOODVSBAD2 && chase_stevie.integer)
 663                                 {
 664                                         // look straight down from high above
 665                                         viewangles[PITCH] = 90;
 666                                         camback = 2048;
 667                                         VectorSet(forward, 0, 0, -1);
 668                                 }
 669
 670                                 // trace a little further so it hits a surface more consistently (to avoid 'snapping' on the edge of the range)
 671                                 dist = -camback - 8;
 672                                 chase_dest[0] = vieworg[0] + forward[0] * dist;
 673                                 chase_dest[1] = vieworg[1] + forward[1] * dist;
 674                                 chase_dest[2] = vieworg[2] + forward[2] * dist + camup;
 675                                 trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
 676                                 VectorMAMAM(1, trace.endpos, 8, forward, 4, trace.plane.normal, vieworg);
 677                         }
 678                 }
 679                 else
 680                 {
 681                         // first person view from entity
 682                         // angles
 683                         if (cldead && v_deathtilt.integer)
 684                                 viewangles[ROLL] = v_deathtiltangle.value;
 685                         VectorAdd(viewangles, cl.punchangle, viewangles);
 686                         viewangles[ROLL] += V_CalcRoll(clviewangles, clvelocity);
 687                         if (v_dmg_time > 0)
 688                         {
 689                                 viewangles[ROLL] += v_dmg_time/v_kicktime.value*v_dmg_roll;
 690                                 viewangles[PITCH] += v_dmg_time/v_kicktime.value*v_dmg_pitch;
 691                         }
 692                         // origin
 693                         VectorAdd(vieworg, cl.punchvector, vieworg);
 694                         if (!cldead)
 695                         {
 696                                 double xyspeed, bob, bobfall;
 697                                 double cycle; // double-precision because cl.time can be a very large number, where float would get stuttery at high time values
 698                                 vec_t frametime;
 699
 700                                 frametime = (cl.time - cl.calcrefdef_prevtime) * cl.movevars_timescale;
 701
 702                                 if(cl_followmodel.integer || cl_leanmodel.integer)
 703                                 {
 704                                         // 1. if we teleported, clear the frametime... the lowpass will recover the previous value then
 705                                         if(teleported)
 706                                         {
 707                                                 // try to fix the first highpass; result is NOT
 708                                                 // perfect! TODO find a better fix
 709                                                 VectorCopy(viewangles, cl.gunangles_prev);
 710                                                 VectorCopy(vieworg, cl.gunorg_prev);
 711                                         }
 712
 713                                         // 2. for the gun origin, only keep the high frequency (non-DC) parts, which is "somewhat like velocity"
 714                                         VectorAdd(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
 715                                         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);
 716                                         VectorCopy(vieworg, cl.gunorg_prev);
 717                                         VectorSubtract(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
 718
 719                                         // in the highpass, we _store_ the DIFFERENCE to the actual view angles...
 720                                         VectorAdd(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
 721                                         cl.gunangles_highpass[PITCH] += 360 * floor((viewangles[PITCH] - cl.gunangles_highpass[PITCH]) / 360 + 0.5);
 722                                         cl.gunangles_highpass[YAW] += 360 * floor((viewangles[YAW] - cl.gunangles_highpass[YAW]) / 360 + 0.5);
 723                                         cl.gunangles_highpass[ROLL] += 360 * floor((viewangles[ROLL] - cl.gunangles_highpass[ROLL]) / 360 + 0.5);
 724                                         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);
 725                                         VectorCopy(viewangles, cl.gunangles_prev);
 726                                         VectorSubtract(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
 727
 728                                         // 3. calculate the RAW adjustment vectors
 729                                         gunorg[0] *= -cl_followmodel_side_speed.value;
 730                                         gunorg[1] *= -cl_followmodel_side_speed.value;
 731                                         gunorg[2] *= -cl_followmodel_up_speed.value;
 732
 733                                         gunangles[PITCH] *= -cl_leanmodel_up_speed.value;
 734                                         gunangles[YAW] *= -cl_leanmodel_side_speed.value;
 735                                         gunangles[ROLL] = 0;
 736
 737                                         // 4. perform highpass/lowpass on the adjustment vectors (turning velocity into acceleration!)
 738                                         //    trick: we must do the lowpass LAST, so the lowpass vector IS the final vector!
 739                                         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);
 740                                         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);
 741                                         // we assume here: PITCH = 0, YAW = 1, ROLL = 2
 742                                         highpass3(gunangles, frametime*cl_leanmodel_up_highpass.value, frametime*cl_leanmodel_side_highpass.value, 0, cl.gunangles_adjustment_highpass, gunangles);
 743                                         lowpass3(gunangles, frametime*cl_leanmodel_up_lowpass.value, frametime*cl_leanmodel_side_lowpass.value, 0, cl.gunangles_adjustment_lowpass, gunangles);
 744
 745                                         // 5. use the adjusted vectors
 746                                         VectorAdd(vieworg, gunorg, gunorg);
 747                                         VectorAdd(viewangles, gunangles, gunangles);
 748                                 }
 749                                 else
 750                                 {
 751                                         // Just initialize gunorg/gunangles.
 752                                         VectorCopy(vieworg, gunorg);
 753                                         VectorCopy(viewangles, gunangles);
 754                                 }
 755
 756                                 // bounded XY speed, used by several effects below
 757                                 xyspeed = bound (0, sqrt(clvelocity[0]*clvelocity[0] + clvelocity[1]*clvelocity[1]), cl_bob_velocity_limit.value);
 758
 759                                 // vertical view bobbing code
 760                                 if (cl_bob.value && cl_bobcycle.value)
 761                                 {
 762                                         float bob_limit = cl_bob_limit.value;
 763
 764                                         if (cl_bob_limit_heightcheck.integer)
 765                                         {
 766                                                 // use traces to determine what range the view can bob in, and scale down the bob as needed
 767                                                 float trace1fraction;
 768                                                 float trace2fraction;
 769                                                 vec3_t bob_height_check_dest;
 770
 771                                                 // these multipliers are expanded a bit (the actual bob sin range is from -0.4 to 1.0) to reduce nearclip issues, especially on water surfaces
 772                                                 bob_height_check_dest[0] = vieworg[0];
 773                                                 bob_height_check_dest[1] = vieworg[1];
 774                                                 bob_height_check_dest[2] = vieworg[2] + cl_bob_limit.value * 1.1f;
 775                                                 trace = CL_TraceLine(vieworg, bob_height_check_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY | (cl_bob_limit_heightcheck_dontcrosswatersurface.integer ? SUPERCONTENTS_LIQUIDSMASK : 0), 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
 776                                                 trace1fraction = trace.fraction;
 777
 778                                                 bob_height_check_dest[0] = vieworg[0];
 779                                                 bob_height_check_dest[1] = vieworg[1];
 780                                                 bob_height_check_dest[2] = vieworg[2] + cl_bob_limit.value * -0.5f;
 781                                                 trace = CL_TraceLine(vieworg, bob_height_check_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY | (cl_bob_limit_heightcheck_dontcrosswatersurface.integer ? SUPERCONTENTS_LIQUIDSMASK : 0), 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
 782                                                 trace2fraction = trace.fraction;
 783
 784                                                 bob_limit *= min(trace1fraction, trace2fraction);
 785                                         }
 786
 787                                         // LadyHavoc: this code is *weird*, but not replacable (I think it
 788                                         // should be done in QC on the server, but oh well, quake is quake)
 789                                         // LadyHavoc: figured out bobup: the time at which the sin is at 180
 790                                         // degrees (which allows lengthening or squishing the peak or valley)
 791                                         cycle = cl.time / cl_bobcycle.value;
 792                                         cycle -= (int) cycle;
 793                                         if (cycle < cl_bobup.value)
 794                                                 cycle = sin(M_PI * cycle / cl_bobup.value);
 795                                         else
 796                                                 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
 797                                         // bob is proportional to velocity in the xy plane
 798                                         // (don't count Z, or jumping messes it up)
 799                                         bob = xyspeed * cl_bob.value;
 800                                         bob = bound(0, bob, bob_limit);
 801                                         bob = bob*0.3 + bob*0.7*cycle;
 802                                         vieworg[2] += bob;
 803                                         // we also need to adjust gunorg, or this appears like pushing the gun!
 804                                         // In the old code, this was applied to vieworg BEFORE copying to gunorg,
 805                                         // but this is not viable with the new followmodel code as that would mean
 806                                         // that followmodel would work on the munged-by-bob vieworg and do feedback
 807                                         gunorg[2] += bob;
 808                                 }
 809
 810                                 // horizontal view bobbing code
 811                                 if (cl_bob2.value && cl_bob2cycle.value)
 812                                 {
 813                                         vec3_t bob2vel;
 814                                         vec3_t forward, right, up;
 815                                         float side, front;
 816
 817                                         cycle = cl.time / cl_bob2cycle.value;
 818                                         cycle -= (int) cycle;
 819                                         if (cycle < 0.5)
 820                                                 cycle = cos(M_PI * cycle / 0.5); // cos looks better here with the other view bobbing using sin
 821                                         else
 822                                                 cycle = cos(M_PI + M_PI * (cycle-0.5)/0.5);
 823                                         bob = cl_bob2.value * cycle;
 824
 825                                         // this value slowly decreases from 1 to 0 when we stop touching the ground.
 826                                         // The cycle is later multiplied with it so the view smooths back to normal
 827                                         if (clonground && !clcmdjump) // also block the effect while the jump button is pressed, to avoid twitches when bunny-hopping
 828                                                 cl.bob2_smooth = 1;
 829                                         else
 830                                         {
 831                                                 if(cl.bob2_smooth > 0)
 832                                                         cl.bob2_smooth -= bound(0, cl_bob2smooth.value, 1);
 833                                                 else
 834                                                         cl.bob2_smooth = 0;
 835                                         }
 836
 837                                         // calculate the front and side of the player between the X and Y axes
 838                                         AngleVectors(viewangles, forward, right, up);
 839                                         // now get the speed based on those angles. The bounds should match the same value as xyspeed's
 840                                         side = bound(-cl_bob_velocity_limit.value, DotProduct (clvelocity, right) * cl.bob2_smooth, cl_bob_velocity_limit.value);
 841                                         front = bound(-cl_bob_velocity_limit.value, DotProduct (clvelocity, forward) * cl.bob2_smooth, cl_bob_velocity_limit.value);
 842                                         VectorScale(forward, bob, forward);
 843                                         VectorScale(right, bob, right);
 844                                         // we use side with forward and front with right, so the bobbing goes
 845                                         // to the side when we walk forward and to the front when we strafe
 846                                         VectorMAMAM(side, forward, front, right, 0, up, bob2vel);
 847                                         vieworg[0] += bob2vel[0];
 848                                         vieworg[1] += bob2vel[1];
 849                                         // we also need to adjust gunorg, or this appears like pushing the gun!
 850                                         // In the old code, this was applied to vieworg BEFORE copying to gunorg,
 851                                         // but this is not viable with the new followmodel code as that would mean
 852                                         // that followmodel would work on the munged-by-bob vieworg and do feedback
 853                                         gunorg[0] += bob2vel[0];
 854                                         gunorg[1] += bob2vel[1];
 855                                 }
 856
 857                                 // fall bobbing code
 858                                 // causes the view to swing down and back up when touching the ground
 859                                 if (cl_bobfall.value && cl_bobfallcycle.value)
 860                                 {
 861                                         if (!clonground)
 862                                         {
 863                                                 cl.bobfall_speed = bound(-400, clvelocity[2], 0) * bound(0, cl_bobfall.value, 0.1);
 864                                                 if (clvelocity[2] < -cl_bobfallminspeed.value)
 865                                                         cl.bobfall_swing = 1;
 866                                                 else
 867                                                         cl.bobfall_swing = 0; // TODO really?
 868                                         }
 869                                         else
 870                                         {
 871                                                 cl.bobfall_swing = max(0, cl.bobfall_swing - cl_bobfallcycle.value * frametime);
 872
 873                                                 bobfall = sin(M_PI * cl.bobfall_swing) * cl.bobfall_speed;
 874                                                 vieworg[2] += bobfall;
 875                                                 gunorg[2] += bobfall;
 876                                         }
 877                                 }
 878
 879                                 // gun model bobbing code
 880                                 if (cl_bobmodel.value)
 881                                 {
 882                                         // calculate for swinging gun model
 883                                         // the gun bobs when running on the ground, but doesn't bob when you're in the air.
 884                                         // Sajt: I tried to smooth out the transitions between bob and no bob, which works
 885                                         // for the most part, but for some reason when you go through a message trigger or
 886                                         // pick up an item or anything like that it will momentarily jolt the gun.
 887                                         vec3_t forward, right, up;
 888                                         float bspeed;
 889                                         float s;
 890                                         float t;
 891
 892                                         s = cl.time * cl_bobmodel_speed.value;
 893                                         if (clonground)
 894                                         {
 895                                                 if (cl.time - cl.hitgroundtime < 0.2)
 896                                                 {
 897                                                         // just hit the ground, speed the bob back up over the next 0.2 seconds
 898                                                         t = cl.time - cl.hitgroundtime;
 899                                                         t = bound(0, t, 0.2);
 900                                                         t *= 5;
 901                                                 }
 902                                                 else
 903                                                         t = 1;
 904                                         }
 905                                         else
 906                                         {
 907                                                 // recently left the ground, slow the bob down over the next 0.2 seconds
 908                                                 t = cl.time - cl.lastongroundtime;
 909                                                 t = 0.2 - bound(0, t, 0.2);
 910                                                 t *= 5;
 911                                         }
 912
 913                                         bspeed = xyspeed * 0.01f;
 914                                         AngleVectors (gunangles, forward, right, up);
 915                                         bob = bspeed * cl_bobmodel_side.value * cl_viewmodel_scale.value * sin (s) * t;
 916                                         VectorMA (gunorg, bob, right, gunorg);
 917                                         bob = bspeed * cl_bobmodel_up.value * cl_viewmodel_scale.value * cos (s * 2) * t;
 918                                         VectorMA (gunorg, bob, up, gunorg);
 919                                 }
 920                         }
 921                 }
 922                 // calculate a view matrix for rendering the scene
 923                 if (v_idlescale.value)
 924                 {
 925                         viewangles[0] += v_idlescale.value * sin(cl.time*v_ipitch_cycle.value) * v_ipitch_level.value;
 926                         viewangles[1] += v_idlescale.value * sin(cl.time*v_iyaw_cycle.value) * v_iyaw_level.value;
 927                         viewangles[2] += v_idlescale.value * sin(cl.time*v_iroll_cycle.value) * v_iroll_level.value;
 928                 }
 929                 Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, vieworg[0], vieworg[1], vieworg[2], viewangles[0], viewangles[1], viewangles[2], 1);
 930                 if (v_yshearing.value > 0)
 931                         Matrix4x4_QuakeToDuke3D(&r_refdef.view.matrix, &r_refdef.view.matrix, v_yshearing.value);
 932
 933                 // calculate a viewmodel matrix for use in view-attached entities
 934                 Matrix4x4_Copy(&viewmodelmatrix_nobob, &r_refdef.view.matrix);
 935                 Matrix4x4_ConcatScale(&viewmodelmatrix_nobob, cl_viewmodel_scale.value);
 936
 937                 Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix_withbob, gunorg[0], gunorg[1], gunorg[2], gunangles[0], gunangles[1], gunangles[2], cl_viewmodel_scale.value);
 938                 if (v_yshearing.value > 0)
 939                         Matrix4x4_QuakeToDuke3D(&viewmodelmatrix_withbob, &viewmodelmatrix_withbob, v_yshearing.value);
 940
 941                 VectorCopy(vieworg, cl.csqc_vieworiginfromengine);
 942                 VectorCopy(viewangles, cl.csqc_viewanglesfromengine);
 943
 944                 Matrix4x4_Invert_Simple(&tmpmatrix, &r_refdef.view.matrix);
 945                 Matrix4x4_Concat(&cl.csqc_viewmodelmatrixfromengine, &tmpmatrix, &viewmodelmatrix_withbob);
 946         }
 947
 948         cl.calcrefdef_prevtime = cl.time;
 949 }
 950
 951 void V_CalcRefdef (void)
 952 {
 953         entity_t *ent;
 954         qboolean cldead;
 955
 956         if (cls.state == ca_connected && cls.signon == SIGNONS && !cl.csqc_server2csqcentitynumber[cl.viewentity])
 957         {
 958                 // ent is the view entity (visible when out of body)
 959                 ent = &cl.entities[cl.viewentity];
 960
 961                 cldead = (cl.stats[STAT_HEALTH] <= 0 && cl.stats[STAT_HEALTH] != -666 && cl.stats[STAT_HEALTH] != -2342);
 962                 V_CalcRefdefUsing(&ent->render.matrix, cl.viewangles, !ent->persistent.trail_allowed, cl.onground, cl.cmd.jump, cl.stats[STAT_VIEWHEIGHT], cldead, cl.intermission != 0, cl.velocity); // FIXME use a better way to detect teleport/warp than trail_allowed
 963         }
 964         else
 965         {
 966                 viewmodelmatrix_nobob = identitymatrix;
 967                 viewmodelmatrix_withbob = identitymatrix;
 968                 cl.csqc_viewmodelmatrixfromengine = identitymatrix;
 969                 r_refdef.view.matrix = identitymatrix;
 970                 VectorClear(cl.csqc_vieworiginfromengine);
 971                 VectorCopy(cl.viewangles, cl.csqc_viewanglesfromengine);
 972         }
 973 }
 974
 975 void V_MakeViewIsometric(void)
 976 {
 977         // when using isometric view to play normal games we have to rotate the camera to make the Ortho matrix do the right thing (forward as up the screen, etc)
 978         matrix4x4_t relative;
 979         matrix4x4_t modifiedview;
 980         matrix4x4_t modify;
 981         vec3_t forward, left, up, org;
 982         float t[4][4];
 983
 984         r_refdef.view.useperspective = false;
 985         r_refdef.view.usevieworiginculling = !r_trippy.value && v_isometric_usevieworiginculling.integer;
 986         r_refdef.view.frustum_y = v_isometric_verticalfov.value * cl.viewzoom;
 987         r_refdef.view.frustum_x = r_refdef.view.frustum_y * (float)r_refdef.view.width / (float)r_refdef.view.height / vid_pixelheight.value;
 988         r_refdef.view.frustum_x *= r_refdef.frustumscale_x;
 989         r_refdef.view.frustum_y *= r_refdef.frustumscale_y;
 990         r_refdef.view.ortho_x = r_refdef.view.frustum_x; // used by VM_CL_R_SetView
 991         r_refdef.view.ortho_y = r_refdef.view.frustum_y; // used by VM_CL_R_SetView
 992
 993         t[0][0] = v_isometric_xx.value;
 994         t[0][1] = v_isometric_xy.value;
 995         t[0][2] = v_isometric_xz.value;
 996         t[0][3] = 0.0f;
 997         t[1][0] = v_isometric_yx.value;
 998         t[1][1] = v_isometric_yy.value;
 999         t[1][2] = v_isometric_yz.value;
1000         t[1][3] = 0.0f;
1001         t[2][0] = v_isometric_zx.value;
1002         t[2][1] = v_isometric_zy.value;
1003         t[2][2] = v_isometric_zz.value;
1004         t[2][3] = 0.0f;
1005         t[3][0] = 0.0f;
1006         t[3][1] = 0.0f;
1007         t[3][2] = 0.0f;
1008         t[3][3] = 1.0f;
1009         Matrix4x4_FromArrayFloatGL(&modify, t[0]);
1010
1011         // if the orientation is locked, extract the origin and create just a translate matrix to start with
1012         if (v_isometric_locked_orientation.integer)
1013         {
1014                 vec3_t vx, vy, vz, origin;
1015                 Matrix4x4_ToVectors(&r_refdef.view.matrix, vx, vy, vz, origin);
1016                 Matrix4x4_CreateTranslate(&r_refdef.view.matrix, origin[0], origin[1], origin[2]);
1017         }
1018
1019         Matrix4x4_Concat(&modifiedview, &r_refdef.view.matrix, &modify);
1020         Matrix4x4_CreateFromQuakeEntity(&relative, v_isometric_tx.value, v_isometric_ty.value, v_isometric_tz.value, v_isometric_rot_pitch.value, v_isometric_rot_yaw.value, v_isometric_rot_roll.value, 1.0f);
1021         Matrix4x4_Concat(&r_refdef.view.matrix, &modifiedview, &relative);
1022         Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, org);
1023         VectorMAMAMAM(1.0f, org, v_isometric_relx.value, forward, v_isometric_rely.value, left, v_isometric_relz.value, up, org);
1024         Matrix4x4_FromVectors(&r_refdef.view.matrix, forward, left, up, org);
1025
1026         if (v_isometric_flipcullface.integer)
1027         {
1028                 int a = r_refdef.view.cullface_front;
1029                 r_refdef.view.cullface_front = r_refdef.view.cullface_back;
1030                 r_refdef.view.cullface_back = a;
1031         }
1032 }
1033
1034
1035 void V_FadeViewFlashs(void)
1036 {
1037         // don't flash if time steps backwards
1038         if (cl.time <= cl.oldtime)
1039                 return;
1040         // drop the damage value
1041         cl.cshifts[CSHIFT_DAMAGE].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_DAMAGE].alphafade;
1042         if (cl.cshifts[CSHIFT_DAMAGE].percent <= 0)
1043                 cl.cshifts[CSHIFT_DAMAGE].percent = 0;
1044         // drop the bonus value
1045         cl.cshifts[CSHIFT_BONUS].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_BONUS].alphafade;
1046         if (cl.cshifts[CSHIFT_BONUS].percent <= 0)
1047                 cl.cshifts[CSHIFT_BONUS].percent = 0;
1048 }
1049
1050 void V_CalcViewBlend(void)
1051 {
1052         float a2;
1053         int j;
1054         r_refdef.viewblend[0] = 0;
1055         r_refdef.viewblend[1] = 0;
1056         r_refdef.viewblend[2] = 0;
1057         r_refdef.viewblend[3] = 0;
1058         r_refdef.frustumscale_x = 1;
1059         r_refdef.frustumscale_y = 1;
1060         if (cls.state == ca_connected && cls.signon == SIGNONS)
1061         {
1062                 // set contents color
1063                 int supercontents;
1064                 vec3_t vieworigin;
1065                 Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, vieworigin);
1066                 supercontents = CL_PointSuperContents(vieworigin);
1067                 if (supercontents & SUPERCONTENTS_LIQUIDSMASK)
1068                 {
1069                         r_refdef.frustumscale_x *= 1 - (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value);
1070                         r_refdef.frustumscale_y *= 1 - (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value);
1071                         if (supercontents & SUPERCONTENTS_LAVA)
1072                         {
1073                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 255;
1074                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
1075                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
1076                         }
1077                         else if (supercontents & SUPERCONTENTS_SLIME)
1078                         {
1079                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
1080                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 25;
1081                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 5;
1082                         }
1083                         else
1084                         {
1085                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 130;
1086                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
1087                                 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 50;
1088                         }
1089                         cl.cshifts[CSHIFT_CONTENTS].percent = 150 * 0.5;
1090                 }
1091                 else
1092                 {
1093                         cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
1094                         cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 0;
1095                         cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
1096                         cl.cshifts[CSHIFT_CONTENTS].percent = 0;
1097                 }
1098
1099                 if (gamemode != GAME_TRANSFUSION)
1100                 {
1101                         if (cl.stats[STAT_ITEMS] & IT_QUAD)
1102                         {
1103                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
1104                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 0;
1105                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 255;
1106                                 cl.cshifts[CSHIFT_POWERUP].percent = 30;
1107                         }
1108                         else if (cl.stats[STAT_ITEMS] & IT_SUIT)
1109                         {
1110                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
1111                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
1112                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
1113                                 cl.cshifts[CSHIFT_POWERUP].percent = 20;
1114                         }
1115                         else if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
1116                         {
1117                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 100;
1118                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 100;
1119                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 100;
1120                                 cl.cshifts[CSHIFT_POWERUP].percent = 100;
1121                         }
1122                         else if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)
1123                         {
1124                                 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 255;
1125                                 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
1126                                 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
1127                                 cl.cshifts[CSHIFT_POWERUP].percent = 30;
1128                         }
1129                         else
1130                                 cl.cshifts[CSHIFT_POWERUP].percent = 0;
1131                 }
1132
1133                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[0] = v_cshift.destcolor[0];
1134                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[1] = v_cshift.destcolor[1];
1135                 cl.cshifts[CSHIFT_VCSHIFT].destcolor[2] = v_cshift.destcolor[2];
1136                 cl.cshifts[CSHIFT_VCSHIFT].percent = v_cshift.percent;
1137
1138                 // LadyHavoc: fixed V_CalcBlend
1139                 for (j = 0;j < NUM_CSHIFTS;j++)
1140                 {
1141                         a2 = bound(0.0f, cl.cshifts[j].percent * (1.0f / 255.0f), 1.0f);
1142                         if (a2 > 0)
1143                         {
1144                                 VectorLerp(r_refdef.viewblend, a2, cl.cshifts[j].destcolor, r_refdef.viewblend);
1145                                 r_refdef.viewblend[3] = (1 - (1 - r_refdef.viewblend[3]) * (1 - a2)); // correct alpha multiply...  took a while to find it on the web
1146                         }
1147                 }
1148                 // saturate color (to avoid blending in black)
1149                 if (r_refdef.viewblend[3])
1150                 {
1151                         a2 = 1 / r_refdef.viewblend[3];
1152                         VectorScale(r_refdef.viewblend, a2, r_refdef.viewblend);
1153                 }
1154                 r_refdef.viewblend[0] = bound(0.0f, r_refdef.viewblend[0], 255.0f);
1155                 r_refdef.viewblend[1] = bound(0.0f, r_refdef.viewblend[1], 255.0f);
1156                 r_refdef.viewblend[2] = bound(0.0f, r_refdef.viewblend[2], 255.0f);
1157                 r_refdef.viewblend[3] = bound(0.0f, r_refdef.viewblend[3] * gl_polyblend.value, 1.0f);
1158                 if (vid.sRGB3D)
1159                 {
1160                         r_refdef.viewblend[0] = Image_LinearFloatFromsRGB(r_refdef.viewblend[0]);
1161                         r_refdef.viewblend[1] = Image_LinearFloatFromsRGB(r_refdef.viewblend[1]);
1162                         r_refdef.viewblend[2] = Image_LinearFloatFromsRGB(r_refdef.viewblend[2]);
1163                 }
1164                 else
1165                 {
1166                         r_refdef.viewblend[0] *= (1.0f/256.0f);
1167                         r_refdef.viewblend[1] *= (1.0f/256.0f);
1168                         r_refdef.viewblend[2] *= (1.0f/256.0f);
1169                 }
1170
1171                 // Samual: Ugly hack, I know. But it's the best we can do since
1172                 // there is no way to detect client states from the engine.
1173                 if (cl.stats[STAT_HEALTH] <= 0 && cl.stats[STAT_HEALTH] != -666 &&
1174                         cl.stats[STAT_HEALTH] != -2342 && cl_deathfade.value > 0)
1175                 {
1176                         cl.deathfade += cl_deathfade.value * max(0.00001, cl.time - cl.oldtime);
1177                         cl.deathfade = bound(0.0f, cl.deathfade, 0.9f);
1178                 }
1179                 else
1180                         cl.deathfade = 0.0f;
1181
1182                 if(cl.deathfade > 0)
1183                 {
1184                         float a;
1185                         float deathfadevec[3] = {0.3f, 0.0f, 0.0f};
1186                         a = r_refdef.viewblend[3] + cl.deathfade - r_refdef.viewblend[3]*cl.deathfade;
1187                         if(a > 0)
1188                                 VectorMAM(r_refdef.viewblend[3] * (1 - cl.deathfade) / a, r_refdef.viewblend, cl.deathfade / a, deathfadevec, r_refdef.viewblend);
1189                         r_refdef.viewblend[3] = a;
1190                 }
1191         }
1192 }
1193
1194 //============================================================================
1195
1196 /*
1197 =============
1198 V_Init
1199 =============
1200 */
1201 void V_Init (void)
1202 {
1203         Cmd_AddCommand(CMD_CLIENT | CMD_CLIENT_FROM_SERVER, "v_cshift", V_cshift_f, "sets tint color of view");
1204         Cmd_AddCommand(CMD_CLIENT | CMD_CLIENT_FROM_SERVER, "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");
1205         Cmd_AddCommand(CMD_CLIENT, "centerview", V_StartPitchDrift_f, "gradually recenter view (stop looking up/down)");
1206
1207         Cvar_RegisterVariable (&v_centermove);
1208         Cvar_RegisterVariable (&v_centerspeed);
1209
1210         Cvar_RegisterVariable (&v_iyaw_cycle);
1211         Cvar_RegisterVariable (&v_iroll_cycle);
1212         Cvar_RegisterVariable (&v_ipitch_cycle);
1213         Cvar_RegisterVariable (&v_iyaw_level);
1214         Cvar_RegisterVariable (&v_iroll_level);
1215         Cvar_RegisterVariable (&v_ipitch_level);
1216
1217         Cvar_RegisterVariable(&v_isometric);
1218         Cvar_RegisterVariable(&v_isometric_verticalfov);
1219         Cvar_RegisterVariable(&v_isometric_xx);
1220         Cvar_RegisterVariable(&v_isometric_xy);
1221         Cvar_RegisterVariable(&v_isometric_xz);
1222         Cvar_RegisterVariable(&v_isometric_yx);
1223         Cvar_RegisterVariable(&v_isometric_yy);
1224         Cvar_RegisterVariable(&v_isometric_yz);
1225         Cvar_RegisterVariable(&v_isometric_zx);
1226         Cvar_RegisterVariable(&v_isometric_zy);
1227         Cvar_RegisterVariable(&v_isometric_zz);
1228         Cvar_RegisterVariable(&v_isometric_tx);
1229         Cvar_RegisterVariable(&v_isometric_ty);
1230         Cvar_RegisterVariable(&v_isometric_tz);
1231         Cvar_RegisterVariable(&v_isometric_rot_pitch);
1232         Cvar_RegisterVariable(&v_isometric_rot_yaw);
1233         Cvar_RegisterVariable(&v_isometric_rot_roll);
1234         Cvar_RegisterVariable(&v_isometric_relx);
1235         Cvar_RegisterVariable(&v_isometric_rely);
1236         Cvar_RegisterVariable(&v_isometric_relz);
1237         Cvar_RegisterVariable(&v_isometric_flipcullface);
1238         Cvar_RegisterVariable(&v_isometric_locked_orientation);
1239         Cvar_RegisterVariable(&v_isometric_usevieworiginculling);
1240
1241         Cvar_RegisterVariable (&v_idlescale);
1242         Cvar_RegisterVariable (&crosshair);
1243
1244         Cvar_RegisterVariable (&cl_rollspeed);
1245         Cvar_RegisterVariable (&cl_rollangle);
1246         Cvar_RegisterVariable (&cl_bob);
1247         Cvar_RegisterVariable (&cl_bobcycle);
1248         Cvar_RegisterVariable (&cl_bobup);
1249         Cvar_RegisterVariable (&cl_bob2);
1250         Cvar_RegisterVariable (&cl_bob2cycle);
1251         Cvar_RegisterVariable (&cl_bob2smooth);
1252         Cvar_RegisterVariable (&cl_bobfall);
1253         Cvar_RegisterVariable (&cl_bobfallcycle);
1254         Cvar_RegisterVariable (&cl_bobfallminspeed);
1255         Cvar_RegisterVariable (&cl_bobmodel);
1256         Cvar_RegisterVariable (&cl_bobmodel_side);
1257         Cvar_RegisterVariable (&cl_bobmodel_up);
1258         Cvar_RegisterVariable (&cl_bobmodel_speed);
1259         Cvar_RegisterVariable (&cl_bob_limit);
1260         Cvar_RegisterVariable (&cl_bob_limit_heightcheck);
1261         Cvar_RegisterVariable (&cl_bob_limit_heightcheck_dontcrosswatersurface);
1262         Cvar_RegisterVariable (&cl_bob_velocity_limit);
1263
1264         Cvar_RegisterVariable (&cl_leanmodel);
1265         Cvar_RegisterVariable (&cl_leanmodel_side_speed);
1266         Cvar_RegisterVariable (&cl_leanmodel_side_limit);
1267         Cvar_RegisterVariable (&cl_leanmodel_side_highpass1);
1268         Cvar_RegisterVariable (&cl_leanmodel_side_lowpass);
1269         Cvar_RegisterVariable (&cl_leanmodel_side_highpass);
1270         Cvar_RegisterVariable (&cl_leanmodel_up_speed);
1271         Cvar_RegisterVariable (&cl_leanmodel_up_limit);
1272         Cvar_RegisterVariable (&cl_leanmodel_up_highpass1);
1273         Cvar_RegisterVariable (&cl_leanmodel_up_lowpass);
1274         Cvar_RegisterVariable (&cl_leanmodel_up_highpass);
1275
1276         Cvar_RegisterVariable (&cl_followmodel);
1277         Cvar_RegisterVariable (&cl_followmodel_side_speed);
1278         Cvar_RegisterVariable (&cl_followmodel_side_limit);
1279         Cvar_RegisterVariable (&cl_followmodel_side_highpass1);
1280         Cvar_RegisterVariable (&cl_followmodel_side_lowpass);
1281         Cvar_RegisterVariable (&cl_followmodel_side_highpass);
1282         Cvar_RegisterVariable (&cl_followmodel_up_speed);
1283         Cvar_RegisterVariable (&cl_followmodel_up_limit);
1284         Cvar_RegisterVariable (&cl_followmodel_up_highpass1);
1285         Cvar_RegisterVariable (&cl_followmodel_up_lowpass);
1286         Cvar_RegisterVariable (&cl_followmodel_up_highpass);
1287
1288         Cvar_RegisterVariable (&cl_viewmodel_scale);
1289
1290         Cvar_RegisterVariable (&v_kicktime);
1291         Cvar_RegisterVariable (&v_kickroll);
1292         Cvar_RegisterVariable (&v_kickpitch);
1293
1294         Cvar_RegisterVariable (&cl_stairsmoothspeed);
1295
1296         Cvar_RegisterVariable (&cl_smoothviewheight);
1297
1298         Cvar_RegisterVariable (&chase_back);
1299         Cvar_RegisterVariable (&chase_up);
1300         Cvar_RegisterVariable (&chase_active);
1301         Cvar_RegisterVariable (&chase_overhead);
1302         Cvar_RegisterVariable (&chase_pitchangle);
1303         Cvar_RegisterVariable (&chase_stevie);
1304
1305         Cvar_RegisterVariable (&v_deathtilt);
1306         Cvar_RegisterVariable (&v_deathtiltangle);
1307
1308         Cvar_RegisterVariable (&v_yshearing);
1309 }
1310