]> de.git.xonotic.org Git - xonotic/darkplaces.git/blobdiff - view.c
fix the EndIncreaseEdicts handlers as edicts beyond num_edicts are not initialized yet
[xonotic/darkplaces.git] / view.c
diff --git a/view.c b/view.c
index 7b915b4b6e68f141d247f4484beaf9cdb6f0df03..eacc8d0e93947e7f9016d460a868dd6d2058583b 100644 (file)
--- a/view.c
+++ b/view.c
@@ -45,6 +45,30 @@ cvar_t cl_bobmodel_side = {CVAR_SAVE, "cl_bobmodel_side", "0.15", "gun bobbing s
 cvar_t cl_bobmodel_up = {CVAR_SAVE, "cl_bobmodel_up", "0.06", "gun bobbing upward movement amount"};
 cvar_t cl_bobmodel_speed = {CVAR_SAVE, "cl_bobmodel_speed", "7", "gun bobbing speed"};
 
+cvar_t cl_leanmodel = {CVAR_SAVE, "cl_leanmodel", "0", "enables gun leaning"};
+cvar_t cl_leanmodel_side_speed = {CVAR_SAVE, "cl_leanmodel_side_speed", "1", "gun leaning sideways speed"};
+cvar_t cl_leanmodel_side_limit = {CVAR_SAVE, "cl_leanmodel_side_limit", "35", "gun leaning sideways limit"};
+cvar_t cl_leanmodel_side_highpass1 = {CVAR_SAVE, "cl_leanmodel_side_highpass1", "5", "gun leaning sideways pre-highpass in 1/s"};
+cvar_t cl_leanmodel_side_highpass = {CVAR_SAVE, "cl_leanmodel_side_highpass", "15", "gun leaning sideways highpass in 1/s"};
+cvar_t cl_leanmodel_side_lowpass = {CVAR_SAVE, "cl_leanmodel_side_lowpass", "30", "gun leaning sideways lowpass in 1/s"};
+cvar_t cl_leanmodel_up_speed = {CVAR_SAVE, "cl_leanmodel_up_speed", "1", "gun leaning upward speed"};
+cvar_t cl_leanmodel_up_limit = {CVAR_SAVE, "cl_leanmodel_up_limit", "25", "gun leaning upward limit"};
+cvar_t cl_leanmodel_up_highpass1 = {CVAR_SAVE, "cl_leanmodel_up_highpass1", "5", "gun leaning upward pre-highpass in 1/s"};
+cvar_t cl_leanmodel_up_highpass = {CVAR_SAVE, "cl_leanmodel_up_highpass", "15", "gun leaning upward highpass in 1/s"};
+cvar_t cl_leanmodel_up_lowpass = {CVAR_SAVE, "cl_leanmodel_up_lowpass", "30", "gun leaning upward lowpass in 1/s"};
+
+cvar_t cl_followmodel = {CVAR_SAVE, "cl_followmodel", "0", "enables gun following"};
+cvar_t cl_followmodel_side_speed = {CVAR_SAVE, "cl_followmodel_side_speed", "1", "gun following sideways speed"};
+cvar_t cl_followmodel_side_limit = {CVAR_SAVE, "cl_followmodel_side_limit", "4", "gun following sideways limit"};
+cvar_t cl_followmodel_side_highpass1 = {CVAR_SAVE, "cl_followmodel_side_highpass1", "5", "gun following sideways pre-highpass in 1/s"};
+cvar_t cl_followmodel_side_highpass = {CVAR_SAVE, "cl_followmodel_side_highpass", "15", "gun following sideways highpass in 1/s"};
+cvar_t cl_followmodel_side_lowpass = {CVAR_SAVE, "cl_followmodel_side_lowpass", "30", "gun following sideways lowpass in 1/s"};
+cvar_t cl_followmodel_up_speed = {CVAR_SAVE, "cl_followmodel_up_speed", "1", "gun following upward speed"};
+cvar_t cl_followmodel_up_limit = {CVAR_SAVE, "cl_followmodel_up_limit", "2", "gun following upward limit"};
+cvar_t cl_followmodel_up_highpass1 = {CVAR_SAVE, "cl_followmodel_up_highpass1", "5", "gun following upward pre-highpass in 1/s"};
+cvar_t cl_followmodel_up_highpass = {CVAR_SAVE, "cl_followmodel_up_highpass", "15", "gun following upward highpass in 1/s"};
+cvar_t cl_followmodel_up_lowpass = {CVAR_SAVE, "cl_followmodel_up_lowpass", "30", "gun following upward lowpass in 1/s"};
+
 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"};
 
 cvar_t v_kicktime = {0, "v_kicktime", "0.5", "how long a view kick from damage lasts"};
@@ -353,11 +377,55 @@ V_CalcRefdef
 static vec3_t eyeboxmins = {-16, -16, -24};
 static vec3_t eyeboxmaxs = { 16,  16,  32};
 #endif
-float viewmodel_push_x, viewmodel_push_y;
+
+static vec_t lowpass(vec_t value, vec_t frac, vec_t *store)
+{
+       frac = bound(0, frac, 1);
+       return (*store = *store * (1 - frac) + value * frac);
+}
+
+static vec_t lowpass_limited(vec_t value, vec_t frac, vec_t limit, vec_t *store)
+{
+       lowpass(value, frac, store);
+       return (*store = bound(value - limit, *store, value + limit));
+}
+
+static vec_t highpass(vec_t value, vec_t frac, vec_t *store)
+{
+       return value - lowpass(value, frac, store);
+}
+
+static vec_t highpass_limited(vec_t value, vec_t frac, vec_t limit, vec_t *store)
+{
+       return value - lowpass_limited(value, frac, limit, store);
+}
+
+static void lowpass3(vec3_t value, vec_t fracx, vec_t fracy, vec_t fracz, vec3_t store, vec3_t out)
+{
+       out[0] = lowpass(value[0], fracx, &store[0]);
+       out[1] = lowpass(value[1], fracy, &store[1]);
+       out[2] = lowpass(value[2], fracz, &store[2]);
+}
+
+static void highpass3(vec3_t value, vec_t fracx, vec_t fracy, vec_t fracz, vec3_t store, vec3_t out)
+{
+       out[0] = highpass(value[0], fracx, &store[0]);
+       out[1] = highpass(value[1], fracy, &store[1]);
+       out[2] = highpass(value[2], fracz, &store[2]);
+}
+
+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)
+{
+       out[0] = highpass_limited(value[0], fracx, limitx, &store[0]);
+       out[1] = highpass_limited(value[1], fracy, limity, &store[1]);
+       out[2] = highpass_limited(value[2], fracz, limitz, &store[2]);
+}
+
 void V_CalcRefdef (void)
 {
        entity_t *ent;
-       float vieworg[3], gunorg[3], viewangles[3], gunangles[3], smoothtime;
+       float vieworg[3], viewangles[3], smoothtime;
+       float gunorg[3], gunangles[3];
 #if 0
 // begin of chase camera bounding box size for proper collisions by Alexander Zubov
        vec3_t camboxmins = {-3, -3, -3};
@@ -519,7 +587,56 @@ void V_CalcRefdef (void)
                                if (cl.stats[STAT_HEALTH] > 0)
                                {
                                        double xyspeed, bob;
+                                       vec_t frametime;
+
+                                       frametime = cl.realframetime * cl.movevars_timescale;
 
+                                       // 1. if we teleported, clear the frametime... the lowpass will recover the previous value then
+                                       if(!ent->persistent.trail_allowed) // FIXME improve this check
+                                       {
+                                               // try to fix the first highpass; result is NOT
+                                               // perfect! TODO find a better fix
+                                               VectorCopy(cl.viewangles, cl.gunangles_prev);
+                                               VectorCopy(cl.movement_origin, cl.gunorg_prev);
+                                       }
+
+                                       // 2. for the gun origin, only keep the high frequency (non-DC) parts, which is "somewhat like velocity"
+                                       VectorAdd(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
+                                       highpass3_limited(cl.movement_origin, 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);
+                                       VectorCopy(cl.movement_origin, cl.gunorg_prev);
+                                       VectorSubtract(cl.gunorg_highpass, cl.gunorg_prev, cl.gunorg_highpass);
+
+                                       // in the highpass, we _store_ the DIFFERENCE to the actual view angles...
+                                       VectorAdd(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
+                                       cl.gunangles_highpass[PITCH] += 360 * floor((cl.viewangles[PITCH] - cl.gunangles_highpass[PITCH]) / 360 + 0.5);
+                                       cl.gunangles_highpass[YAW] += 360 * floor((cl.viewangles[YAW] - cl.gunangles_highpass[YAW]) / 360 + 0.5);
+                                       cl.gunangles_highpass[ROLL] += 360 * floor((cl.viewangles[ROLL] - cl.gunangles_highpass[ROLL]) / 360 + 0.5);
+                                       highpass3_limited(cl.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);
+                                       VectorCopy(cl.viewangles, cl.gunangles_prev);
+                                       VectorSubtract(cl.gunangles_highpass, cl.gunangles_prev, cl.gunangles_highpass);
+
+                                       // 3. calculate the RAW adjustment vectors
+                                       gunorg[0] *= (cl_followmodel.value ? -cl_followmodel_side_speed.value : 0);
+                                       gunorg[1] *= (cl_followmodel.value ? -cl_followmodel_side_speed.value : 0);
+                                       gunorg[2] *= (cl_followmodel.value ? -cl_followmodel_up_speed.value : 0);
+
+                                       gunangles[PITCH] *= (cl_leanmodel.value ? -cl_leanmodel_up_speed.value : 0);
+                                       gunangles[YAW] *= (cl_leanmodel.value ? -cl_leanmodel_side_speed.value : 0);
+                                       gunangles[ROLL] = 0;
+
+                                       // 4. perform highpass/lowpass on the adjustment vectors (turning velocity into acceleration!)
+                                       //    trick: we must do the lowpass LAST, so the lowpass vector IS the final vector!
+                                       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);
+                                       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);
+                                       // we assume here: PITCH = 0, YAW = 1, ROLL = 2
+                                       highpass3(gunangles, frametime*cl_leanmodel_up_highpass.value, frametime*cl_leanmodel_side_highpass.value, 0, cl.gunangles_adjustment_highpass, gunangles);
+                                       lowpass3(gunangles, frametime*cl_leanmodel_up_lowpass.value, frametime*cl_leanmodel_side_lowpass.value, 0, cl.gunangles_adjustment_lowpass, gunangles);
+
+                                       // 5. use the adjusted vectors
+                                       VectorAdd(vieworg, gunorg, gunorg);
+                                       VectorAdd(cl.viewangles, gunangles, gunangles);
+
+                                       // view bobbing code
                                        xyspeed = sqrt(cl.movement_velocity[0]*cl.movement_velocity[0] + cl.movement_velocity[1]*cl.movement_velocity[1]);
                                        if (cl_bob.value && cl_bobcycle.value)
                                        {
@@ -539,10 +656,14 @@ void V_CalcRefdef (void)
                                                bob = xyspeed * cl_bob.value;
                                                bob = bob*0.3 + bob*0.7*cycle;
                                                vieworg[2] += bound(-7, bob, 4);
+                                               // 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[2] += bound(-7, bob, 4);
                                        }
 
-                                       VectorCopy(vieworg, gunorg);
-
+                                       // gun model bobbing code
                                        if (cl_bob.value && cl_bobmodel.value)
                                        {
                                                // calculate for swinging gun model
@@ -583,28 +704,6 @@ void V_CalcRefdef (void)
                                                bob = bspeed * cl_bobmodel_up.value * cl_viewmodel_scale.value * cos (s * 2) * t;
                                                VectorMA (gunorg, bob, up, gunorg);
                                        }
-
-                                       // gun model leaning code
-                                       
-                                       // TODO 1: Fix bug where model does a 360* turn when YAW jumps around the 0 - 360 rotation border.
-                                       // [18:53:17] <@div0> search for AnglesFromVectors and AngleVectors
-                                       // [18:53:27] <@div0> I am quite sure interpolation (lerp) uses it
-                                       
-                                       // TODO 2: Implement limits (weapon model must not lean past a certain limit)
-
-                                       // TODO 3: Cvar everything once the first TODOs are ready.
-
-                                       if(viewmodel_push_x < cl.viewangles[PITCH])
-                                               viewmodel_push_x += (cl.viewangles[PITCH] - viewmodel_push_x) * 0.01;
-                                       else if(viewmodel_push_x > cl.viewangles[PITCH])
-                                               viewmodel_push_x -= (viewmodel_push_x - cl.viewangles[PITCH]) * 0.01;
-
-                                       if(viewmodel_push_y < cl.viewangles[YAW])
-                                               viewmodel_push_y += (cl.viewangles[YAW] - viewmodel_push_y) * 0.01;
-                                       else if(viewmodel_push_y > cl.viewangles[YAW])
-                                               viewmodel_push_y -= (viewmodel_push_y - cl.viewangles[YAW]) * 0.01;
-
-                                       VectorSet(gunangles, viewmodel_push_x, viewmodel_push_y, viewangles[2]);
                                }
                        }
                        // calculate a view matrix for rendering the scene
@@ -803,6 +902,30 @@ void V_Init (void)
        Cvar_RegisterVariable (&cl_bobmodel_up);
        Cvar_RegisterVariable (&cl_bobmodel_speed);
 
+       Cvar_RegisterVariable (&cl_leanmodel);
+       Cvar_RegisterVariable (&cl_leanmodel_side_speed);
+       Cvar_RegisterVariable (&cl_leanmodel_side_limit);
+       Cvar_RegisterVariable (&cl_leanmodel_side_highpass1);
+       Cvar_RegisterVariable (&cl_leanmodel_side_lowpass);
+       Cvar_RegisterVariable (&cl_leanmodel_side_highpass);
+       Cvar_RegisterVariable (&cl_leanmodel_up_speed);
+       Cvar_RegisterVariable (&cl_leanmodel_up_limit);
+       Cvar_RegisterVariable (&cl_leanmodel_up_highpass1);
+       Cvar_RegisterVariable (&cl_leanmodel_up_lowpass);
+       Cvar_RegisterVariable (&cl_leanmodel_up_highpass);
+
+       Cvar_RegisterVariable (&cl_followmodel);
+       Cvar_RegisterVariable (&cl_followmodel_side_speed);
+       Cvar_RegisterVariable (&cl_followmodel_side_limit);
+       Cvar_RegisterVariable (&cl_followmodel_side_highpass1);
+       Cvar_RegisterVariable (&cl_followmodel_side_lowpass);
+       Cvar_RegisterVariable (&cl_followmodel_side_highpass);
+       Cvar_RegisterVariable (&cl_followmodel_up_speed);
+       Cvar_RegisterVariable (&cl_followmodel_up_limit);
+       Cvar_RegisterVariable (&cl_followmodel_up_highpass1);
+       Cvar_RegisterVariable (&cl_followmodel_up_lowpass);
+       Cvar_RegisterVariable (&cl_followmodel_up_highpass);
+
        Cvar_RegisterVariable (&cl_viewmodel_scale);
 
        Cvar_RegisterVariable (&v_kicktime);