view.c

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