Get rid of cl_bob2up. It's not good for -sideways- movement

[xonotic/darkplaces.git] / view.c

diff --git a/view.c b/view.c
index 9541319aab696169ee927360c97b1a41ef5455a7..ed3739f598210e3704ab1bf796cdf95cd251972e 100644 (file)
--- a/view.c
+++ b/view.c
@@ -39,9 +39,8 @@ cvar_t cl_rollangle = {0, "cl_rollangle", "2.0", "how much to tilt the view when
 cvar_t cl_bob = {CVAR_SAVE, "cl_bob","0.02", "view bobbing amount"};
 cvar_t cl_bobcycle = {CVAR_SAVE, "cl_bobcycle","0.6", "view bobbing speed"};
 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"};
-cvar_t cl_bob2 = {CVAR_SAVE, "cl_bob2","0", "sideway view bobbing amount"};
-cvar_t cl_bob2cycle = {CVAR_SAVE, "cl_bob2cycle","0.6", "sideway view bobbing speed"};
-cvar_t cl_bob2up = {CVAR_SAVE, "cl_bob2up","0.5", "view bobbing adjustment that makes the side swing of the bob last longer"};
+cvar_t cl_bob2 = {CVAR_SAVE, "cl_bob2","0", "sideways view bobbing amount"};
+cvar_t cl_bob2cycle = {CVAR_SAVE, "cl_bob2cycle","0.6", "sideways view bobbing speed"};
 cvar_t cl_bob2smooth = {CVAR_SAVE, "cl_bob2smooth","0.05", "how fast the view goes back when you stop touching the ground"};
 cvar_t cl_bobmodel = {CVAR_SAVE, "cl_bobmodel", "1", "enables gun bobbing"};
 cvar_t cl_bobmodel_side = {CVAR_SAVE, "cl_bobmodel_side", "0.15", "gun bobbing sideways sway amount"};
@@ -668,23 +667,21 @@ void V_CalcRefdef (void)
                                        // horizontal view bobbing code
                                        if (cl_bob2.value && cl_bob2cycle.value)
                                        {
-                                               vec3_t bobvel;
+                                               vec3_t bob2vel;
                                                vec3_t forward, right, up;
                                                float side, front;
 
                                                cycle = cl.time / cl_bob2cycle.value;
                                                cycle -= (int) cycle;
-                                               if (cycle < cl_bob2up.value)
-                                                       cycle = sin(M_PI * cycle / cl_bob2up.value);
+                                               if (cycle < 0.5)
+                                                       cycle = sin(M_PI * cycle / 0.5);
                                                else
-                                                       cycle = sin(M_PI + M_PI * (cycle-cl_bob2up.value)/(1.0 - cl_bob2up.value));
-                                               // bob is proportional to velocity in the xy plane
-                                               // (don't count Z, or jumping messes it up)
+                                                       cycle = sin(M_PI + M_PI * (cycle-0.5)/0.5);
                                                bob = xyspeed * cl_bob2.value * cycle;
 
                                                // this value slowly decreases from 1 to 0 when we stop touching the ground.
                                                // The cycle is later multiplied with it so the view smooths back to normal
-                                               if (cl.onground && !cl.cmd.jump) // also block the effect while the jump button is pressed, to avoid twitches when bunny-hopping
+                                               if (cl.onground && !cl.cmd.jump) // also block while the jump button is pressed, to avoid twitches when bunny-hopping
                                                        cl.bob2_smooth = 1;
                                                else
                                                {
@@ -694,26 +691,24 @@ void V_CalcRefdef (void)
                                                                cl.bob2_smooth = 0;
                                                }
 
-                                               // now we calculate the side and front of the player, between the X and Y axis
+                                               // calculate the side and front of the player between the X and Y axes
                                                AngleVectors(viewangles, forward, right, up);
-                                               // now the speed based on these angles. The division is for mathing vertical bobbing intensity
+                                               // now get the speed based on those angles. The division is for mathing vertical bobbing intensity
                                                side = DotProduct (cl.velocity, right) / 1000 * cl.bob2_smooth;
                                                front = DotProduct (cl.velocity, forward) / 1000 * cl.bob2_smooth;
-                                               forward[0] *= bob;
-                                               forward[1] *= bob;
-                                               right[0] *= bob;
-                                               right[1] *= bob;
-                                               // we use side with forward and front with right so the side bobbing goes
-                                               // to the side when we walk forward and to the front when we strafe.
-                                               VectorMAMAM(side, forward, front, right, 0, up, bobvel);
-                                               vieworg[0] += bound(-8, bobvel[0], 8);
-                                               vieworg[1] += bound(-8, bobvel[1], 8);
+                                               VectorScale(forward, bob, forward);
+                                               VectorScale(right, bob, right);
+                                               // we use side with forward and front with right, so the bobbing goes
+                                               // to the side when we walk forward and to the front when we strafe
+                                               VectorMAMAM(side, forward, front, right, 0, up, bob2vel);
+                                               vieworg[0] += bound(-8, bob2vel[0], 8);
+                                               vieworg[1] += bound(-8, bob2vel[1], 8);
                                                // we also need to adjust gunorg, or this appears like pushing the gun!
                                                // In the old code, this was applied to vieworg BEFORE copying to gunorg,
                                                // but this is not viable with the new followmodel code as that would mean
                                                // that followmodel would work on the munged-by-bob vieworg and do feedback
-                                               gunorg[0] += bound(-8, bobvel[0], 8);
-                                               gunorg[1] += bound(-8, bobvel[1], 8);
+                                               gunorg[0] += bound(-8, bob2vel[0], 8);
+                                               gunorg[1] += bound(-8, bob2vel[1], 8);
                                        }
 
                                        // gun model bobbing code
@@ -952,7 +947,6 @@ void V_Init (void)
        Cvar_RegisterVariable (&cl_bobup);
        Cvar_RegisterVariable (&cl_bob2);
        Cvar_RegisterVariable (&cl_bob2cycle);
-       Cvar_RegisterVariable (&cl_bob2up);
        Cvar_RegisterVariable (&cl_bob2smooth);
        Cvar_RegisterVariable (&cl_bobmodel);
        Cvar_RegisterVariable (&cl_bobmodel_side);