2 Copyright (C) 1996-1997 Id Software, Inc.
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.
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.
13 See the GNU General Public License for more details.
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.
20 // view.c -- player eye positioning
23 #include "cl_collision.h"
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.
35 cvar_t cl_rollspeed = {0, "cl_rollspeed", "200", "how much strafing is necessary to tilt the view"};
36 cvar_t cl_rollangle = {0, "cl_rollangle", "2.0", "how much to tilt the view when strafing"};
38 cvar_t cl_bob = {CVAR_SAVE, "cl_bob","0.02", "view bobbing amount"};
39 cvar_t cl_bobcycle = {CVAR_SAVE, "cl_bobcycle","0.6", "view bobbing speed"};
40 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"};
41 cvar_t cl_bob2 = {CVAR_SAVE, "cl_bob2","0", "sideways view bobbing amount"};
42 cvar_t cl_bob2cycle = {CVAR_SAVE, "cl_bob2cycle","0.6", "sideways view bobbing speed"};
43 cvar_t cl_bob2smooth = {CVAR_SAVE, "cl_bob2smooth","0.05", "how fast the view goes back when you stop touching the ground"};
44 cvar_t cl_bobfall = {CVAR_SAVE, "cl_bobfall","0", "how much the view swings down when falling (influenced by the speed you hit the ground with)"};
45 cvar_t cl_bobfallcycle = {CVAR_SAVE, "cl_bobfallcycle","3", "speed of the bobfall swing"};
46 cvar_t cl_bobfallminspeed = {CVAR_SAVE, "cl_bobfallminspeed","200", "necessary amount of speed for bob-falling to occur"};
47 cvar_t cl_bobmodel = {CVAR_SAVE, "cl_bobmodel", "1", "enables gun bobbing"};
48 cvar_t cl_bobmodel_side = {CVAR_SAVE, "cl_bobmodel_side", "0.15", "gun bobbing sideways sway amount"};
49 cvar_t cl_bobmodel_up = {CVAR_SAVE, "cl_bobmodel_up", "0.06", "gun bobbing upward movement amount"};
50 cvar_t cl_bobmodel_speed = {CVAR_SAVE, "cl_bobmodel_speed", "7", "gun bobbing speed"};
51 cvar_t cl_bob_limit = {CVAR_SAVE, "cl_bob_limit", "7", "limits bobbing to this much distance from view_ofs"};
52 cvar_t cl_bob_limit_heightcheck = {CVAR_SAVE, "cl_bob_limit_heightcheck", "0", "check ceiling and floor height against cl_bob_limit and scale down all view bobbing if could result in camera being in solid"};
53 cvar_t cl_bob_limit_heightcheck_dontcrosswatersurface = {CVAR_SAVE, "cl_bob_limit_heightcheck_dontcrosswatersurface", "1", "limit cl_bob_limit to not crossing liquid surfaces also"};
54 cvar_t cl_bob_velocity_limit = {CVAR_SAVE, "cl_bob_velocity_limit", "400", "limits the xyspeed value in the bobbing code"};
56 cvar_t cl_leanmodel = {CVAR_SAVE, "cl_leanmodel", "0", "enables gun leaning"};
57 cvar_t cl_leanmodel_side_speed = {CVAR_SAVE, "cl_leanmodel_side_speed", "0.7", "gun leaning sideways speed"};
58 cvar_t cl_leanmodel_side_limit = {CVAR_SAVE, "cl_leanmodel_side_limit", "35", "gun leaning sideways limit"};
59 cvar_t cl_leanmodel_side_highpass1 = {CVAR_SAVE, "cl_leanmodel_side_highpass1", "30", "gun leaning sideways pre-highpass in 1/s"};
60 cvar_t cl_leanmodel_side_highpass = {CVAR_SAVE, "cl_leanmodel_side_highpass", "3", "gun leaning sideways highpass in 1/s"};
61 cvar_t cl_leanmodel_side_lowpass = {CVAR_SAVE, "cl_leanmodel_side_lowpass", "20", "gun leaning sideways lowpass in 1/s"};
62 cvar_t cl_leanmodel_up_speed = {CVAR_SAVE, "cl_leanmodel_up_speed", "0.65", "gun leaning upward speed"};
63 cvar_t cl_leanmodel_up_limit = {CVAR_SAVE, "cl_leanmodel_up_limit", "50", "gun leaning upward limit"};
64 cvar_t cl_leanmodel_up_highpass1 = {CVAR_SAVE, "cl_leanmodel_up_highpass1", "5", "gun leaning upward pre-highpass in 1/s"};
65 cvar_t cl_leanmodel_up_highpass = {CVAR_SAVE, "cl_leanmodel_up_highpass", "15", "gun leaning upward highpass in 1/s"};
66 cvar_t cl_leanmodel_up_lowpass = {CVAR_SAVE, "cl_leanmodel_up_lowpass", "20", "gun leaning upward lowpass in 1/s"};
68 cvar_t cl_followmodel = {CVAR_SAVE, "cl_followmodel", "0", "enables gun following"};
69 cvar_t cl_followmodel_side_speed = {CVAR_SAVE, "cl_followmodel_side_speed", "0.25", "gun following sideways speed"};
70 cvar_t cl_followmodel_side_limit = {CVAR_SAVE, "cl_followmodel_side_limit", "6", "gun following sideways limit"};
71 cvar_t cl_followmodel_side_highpass1 = {CVAR_SAVE, "cl_followmodel_side_highpass1", "30", "gun following sideways pre-highpass in 1/s"};
72 cvar_t cl_followmodel_side_highpass = {CVAR_SAVE, "cl_followmodel_side_highpass", "5", "gun following sideways highpass in 1/s"};
73 cvar_t cl_followmodel_side_lowpass = {CVAR_SAVE, "cl_followmodel_side_lowpass", "10", "gun following sideways lowpass in 1/s"};
74 cvar_t cl_followmodel_up_speed = {CVAR_SAVE, "cl_followmodel_up_speed", "0.5", "gun following upward speed"};
75 cvar_t cl_followmodel_up_limit = {CVAR_SAVE, "cl_followmodel_up_limit", "5", "gun following upward limit"};
76 cvar_t cl_followmodel_up_highpass1 = {CVAR_SAVE, "cl_followmodel_up_highpass1", "60", "gun following upward pre-highpass in 1/s"};
77 cvar_t cl_followmodel_up_highpass = {CVAR_SAVE, "cl_followmodel_up_highpass", "2", "gun following upward highpass in 1/s"};
78 cvar_t cl_followmodel_up_lowpass = {CVAR_SAVE, "cl_followmodel_up_lowpass", "10", "gun following upward lowpass in 1/s"};
80 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"};
82 cvar_t v_kicktime = {0, "v_kicktime", "0.5", "how long a view kick from damage lasts"};
83 cvar_t v_kickroll = {0, "v_kickroll", "0.6", "how much a view kick from damage rolls your view"};
84 cvar_t v_kickpitch = {0, "v_kickpitch", "0.6", "how much a view kick from damage pitches your view"};
86 cvar_t v_iyaw_cycle = {0, "v_iyaw_cycle", "2", "v_idlescale yaw speed"};
87 cvar_t v_iroll_cycle = {0, "v_iroll_cycle", "0.5", "v_idlescale roll speed"};
88 cvar_t v_ipitch_cycle = {0, "v_ipitch_cycle", "1", "v_idlescale pitch speed"};
89 cvar_t v_iyaw_level = {0, "v_iyaw_level", "0.3", "v_idlescale yaw amount"};
90 cvar_t v_iroll_level = {0, "v_iroll_level", "0.1", "v_idlescale roll amount"};
91 cvar_t v_ipitch_level = {0, "v_ipitch_level", "0.3", "v_idlescale pitch amount"};
93 cvar_t v_idlescale = {0, "v_idlescale", "0", "how much of the quake 'drunken view' effect to use"};
95 cvar_t v_isometric = {0, "v_isometric", "0", "changes view to isometric (non-perspective)"};
96 cvar_t v_isometric_verticalfov = { 0, "v_isometric_verticalfov", "512", "vertical field of view in game units (horizontal is computed using aspect ratio based on this)"};
97 cvar_t v_isometric_xx = {0, "v_isometric_xx", "1", "camera matrix"};
98 cvar_t v_isometric_xy = {0, "v_isometric_xy", "0", "camera matrix"};
99 cvar_t v_isometric_xz = {0, "v_isometric_xz", "0", "camera matrix"};
100 cvar_t v_isometric_yx = {0, "v_isometric_yx", "0", "camera matrix"};
101 cvar_t v_isometric_yy = {0, "v_isometric_yy", "1", "camera matrix"};
102 cvar_t v_isometric_yz = {0, "v_isometric_yz", "0", "camera matrix"};
103 cvar_t v_isometric_zx = {0, "v_isometric_zx", "0", "camera matrix"};
104 cvar_t v_isometric_zy = {0, "v_isometric_zy", "0", "camera matrix"};
105 cvar_t v_isometric_zz = {0, "v_isometric_zz", "1", "camera matrix"};
106 cvar_t v_isometric_tx = {0, "v_isometric_tx", "0", "camera position (player-relative)"};
107 cvar_t v_isometric_ty = {0, "v_isometric_ty", "0", "camera position (player-relative)"};
108 cvar_t v_isometric_tz = {0, "v_isometric_tz", "0", "camera position (player-relative)"};
109 cvar_t v_isometric_rot_pitch = {0, "v_isometric_rot_pitch", "60", "camera rotation"};
110 cvar_t v_isometric_rot_yaw = {0, "v_isometric_rot_yaw", "135", "camera rotation"};
111 cvar_t v_isometric_rot_roll = {0, "v_isometric_rot_roll", "0", "camera rotation"};
112 cvar_t v_isometric_relx = {0, "v_isometric_relx", "0", "camera position*forward"};
113 cvar_t v_isometric_rely = {0, "v_isometric_rely", "0", "camera position*left"};
114 cvar_t v_isometric_relz = {0, "v_isometric_relz", "0", "camera position*up"};
115 cvar_t v_isometric_flipcullface = {0, "v_isometric_flipcullface", "0", "flips the backface culling"};
116 cvar_t v_isometric_locked_orientation = {0, "v_isometric_locked_orientation", "1", "camera rotation is fixed"};
117 cvar_t v_isometric_usevieworiginculling = {0, "v_isometric_usevieworiginculling", "0", "check visibility to the player location (can look pretty weird)"};
119 cvar_t crosshair = {CVAR_SAVE, "crosshair", "0", "selects crosshair to use (0 is none)"};
121 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)"};
122 cvar_t v_centerspeed = {0, "v_centerspeed","500", "how fast the view centers itself"};
124 cvar_t cl_stairsmoothspeed = {CVAR_SAVE, "cl_stairsmoothspeed", "160", "how fast your view moves upward/downward when running up/down stairs"};
126 cvar_t cl_smoothviewheight = {CVAR_SAVE, "cl_smoothviewheight", "0", "time of the averaging to the viewheight value so that it creates a smooth transition. higher values = longer transition, 0 for instant transition."};
128 cvar_t chase_back = {CVAR_SAVE, "chase_back", "48", "chase cam distance from the player"};
129 cvar_t chase_up = {CVAR_SAVE, "chase_up", "24", "chase cam distance from the player"};
130 cvar_t chase_active = {CVAR_SAVE, "chase_active", "0", "enables chase cam"};
131 cvar_t chase_overhead = {CVAR_SAVE, "chase_overhead", "0", "chase cam looks straight down if this is not zero"};
133 cvar_t chase_stevie = {0, "chase_stevie", "0", "(GOODVSBAD2 only) chase cam view from above"};
135 cvar_t v_deathtilt = {0, "v_deathtilt", "1", "whether to use sideways view when dead"};
136 cvar_t v_deathtiltangle = {0, "v_deathtiltangle", "80", "what roll angle to use when tilting the view while dead"};
138 // Prophecy camera pitchangle by Alexander "motorsep" Zubov
139 cvar_t chase_pitchangle = {CVAR_SAVE, "chase_pitchangle", "55", "chase cam pitch angle"};
141 cvar_t v_yshearing = {0, "v_yshearing", "0", "be all out of gum (set this to the maximum angle to allow Y shearing for - try values like 75)"};
143 float v_dmg_time, v_dmg_roll, v_dmg_pitch;
150 Used by view and sv_user
153 float V_CalcRoll (const vec3_t angles, const vec3_t velocity)
160 AngleVectors (angles, NULL, right, NULL);
161 side = DotProduct (velocity, right);
162 sign = side < 0 ? -1 : 1;
165 value = cl_rollangle.value;
167 if (side < cl_rollspeed.value)
168 side = side * value / cl_rollspeed.value;
176 void V_StartPitchDrift (void)
178 if (cl.laststop == cl.time)
179 return; // something else is keeping it from drifting
181 if (cl.nodrift || !cl.pitchvel)
183 cl.pitchvel = v_centerspeed.value;
189 void V_StopPitchDrift (void)
191 cl.laststop = cl.time;
200 Moves the client pitch angle towards cl.idealpitch sent by the server.
202 If the user is adjusting pitch manually, either with lookup/lookdown,
203 mlook and mouse, or klook and keyboard, pitch drifting is constantly stopped.
205 Drifting is enabled when the center view key is hit, mlook is released and
206 lookspring is non 0, or when
209 void V_DriftPitch (void)
213 if (noclip_anglehack || !cl.onground || cls.demoplayback )
220 // don't count small mouse motion
223 if ( fabs(cl.cmd.forwardmove) < cl_forwardspeed.value)
226 cl.driftmove += cl.realframetime;
228 if ( cl.driftmove > v_centermove.value)
230 V_StartPitchDrift ();
235 delta = cl.idealpitch - cl.viewangles[PITCH];
243 move = cl.realframetime * cl.pitchvel;
244 cl.pitchvel += cl.realframetime * v_centerspeed.value;
253 cl.viewangles[PITCH] += move;
262 cl.viewangles[PITCH] -= move;
268 ==============================================================================
272 ==============================================================================
281 void V_ParseDamage (void)
285 //vec3_t forward, right;
291 armor = MSG_ReadByte(&cl_message);
292 blood = MSG_ReadByte(&cl_message);
293 MSG_ReadVector(&cl_message, from, cls.protocol);
295 // Send the Dmg Globals to CSQC
296 CL_VM_UpdateDmgGlobals(blood, armor, from);
298 count = blood*0.5 + armor*0.5;
302 cl.faceanimtime = cl.time + 0.2; // put sbar face into pain frame
304 cl.cshifts[CSHIFT_DAMAGE].percent += 3*count;
305 cl.cshifts[CSHIFT_DAMAGE].alphafade = 150;
306 if (cl.cshifts[CSHIFT_DAMAGE].percent < 0)
307 cl.cshifts[CSHIFT_DAMAGE].percent = 0;
308 if (cl.cshifts[CSHIFT_DAMAGE].percent > 150)
309 cl.cshifts[CSHIFT_DAMAGE].percent = 150;
313 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 200;
314 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 100;
315 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 100;
319 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 220;
320 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 50;
321 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 50;
325 cl.cshifts[CSHIFT_DAMAGE].destcolor[0] = 255;
326 cl.cshifts[CSHIFT_DAMAGE].destcolor[1] = 0;
327 cl.cshifts[CSHIFT_DAMAGE].destcolor[2] = 0;
330 // calculate view angle kicks
331 if (cl.entities[cl.viewentity].state_current.active)
333 ent = &cl.entities[cl.viewentity];
334 Matrix4x4_Transform(&ent->render.inversematrix, from, localfrom);
335 VectorNormalize(localfrom);
336 v_dmg_pitch = count * localfrom[0] * v_kickpitch.value;
337 v_dmg_roll = count * localfrom[1] * v_kickroll.value;
338 v_dmg_time = v_kicktime.value;
342 static cshift_t v_cshift;
349 static void V_cshift_f (void)
351 v_cshift.destcolor[0] = atof(Cmd_Argv(1));
352 v_cshift.destcolor[1] = atof(Cmd_Argv(2));
353 v_cshift.destcolor[2] = atof(Cmd_Argv(3));
354 v_cshift.percent = atof(Cmd_Argv(4));
362 When you run over an item, the server sends this command
365 static void V_BonusFlash_f (void)
369 cl.cshifts[CSHIFT_BONUS].destcolor[0] = 215;
370 cl.cshifts[CSHIFT_BONUS].destcolor[1] = 186;
371 cl.cshifts[CSHIFT_BONUS].destcolor[2] = 69;
372 cl.cshifts[CSHIFT_BONUS].percent = 50;
373 cl.cshifts[CSHIFT_BONUS].alphafade = 100;
375 else if(Cmd_Argc() >= 4 && Cmd_Argc() <= 6)
377 cl.cshifts[CSHIFT_BONUS].destcolor[0] = atof(Cmd_Argv(1)) * 255;
378 cl.cshifts[CSHIFT_BONUS].destcolor[1] = atof(Cmd_Argv(2)) * 255;
379 cl.cshifts[CSHIFT_BONUS].destcolor[2] = atof(Cmd_Argv(3)) * 255;
381 cl.cshifts[CSHIFT_BONUS].percent = atof(Cmd_Argv(4)) * 255; // yes, these are HEXADECIMAL percent ;)
383 cl.cshifts[CSHIFT_BONUS].percent = 50;
385 cl.cshifts[CSHIFT_BONUS].alphafade = atof(Cmd_Argv(5)) * 255;
387 cl.cshifts[CSHIFT_BONUS].alphafade = 100;
390 Con_Printf("usage:\nbf, or bf R G B [A [alphafade]]\n");
394 ==============================================================================
398 ==============================================================================
401 extern matrix4x4_t viewmodelmatrix_nobob;
402 extern matrix4x4_t viewmodelmatrix_withbob;
404 #include "cl_collision.h"
414 static vec3_t eyeboxmins = {-16, -16, -24};
415 static vec3_t eyeboxmaxs = { 16, 16, 32};
418 static vec_t lowpass(vec_t value, vec_t frac, vec_t *store)
420 frac = bound(0, frac, 1);
421 return (*store = *store * (1 - frac) + value * frac);
424 static vec_t lowpass_limited(vec_t value, vec_t frac, vec_t limit, vec_t *store)
426 lowpass(value, frac, store);
427 return (*store = bound(value - limit, *store, value + limit));
430 static vec_t highpass(vec_t value, vec_t frac, vec_t *store)
432 return value - lowpass(value, frac, store);
435 static vec_t highpass_limited(vec_t value, vec_t frac, vec_t limit, vec_t *store)
437 return value - lowpass_limited(value, frac, limit, store);
440 static void lowpass3(vec3_t value, vec_t fracx, vec_t fracy, vec_t fracz, vec3_t store, vec3_t out)
442 out[0] = lowpass(value[0], fracx, &store[0]);
443 out[1] = lowpass(value[1], fracy, &store[1]);
444 out[2] = lowpass(value[2], fracz, &store[2]);
447 static void highpass3(vec3_t value, vec_t fracx, vec_t fracy, vec_t fracz, vec3_t store, vec3_t out)
449 out[0] = highpass(value[0], fracx, &store[0]);
450 out[1] = highpass(value[1], fracy, &store[1]);
451 out[2] = highpass(value[2], fracz, &store[2]);
454 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)
456 out[0] = highpass_limited(value[0], fracx, limitx, &store[0]);
457 out[1] = highpass_limited(value[1], fracy, limity, &store[1]);
458 out[2] = highpass_limited(value[2], fracz, limitz, &store[2]);
466 * cl.gunangles_adjustment_highpass
467 * cl.gunangles_adjustment_lowpass
468 * cl.gunangles_highpass
470 * cl.gunorg_adjustment_highpass
471 * cl.gunorg_adjustment_lowpass
475 * cl.lastongroundtime
479 * cl.calcrefdef_prevtime
482 * cl.movevars_stepheight
483 * cl.movevars_timescale
487 * cl.qw_intermission_angles
488 * cl.qw_intermission_origin
493 * cl.csqc_viewanglesfromengine
494 * cl.csqc_viewmodelmatrixfromengine
495 * cl.csqc_vieworiginfromengine
496 * r_refdef.view.matrix
497 * viewmodelmatrix_nobob
498 * viewmodelmatrix_withbob
500 void V_CalcRefdefUsing (const matrix4x4_t *entrendermatrix, const vec3_t clviewangles, qboolean teleported, qboolean clonground, qboolean clcmdjump, float clstatsviewheight, qboolean cldead, qboolean clintermission, const vec3_t clvelocity)
502 float vieworg[3], viewangles[3], smoothtime;
503 float gunorg[3], gunangles[3];
504 matrix4x4_t tmpmatrix;
506 static float viewheightavg;
509 // begin of chase camera bounding box size for proper collisions by Alexander Zubov
510 vec3_t camboxmins = {-3, -3, -3};
511 vec3_t camboxmaxs = {3, 3, 3};
512 // end of chase camera bounding box size for proper collisions by Alexander Zubov
516 // react to clonground state changes (for gun bob)
520 cl.hitgroundtime = cl.movecmd[0].time;
521 cl.lastongroundtime = cl.movecmd[0].time;
523 cl.oldonground = clonground;
524 cl.calcrefdef_prevtime = max(cl.calcrefdef_prevtime, cl.oldtime);
526 VectorClear(gunangles);
528 viewmodelmatrix_nobob = identitymatrix;
529 viewmodelmatrix_withbob = identitymatrix;
530 r_refdef.view.matrix = identitymatrix;
532 // player can look around, so take the origin from the entity,
533 // and the angles from the input system
534 Matrix4x4_OriginFromMatrix(entrendermatrix, vieworg);
535 VectorCopy(clviewangles, viewangles);
537 // calculate how much time has passed since the last V_CalcRefdef
538 smoothtime = bound(0, cl.time - cl.stairsmoothtime, 0.1);
539 cl.stairsmoothtime = cl.time;
543 v_dmg_time -= bound(0, smoothtime, 0.1);
547 // entity is a fixed camera, just copy the matrix
548 if (cls.protocol == PROTOCOL_QUAKEWORLD)
549 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);
552 r_refdef.view.matrix = *entrendermatrix;
553 Matrix4x4_AdjustOrigin(&r_refdef.view.matrix, 0, 0, clstatsviewheight);
555 if (v_yshearing.value > 0)
556 Matrix4x4_QuakeToDuke3D(&r_refdef.view.matrix, &r_refdef.view.matrix, v_yshearing.value);
557 Matrix4x4_Copy(&viewmodelmatrix_nobob, &r_refdef.view.matrix);
558 Matrix4x4_ConcatScale(&viewmodelmatrix_nobob, cl_viewmodel_scale.value);
559 Matrix4x4_Copy(&viewmodelmatrix_withbob, &viewmodelmatrix_nobob);
561 VectorCopy(vieworg, cl.csqc_vieworiginfromengine);
562 VectorCopy(viewangles, cl.csqc_viewanglesfromengine);
564 Matrix4x4_Invert_Simple(&tmpmatrix, &r_refdef.view.matrix);
565 Matrix4x4_CreateScale(&cl.csqc_viewmodelmatrixfromengine, cl_viewmodel_scale.value);
569 // smooth stair stepping, but only if clonground and enabled
570 if (!clonground || cl_stairsmoothspeed.value <= 0 || teleported)
571 cl.stairsmoothz = vieworg[2];
574 if (cl.stairsmoothz < vieworg[2])
575 vieworg[2] = cl.stairsmoothz = bound(vieworg[2] - cl.movevars_stepheight, cl.stairsmoothz + smoothtime * cl_stairsmoothspeed.value, vieworg[2]);
576 else if (cl.stairsmoothz > vieworg[2])
577 vieworg[2] = cl.stairsmoothz = bound(vieworg[2], cl.stairsmoothz - smoothtime * cl_stairsmoothspeed.value, vieworg[2] + cl.movevars_stepheight);
580 // apply qw weapon recoil effect (this did not work in QW)
581 // TODO: add a cvar to disable this
582 viewangles[PITCH] += cl.qw_weaponkick;
584 // apply the viewofs (even if chasecam is used)
585 // Samual: Lets add smoothing for this too so that things like crouching are done with a transition.
586 viewheight = bound(0, (cl.time - cl.calcrefdef_prevtime) / max(0.0001, cl_smoothviewheight.value), 1);
587 viewheightavg = viewheightavg * (1 - viewheight) + clstatsviewheight * viewheight;
588 vieworg[2] += viewheightavg;
590 if (chase_active.value)
592 // observing entity from third person. Added "campitch" by Alexander "motorsep" Zubov
593 vec_t camback, camup, dist, campitch, forward[3], chase_dest[3];
595 camback = chase_back.value;
596 camup = chase_up.value;
597 campitch = chase_pitchangle.value;
599 AngleVectors(viewangles, forward, NULL, NULL);
601 if (chase_overhead.integer)
608 viewangles[PITCH] = 0;
609 AngleVectors(viewangles, forward, NULL, up);
610 // trace a little further so it hits a surface more consistently (to avoid 'snapping' on the edge of the range)
611 chase_dest[0] = vieworg[0] - forward[0] * camback + up[0] * camup;
612 chase_dest[1] = vieworg[1] - forward[1] * camback + up[1] * camup;
613 chase_dest[2] = vieworg[2] - forward[2] * camback + up[2] * camup;
616 //trace = CL_TraceLine(vieworg, eyeboxmins, eyeboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, true, false, NULL, false);
617 trace = CL_TraceLine(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, true, false, NULL, false);
619 //trace = CL_TraceBox(vieworg, eyeboxmins, eyeboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, true, false, NULL, false);
620 trace = CL_TraceBox(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, true, false, NULL, false);
622 VectorCopy(trace.endpos, vieworg);
625 // trace from first person view location to our chosen third person view location
627 trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
629 trace = CL_TraceBox(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false);
631 VectorCopy(trace.endpos, bestvieworg);
633 for (offset[0] = -16;offset[0] <= 16;offset[0] += 8)
635 for (offset[1] = -16;offset[1] <= 16;offset[1] += 8)
637 AngleVectors(viewangles, NULL, NULL, up);
638 chase_dest[0] = vieworg[0] - forward[0] * camback + up[0] * camup + offset[0];
639 chase_dest[1] = vieworg[1] - forward[1] * camback + up[1] * camup + offset[1];
640 chase_dest[2] = vieworg[2] - forward[2] * camback + up[2] * camup + offset[2];
642 trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
644 trace = CL_TraceBox(vieworg, camboxmins, camboxmaxs, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false);
646 if (bestvieworg[2] > trace.endpos[2])
647 bestvieworg[2] = trace.endpos[2];
651 VectorCopy(bestvieworg, vieworg);
653 viewangles[PITCH] = campitch;
657 if (gamemode == GAME_GOODVSBAD2 && chase_stevie.integer)
659 // look straight down from high above
660 viewangles[PITCH] = 90;
662 VectorSet(forward, 0, 0, -1);
665 // trace a little further so it hits a surface more consistently (to avoid 'snapping' on the edge of the range)
667 chase_dest[0] = vieworg[0] + forward[0] * dist;
668 chase_dest[1] = vieworg[1] + forward[1] * dist;
669 chase_dest[2] = vieworg[2] + forward[2] * dist + camup;
670 trace = CL_TraceLine(vieworg, chase_dest, MOVE_NOMONSTERS, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_SKY, 0, MATERIALFLAGMASK_TRANSLUCENT, collision_extendmovelength.value, true, false, NULL, false, true);
671 VectorMAMAM(1, trace.endpos, 8, forward, 4, trace.plane.normal, vieworg);
676 // first person view from entity
678 if (cldead && v_deathtilt.integer)
679 viewangles[ROLL] = v_deathtiltangle.value;
680 VectorAdd(viewangles, cl.punchangle, viewangles);
681 viewangles[ROLL] += V_CalcRoll(clviewangles, clvelocity);
684 viewangles[ROLL] += v_dmg_time/v_kicktime.value*v_dmg_roll;
685 viewangles[PITCH] += v_dmg_time/v_kicktime.value*v_dmg_pitch;
688 VectorAdd(vieworg, cl.punchvector, vieworg);
691 double xyspeed, bob, bobfall;
692 double cycle; // double-precision because cl.time can be a very large number, where float would get stuttery at high time values
695 frametime = (cl.time - cl.calcrefdef_prevtime) * cl.movevars_timescale;
697 if(cl_followmodel.integer || cl_leanmodel.integer)
699 // 1. if we teleported, clear the frametime... the lowpass will recover the previous value then
702 // try to fix the first highpass; result is NOT
703 // perfect! TODO find a better fix
704 VectorCopy(viewangles, cl.gunangles_prev);
705 VectorCopy(vieworg, cl.gunorg_prev);
708 // 2. for the gun origin, only keep the high frequency (non-DC) parts, which is "somewhat like velocity"
709 VectorAdd(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
710 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);
711 VectorCopy(vieworg, cl.gunorg_prev);
712 VectorSubtract(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
714 // in the highpass, we _store_ the DIFFERENCE to the actual view angles...
715 VectorAdd(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
716 cl.gunangles_highpass[PITCH] += 360 * floor((viewangles[PITCH] - cl.gunangles_highpass[PITCH]) / 360 + 0.5);
717 cl.gunangles_highpass[YAW] += 360 * floor((viewangles[YAW] - cl.gunangles_highpass[YAW]) / 360 + 0.5);
718 cl.gunangles_highpass[ROLL] += 360 * floor((viewangles[ROLL] - cl.gunangles_highpass[ROLL]) / 360 + 0.5);
719 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);
720 VectorCopy(viewangles, cl.gunangles_prev);
721 VectorSubtract(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
723 // 3. calculate the RAW adjustment vectors
724 gunorg[0] *= -cl_followmodel_side_speed.value;
725 gunorg[1] *= -cl_followmodel_side_speed.value;
726 gunorg[2] *= -cl_followmodel_up_speed.value;
728 gunangles[PITCH] *= -cl_leanmodel_up_speed.value;
729 gunangles[YAW] *= -cl_leanmodel_side_speed.value;
732 // 4. perform highpass/lowpass on the adjustment vectors (turning velocity into acceleration!)
733 // trick: we must do the lowpass LAST, so the lowpass vector IS the final vector!
734 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);
735 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);
736 // we assume here: PITCH = 0, YAW = 1, ROLL = 2
737 highpass3(gunangles, frametime*cl_leanmodel_up_highpass.value, frametime*cl_leanmodel_side_highpass.value, 0, cl.gunangles_adjustment_highpass, gunangles);
738 lowpass3(gunangles, frametime*cl_leanmodel_up_lowpass.value, frametime*cl_leanmodel_side_lowpass.value, 0, cl.gunangles_adjustment_lowpass, gunangles);
740 // 5. use the adjusted vectors
741 VectorAdd(vieworg, gunorg, gunorg);
742 VectorAdd(viewangles, gunangles, gunangles);
746 // Just initialize gunorg/gunangles.
747 VectorCopy(vieworg, gunorg);
748 VectorCopy(viewangles, gunangles);
751 // bounded XY speed, used by several effects below
752 xyspeed = bound (0, sqrt(clvelocity[0]*clvelocity[0] + clvelocity[1]*clvelocity[1]), cl_bob_velocity_limit.value);
754 // vertical view bobbing code
755 if (cl_bob.value && cl_bobcycle.value)
757 float bob_limit = cl_bob_limit.value;
759 if (cl_bob_limit_heightcheck.integer)
761 // use traces to determine what range the view can bob in, and scale down the bob as needed
762 float trace1fraction;
763 float trace2fraction;
764 vec3_t bob_height_check_dest;
766 // 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
767 bob_height_check_dest[0] = vieworg[0];
768 bob_height_check_dest[1] = vieworg[1];
769 bob_height_check_dest[2] = vieworg[2] + cl_bob_limit.value * 1.1f;
770 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);
771 trace1fraction = trace.fraction;
773 bob_height_check_dest[0] = vieworg[0];
774 bob_height_check_dest[1] = vieworg[1];
775 bob_height_check_dest[2] = vieworg[2] + cl_bob_limit.value * -0.5f;
776 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);
777 trace2fraction = trace.fraction;
779 bob_limit *= min(trace1fraction, trace2fraction);
782 // LordHavoc: this code is *weird*, but not replacable (I think it
783 // should be done in QC on the server, but oh well, quake is quake)
784 // LordHavoc: figured out bobup: the time at which the sin is at 180
785 // degrees (which allows lengthening or squishing the peak or valley)
786 cycle = cl.time / cl_bobcycle.value;
787 cycle -= (int) cycle;
788 if (cycle < cl_bobup.value)
789 cycle = sin(M_PI * cycle / cl_bobup.value);
791 cycle = sin(M_PI + M_PI * (cycle-cl_bobup.value)/(1.0 - cl_bobup.value));
792 // bob is proportional to velocity in the xy plane
793 // (don't count Z, or jumping messes it up)
794 bob = xyspeed * cl_bob.value;
795 bob = bound(0, bob, bob_limit);
796 bob = bob*0.3 + bob*0.7*cycle;
798 // we also need to adjust gunorg, or this appears like pushing the gun!
799 // In the old code, this was applied to vieworg BEFORE copying to gunorg,
800 // but this is not viable with the new followmodel code as that would mean
801 // that followmodel would work on the munged-by-bob vieworg and do feedback
805 // horizontal view bobbing code
806 if (cl_bob2.value && cl_bob2cycle.value)
809 vec3_t forward, right, up;
812 cycle = cl.time / cl_bob2cycle.value;
813 cycle -= (int) cycle;
815 cycle = cos(M_PI * cycle / 0.5); // cos looks better here with the other view bobbing using sin
817 cycle = cos(M_PI + M_PI * (cycle-0.5)/0.5);
818 bob = cl_bob2.value * cycle;
820 // this value slowly decreases from 1 to 0 when we stop touching the ground.
821 // The cycle is later multiplied with it so the view smooths back to normal
822 if (clonground && !clcmdjump) // also block the effect while the jump button is pressed, to avoid twitches when bunny-hopping
826 if(cl.bob2_smooth > 0)
827 cl.bob2_smooth -= bound(0, cl_bob2smooth.value, 1);
832 // calculate the front and side of the player between the X and Y axes
833 AngleVectors(viewangles, forward, right, up);
834 // now get the speed based on those angles. The bounds should match the same value as xyspeed's
835 side = bound(-cl_bob_velocity_limit.value, DotProduct (clvelocity, right) * cl.bob2_smooth, cl_bob_velocity_limit.value);
836 front = bound(-cl_bob_velocity_limit.value, DotProduct (clvelocity, forward) * cl.bob2_smooth, cl_bob_velocity_limit.value);
837 VectorScale(forward, bob, forward);
838 VectorScale(right, bob, right);
839 // we use side with forward and front with right, so the bobbing goes
840 // to the side when we walk forward and to the front when we strafe
841 VectorMAMAM(side, forward, front, right, 0, up, bob2vel);
842 vieworg[0] += bob2vel[0];
843 vieworg[1] += bob2vel[1];
844 // we also need to adjust gunorg, or this appears like pushing the gun!
845 // In the old code, this was applied to vieworg BEFORE copying to gunorg,
846 // but this is not viable with the new followmodel code as that would mean
847 // that followmodel would work on the munged-by-bob vieworg and do feedback
848 gunorg[0] += bob2vel[0];
849 gunorg[1] += bob2vel[1];
853 // causes the view to swing down and back up when touching the ground
854 if (cl_bobfall.value && cl_bobfallcycle.value)
858 cl.bobfall_speed = bound(-400, clvelocity[2], 0) * bound(0, cl_bobfall.value, 0.1);
859 if (clvelocity[2] < -cl_bobfallminspeed.value)
860 cl.bobfall_swing = 1;
862 cl.bobfall_swing = 0; // TODO really?
866 cl.bobfall_swing = max(0, cl.bobfall_swing - cl_bobfallcycle.value * frametime);
868 bobfall = sin(M_PI * cl.bobfall_swing) * cl.bobfall_speed;
869 vieworg[2] += bobfall;
870 gunorg[2] += bobfall;
874 // gun model bobbing code
875 if (cl_bobmodel.value)
877 // calculate for swinging gun model
878 // the gun bobs when running on the ground, but doesn't bob when you're in the air.
879 // Sajt: I tried to smooth out the transitions between bob and no bob, which works
880 // for the most part, but for some reason when you go through a message trigger or
881 // pick up an item or anything like that it will momentarily jolt the gun.
882 vec3_t forward, right, up;
887 s = cl.time * cl_bobmodel_speed.value;
890 if (cl.time - cl.hitgroundtime < 0.2)
892 // just hit the ground, speed the bob back up over the next 0.2 seconds
893 t = cl.time - cl.hitgroundtime;
894 t = bound(0, t, 0.2);
902 // recently left the ground, slow the bob down over the next 0.2 seconds
903 t = cl.time - cl.lastongroundtime;
904 t = 0.2 - bound(0, t, 0.2);
908 bspeed = xyspeed * 0.01f;
909 AngleVectors (gunangles, forward, right, up);
910 bob = bspeed * cl_bobmodel_side.value * cl_viewmodel_scale.value * sin (s) * t;
911 VectorMA (gunorg, bob, right, gunorg);
912 bob = bspeed * cl_bobmodel_up.value * cl_viewmodel_scale.value * cos (s * 2) * t;
913 VectorMA (gunorg, bob, up, gunorg);
917 // calculate a view matrix for rendering the scene
918 if (v_idlescale.value)
920 viewangles[0] += v_idlescale.value * sin(cl.time*v_ipitch_cycle.value) * v_ipitch_level.value;
921 viewangles[1] += v_idlescale.value * sin(cl.time*v_iyaw_cycle.value) * v_iyaw_level.value;
922 viewangles[2] += v_idlescale.value * sin(cl.time*v_iroll_cycle.value) * v_iroll_level.value;
924 Matrix4x4_CreateFromQuakeEntity(&r_refdef.view.matrix, vieworg[0], vieworg[1], vieworg[2], viewangles[0], viewangles[1], viewangles[2], 1);
925 if (v_yshearing.value > 0)
926 Matrix4x4_QuakeToDuke3D(&r_refdef.view.matrix, &r_refdef.view.matrix, v_yshearing.value);
928 // calculate a viewmodel matrix for use in view-attached entities
929 Matrix4x4_Copy(&viewmodelmatrix_nobob, &r_refdef.view.matrix);
930 Matrix4x4_ConcatScale(&viewmodelmatrix_nobob, cl_viewmodel_scale.value);
932 Matrix4x4_CreateFromQuakeEntity(&viewmodelmatrix_withbob, gunorg[0], gunorg[1], gunorg[2], gunangles[0], gunangles[1], gunangles[2], cl_viewmodel_scale.value);
933 if (v_yshearing.value > 0)
934 Matrix4x4_QuakeToDuke3D(&viewmodelmatrix_withbob, &viewmodelmatrix_withbob, v_yshearing.value);
936 VectorCopy(vieworg, cl.csqc_vieworiginfromengine);
937 VectorCopy(viewangles, cl.csqc_viewanglesfromengine);
939 Matrix4x4_Invert_Simple(&tmpmatrix, &r_refdef.view.matrix);
940 Matrix4x4_Concat(&cl.csqc_viewmodelmatrixfromengine, &tmpmatrix, &viewmodelmatrix_withbob);
943 cl.calcrefdef_prevtime = cl.time;
946 void V_CalcRefdef (void)
951 if (cls.state == ca_connected && cls.signon == SIGNONS && !cl.csqc_server2csqcentitynumber[cl.viewentity])
953 // ent is the view entity (visible when out of body)
954 ent = &cl.entities[cl.viewentity];
956 cldead = (cl.stats[STAT_HEALTH] <= 0 && cl.stats[STAT_HEALTH] != -666 && cl.stats[STAT_HEALTH] != -2342);
957 V_CalcRefdefUsing(&ent->render.matrix, cl.viewangles, !ent->persistent.trail_allowed, cl.onground, cl.cmd.jump, cl.stats[STAT_VIEWHEIGHT], cldead, cl.intermission != 0, cl.velocity); // FIXME use a better way to detect teleport/warp than trail_allowed
961 viewmodelmatrix_nobob = identitymatrix;
962 viewmodelmatrix_withbob = identitymatrix;
963 cl.csqc_viewmodelmatrixfromengine = identitymatrix;
964 r_refdef.view.matrix = identitymatrix;
965 VectorClear(cl.csqc_vieworiginfromengine);
966 VectorCopy(cl.viewangles, cl.csqc_viewanglesfromengine);
970 void V_MakeViewIsometric(void)
972 // 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)
973 matrix4x4_t relative;
974 matrix4x4_t modifiedview;
976 vec3_t forward, left, up, org;
979 r_refdef.view.useperspective = false;
980 r_refdef.view.usevieworiginculling = !r_trippy.value && v_isometric_usevieworiginculling.integer;
981 r_refdef.view.frustum_y = v_isometric_verticalfov.value * cl.viewzoom;
982 r_refdef.view.frustum_x = r_refdef.view.frustum_y * (float)r_refdef.view.width / (float)r_refdef.view.height / vid_pixelheight.value;
983 r_refdef.view.frustum_x *= r_refdef.frustumscale_x;
984 r_refdef.view.frustum_y *= r_refdef.frustumscale_y;
985 r_refdef.view.ortho_x = r_refdef.view.frustum_x; // used by VM_CL_R_SetView
986 r_refdef.view.ortho_y = r_refdef.view.frustum_y; // used by VM_CL_R_SetView
988 t[0][0] = v_isometric_xx.value;
989 t[0][1] = v_isometric_xy.value;
990 t[0][2] = v_isometric_xz.value;
992 t[1][0] = v_isometric_yx.value;
993 t[1][1] = v_isometric_yy.value;
994 t[1][2] = v_isometric_yz.value;
996 t[2][0] = v_isometric_zx.value;
997 t[2][1] = v_isometric_zy.value;
998 t[2][2] = v_isometric_zz.value;
1004 Matrix4x4_FromArrayFloatGL(&modify, t[0]);
1006 // if the orientation is locked, extract the origin and create just a translate matrix to start with
1007 if (v_isometric_locked_orientation.integer)
1009 vec3_t vx, vy, vz, origin;
1010 Matrix4x4_ToVectors(&r_refdef.view.matrix, vx, vy, vz, origin);
1011 Matrix4x4_CreateTranslate(&r_refdef.view.matrix, origin[0], origin[1], origin[2]);
1014 Matrix4x4_Concat(&modifiedview, &r_refdef.view.matrix, &modify);
1015 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);
1016 Matrix4x4_Concat(&r_refdef.view.matrix, &modifiedview, &relative);
1017 Matrix4x4_ToVectors(&r_refdef.view.matrix, forward, left, up, org);
1018 VectorMAMAMAM(1.0f, org, v_isometric_relx.value, forward, v_isometric_rely.value, left, v_isometric_relz.value, up, org);
1019 Matrix4x4_FromVectors(&r_refdef.view.matrix, forward, left, up, org);
1021 if (v_isometric_flipcullface.integer)
1023 int a = r_refdef.view.cullface_front;
1024 r_refdef.view.cullface_front = r_refdef.view.cullface_back;
1025 r_refdef.view.cullface_back = a;
1030 void V_FadeViewFlashs(void)
1032 // don't flash if time steps backwards
1033 if (cl.time <= cl.oldtime)
1035 // drop the damage value
1036 cl.cshifts[CSHIFT_DAMAGE].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_DAMAGE].alphafade;
1037 if (cl.cshifts[CSHIFT_DAMAGE].percent <= 0)
1038 cl.cshifts[CSHIFT_DAMAGE].percent = 0;
1039 // drop the bonus value
1040 cl.cshifts[CSHIFT_BONUS].percent -= (cl.time - cl.oldtime)*cl.cshifts[CSHIFT_BONUS].alphafade;
1041 if (cl.cshifts[CSHIFT_BONUS].percent <= 0)
1042 cl.cshifts[CSHIFT_BONUS].percent = 0;
1045 void V_CalcViewBlend(void)
1049 r_refdef.viewblend[0] = 0;
1050 r_refdef.viewblend[1] = 0;
1051 r_refdef.viewblend[2] = 0;
1052 r_refdef.viewblend[3] = 0;
1053 r_refdef.frustumscale_x = 1;
1054 r_refdef.frustumscale_y = 1;
1055 if (cls.state == ca_connected && cls.signon == SIGNONS)
1057 // set contents color
1060 Matrix4x4_OriginFromMatrix(&r_refdef.view.matrix, vieworigin);
1061 supercontents = CL_PointSuperContents(vieworigin);
1062 if (supercontents & SUPERCONTENTS_LIQUIDSMASK)
1064 r_refdef.frustumscale_x *= 1 - (((sin(cl.time * 4.7) + 1) * 0.015) * r_waterwarp.value);
1065 r_refdef.frustumscale_y *= 1 - (((sin(cl.time * 3.0) + 1) * 0.015) * r_waterwarp.value);
1066 if (supercontents & SUPERCONTENTS_LAVA)
1068 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 255;
1069 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
1070 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
1072 else if (supercontents & SUPERCONTENTS_SLIME)
1074 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
1075 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 25;
1076 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 5;
1080 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 130;
1081 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 80;
1082 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 50;
1084 cl.cshifts[CSHIFT_CONTENTS].percent = 150 * 0.5;
1088 cl.cshifts[CSHIFT_CONTENTS].destcolor[0] = 0;
1089 cl.cshifts[CSHIFT_CONTENTS].destcolor[1] = 0;
1090 cl.cshifts[CSHIFT_CONTENTS].destcolor[2] = 0;
1091 cl.cshifts[CSHIFT_CONTENTS].percent = 0;
1094 if (gamemode != GAME_TRANSFUSION)
1096 if (cl.stats[STAT_ITEMS] & IT_QUAD)
1098 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
1099 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 0;
1100 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 255;
1101 cl.cshifts[CSHIFT_POWERUP].percent = 30;
1103 else if (cl.stats[STAT_ITEMS] & IT_SUIT)
1105 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 0;
1106 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
1107 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
1108 cl.cshifts[CSHIFT_POWERUP].percent = 20;
1110 else if (cl.stats[STAT_ITEMS] & IT_INVISIBILITY)
1112 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 100;
1113 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 100;
1114 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 100;
1115 cl.cshifts[CSHIFT_POWERUP].percent = 100;
1117 else if (cl.stats[STAT_ITEMS] & IT_INVULNERABILITY)
1119 cl.cshifts[CSHIFT_POWERUP].destcolor[0] = 255;
1120 cl.cshifts[CSHIFT_POWERUP].destcolor[1] = 255;
1121 cl.cshifts[CSHIFT_POWERUP].destcolor[2] = 0;
1122 cl.cshifts[CSHIFT_POWERUP].percent = 30;
1125 cl.cshifts[CSHIFT_POWERUP].percent = 0;
1128 cl.cshifts[CSHIFT_VCSHIFT].destcolor[0] = v_cshift.destcolor[0];
1129 cl.cshifts[CSHIFT_VCSHIFT].destcolor[1] = v_cshift.destcolor[1];
1130 cl.cshifts[CSHIFT_VCSHIFT].destcolor[2] = v_cshift.destcolor[2];
1131 cl.cshifts[CSHIFT_VCSHIFT].percent = v_cshift.percent;
1133 // LordHavoc: fixed V_CalcBlend
1134 for (j = 0;j < NUM_CSHIFTS;j++)
1136 a2 = bound(0.0f, cl.cshifts[j].percent * (1.0f / 255.0f), 1.0f);
1139 VectorLerp(r_refdef.viewblend, a2, cl.cshifts[j].destcolor, r_refdef.viewblend);
1140 r_refdef.viewblend[3] = (1 - (1 - r_refdef.viewblend[3]) * (1 - a2)); // correct alpha multiply... took a while to find it on the web
1143 // saturate color (to avoid blending in black)
1144 if (r_refdef.viewblend[3])
1146 a2 = 1 / r_refdef.viewblend[3];
1147 VectorScale(r_refdef.viewblend, a2, r_refdef.viewblend);
1149 r_refdef.viewblend[0] = bound(0.0f, r_refdef.viewblend[0], 255.0f);
1150 r_refdef.viewblend[1] = bound(0.0f, r_refdef.viewblend[1], 255.0f);
1151 r_refdef.viewblend[2] = bound(0.0f, r_refdef.viewblend[2], 255.0f);
1152 r_refdef.viewblend[3] = bound(0.0f, r_refdef.viewblend[3] * gl_polyblend.value, 1.0f);
1155 r_refdef.viewblend[0] = Image_LinearFloatFromsRGB(r_refdef.viewblend[0]);
1156 r_refdef.viewblend[1] = Image_LinearFloatFromsRGB(r_refdef.viewblend[1]);
1157 r_refdef.viewblend[2] = Image_LinearFloatFromsRGB(r_refdef.viewblend[2]);
1161 r_refdef.viewblend[0] *= (1.0f/256.0f);
1162 r_refdef.viewblend[1] *= (1.0f/256.0f);
1163 r_refdef.viewblend[2] *= (1.0f/256.0f);
1166 // Samual: Ugly hack, I know. But it's the best we can do since
1167 // there is no way to detect client states from the engine.
1168 if (cl.stats[STAT_HEALTH] <= 0 && cl.stats[STAT_HEALTH] != -666 &&
1169 cl.stats[STAT_HEALTH] != -2342 && cl_deathfade.value > 0)
1171 cl.deathfade += cl_deathfade.value * max(0.00001, cl.time - cl.oldtime);
1172 cl.deathfade = bound(0.0f, cl.deathfade, 0.9f);
1175 cl.deathfade = 0.0f;
1177 if(cl.deathfade > 0)
1180 float deathfadevec[3] = {0.3f, 0.0f, 0.0f};
1181 a = r_refdef.viewblend[3] + cl.deathfade - r_refdef.viewblend[3]*cl.deathfade;
1183 VectorMAM(r_refdef.viewblend[3] * (1 - cl.deathfade) / a, r_refdef.viewblend, cl.deathfade / a, deathfadevec, r_refdef.viewblend);
1184 r_refdef.viewblend[3] = a;
1189 //============================================================================
1198 Cmd_AddCommand ("v_cshift", V_cshift_f, "sets tint color of view");
1199 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");
1200 Cmd_AddCommand ("centerview", V_StartPitchDrift, "gradually recenter view (stop looking up/down)");
1202 Cvar_RegisterVariable (&v_centermove);
1203 Cvar_RegisterVariable (&v_centerspeed);
1205 Cvar_RegisterVariable (&v_iyaw_cycle);
1206 Cvar_RegisterVariable (&v_iroll_cycle);
1207 Cvar_RegisterVariable (&v_ipitch_cycle);
1208 Cvar_RegisterVariable (&v_iyaw_level);
1209 Cvar_RegisterVariable (&v_iroll_level);
1210 Cvar_RegisterVariable (&v_ipitch_level);
1212 Cvar_RegisterVariable(&v_isometric);
1213 Cvar_RegisterVariable(&v_isometric_verticalfov);
1214 Cvar_RegisterVariable(&v_isometric_xx);
1215 Cvar_RegisterVariable(&v_isometric_xy);
1216 Cvar_RegisterVariable(&v_isometric_xz);
1217 Cvar_RegisterVariable(&v_isometric_yx);
1218 Cvar_RegisterVariable(&v_isometric_yy);
1219 Cvar_RegisterVariable(&v_isometric_yz);
1220 Cvar_RegisterVariable(&v_isometric_zx);
1221 Cvar_RegisterVariable(&v_isometric_zy);
1222 Cvar_RegisterVariable(&v_isometric_zz);
1223 Cvar_RegisterVariable(&v_isometric_tx);
1224 Cvar_RegisterVariable(&v_isometric_ty);
1225 Cvar_RegisterVariable(&v_isometric_tz);
1226 Cvar_RegisterVariable(&v_isometric_rot_pitch);
1227 Cvar_RegisterVariable(&v_isometric_rot_yaw);
1228 Cvar_RegisterVariable(&v_isometric_rot_roll);
1229 Cvar_RegisterVariable(&v_isometric_relx);
1230 Cvar_RegisterVariable(&v_isometric_rely);
1231 Cvar_RegisterVariable(&v_isometric_relz);
1232 Cvar_RegisterVariable(&v_isometric_flipcullface);
1233 Cvar_RegisterVariable(&v_isometric_locked_orientation);
1234 Cvar_RegisterVariable(&v_isometric_usevieworiginculling);
1236 Cvar_RegisterVariable (&v_idlescale);
1237 Cvar_RegisterVariable (&crosshair);
1239 Cvar_RegisterVariable (&cl_rollspeed);
1240 Cvar_RegisterVariable (&cl_rollangle);
1241 Cvar_RegisterVariable (&cl_bob);
1242 Cvar_RegisterVariable (&cl_bobcycle);
1243 Cvar_RegisterVariable (&cl_bobup);
1244 Cvar_RegisterVariable (&cl_bob2);
1245 Cvar_RegisterVariable (&cl_bob2cycle);
1246 Cvar_RegisterVariable (&cl_bob2smooth);
1247 Cvar_RegisterVariable (&cl_bobfall);
1248 Cvar_RegisterVariable (&cl_bobfallcycle);
1249 Cvar_RegisterVariable (&cl_bobfallminspeed);
1250 Cvar_RegisterVariable (&cl_bobmodel);
1251 Cvar_RegisterVariable (&cl_bobmodel_side);
1252 Cvar_RegisterVariable (&cl_bobmodel_up);
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);
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);
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);
1283 Cvar_RegisterVariable (&cl_viewmodel_scale);
1285 Cvar_RegisterVariable (&v_kicktime);
1286 Cvar_RegisterVariable (&v_kickroll);
1287 Cvar_RegisterVariable (&v_kickpitch);
1289 Cvar_RegisterVariable (&cl_stairsmoothspeed);
1291 Cvar_RegisterVariable (&cl_smoothviewheight);
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);
1300 Cvar_RegisterVariable (&v_deathtilt);
1301 Cvar_RegisterVariable (&v_deathtiltangle);
1303 Cvar_RegisterVariable (&v_yshearing);