More progress, still nothing considerable

[xonotic/darkplaces.git] / view.c

diff --git a/view.c b/view.c
index 2f7e17f862904463eb11c64bc51ba4246ae0031c..0cd7b478b4ccc5b27bb9ddde494ba4911f8f4bee 100644 (file)
--- a/view.c
+++ b/view.c
@@ -638,8 +638,10 @@ void V_CalcRefdef (void)
                                        VectorAdd(vieworg, gunorg, gunorg);
                                        VectorAdd(viewangles, gunangles, gunangles);
 
+                                       // bounded XY speed, used by several effects below
+                                       xyspeed = bound (0, sqrt(cl.velocity[0]*cl.velocity[0] + cl.velocity[1]*cl.velocity[1]), 400);
+
                                        // vertical view bobbing code
-                                       xyspeed = sqrt(cl.velocity[0]*cl.velocity[0] + cl.velocity[1]*cl.velocity[1]);
                                        if (cl_bob.value && cl_bobcycle.value)
                                        {
                                                // LordHavoc: this code is *weird*, but not replacable (I think it
@@ -677,11 +679,11 @@ void V_CalcRefdef (void)
                                                        cycle = sin(M_PI * cycle / 0.5);
                                                else
                                                        cycle = sin(M_PI + M_PI * (cycle-0.5)/0.5);
-                                               bob = xyspeed * bound(0, cl_bob2.value, 0.05) * cycle;
+                                               bob = bound(0, cl_bob2.value, 0.05) * 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 while the jump button is pressed, to avoid twitches when bunny-hopping
+                                               if (cl.onground && !cl.cmd.jump) // also block the effect while the jump button is pressed, to avoid twitches when bunny-hopping
                                                        cl.bob2_smooth = 1;
                                                else
                                                {
@@ -691,11 +693,11 @@ void V_CalcRefdef (void)
                                                                cl.bob2_smooth = 0;
                                                }
 
-                                               // calculate the side and front of the player between the X and Y axes
+                                               // calculate the front and side of the player between the X and Y axes
                                                AngleVectors(viewangles, forward, right, up);
-                                               // 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;
+                                               // now get the speed based on those angles. The bounds should match the same value as xyspeed's
+                                               side = bound(-400, DotProduct (cl.velocity, right) * cl.bob2_smooth, 400);
+                                               front = bound(-400, DotProduct (cl.velocity, forward) * cl.bob2_smooth, 400);
                                                VectorScale(forward, bob, forward);
                                                VectorScale(right, bob, right);
                                                // we use side with forward and front with right, so the bobbing goes
@@ -710,9 +712,34 @@ void V_CalcRefdef (void)
                                                gunorg[0] += bob2vel[0];
                                                gunorg[1] += bob2vel[1];
                                        }
+                                       
+                                       
+                                       // TEST!!!
+
+                                       // get the speed while in the air, apply it while we're not
+                                       if (!cl.onground)
+                                       {
+                                               cl.ground_hit_speed = 0;
+                                               cl.ground_hit_target = cl.velocity[2] * 0.1; // replace 0.1 with cvar
+                                       }
+                                       else
+                                       {
+                                               if(cl.ground_hit_speed > cl.ground_hit_target)
+                                                       cl.ground_hit_speed -= 0.1; // replace 0.1 with cvar
+                                               if(cl.ground_hit_speed < cl.ground_hit_target)
+                                                       cl.ground_hit_speed += 0.1; // replace 0.1 with cvar
+
+                                               vieworg[2] += cl.ground_hit_speed;
+                                               gunorg[2] += cl.ground_hit_speed;
+                                       }
+
+                                       // End of TEST!!!
+                                       
+                                       
 
                                        // gun model bobbing code
-                                       if (cl_bob.value && cl_bobmodel.value)
+                                       if (cl_bob.value || cl_bob2.value)
+                                       if (cl_bobmodel.value)
                                        {
                                                // calculate for swinging gun model
                                                // the gun bobs when running on the ground, but doesn't bob when you're in the air.
@@ -745,7 +772,7 @@ void V_CalcRefdef (void)
                                                        t *= 5;
                                                }
 
-                                               bspeed = bound (0, xyspeed, 400) * 0.01f;
+                                               bspeed = xyspeed * 0.01f;
                                                AngleVectors (gunangles, forward, right, up);
                                                bob = bspeed * cl_bobmodel_side.value * cl_viewmodel_scale.value * sin (s) * t;
                                                VectorMA (gunorg, bob, right, gunorg);