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