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_bobroll = {CVAR_SAVE, "cl_bobroll","0", "view rolling amount"};
+cvar_t cl_bobrollcycle = {CVAR_SAVE, "cl_bobrollcycle","0.8", "view rolling speed"};
+cvar_t cl_bobrollairtime = {CVAR_SAVE, "cl_bobrollairtime","0.05", "how fast the view rolls 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"};
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_side = {CVAR_SAVE, "cl_leanmodel_side", "1", "enables gun leaning sideways"};
-cvar_t cl_leanmodel_side_speed = {CVAR_SAVE, "cl_leanmodel_side_speed", "20", "gun leaning sideways 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", "0.7", "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_up = {CVAR_SAVE, "cl_leanmodel_up", "1", "enables gun leaning upward"};
-cvar_t cl_leanmodel_up_speed = {CVAR_SAVE, "cl_leanmodel_up_speed", "15", "gun leaning upward speed"};
-cvar_t cl_leanmodel_up_limit = {CVAR_SAVE, "cl_leanmodel_up_limit", "25", "gun leaning upward limit"};
-
-cvar_t cl_followmodel_side = {CVAR_SAVE, "cl_followmodel_side", "1", "enables gun following sideways"};
-cvar_t cl_followmodel_side_speed = {CVAR_SAVE, "cl_followmodel_side_speed", "0.015", "gun following sideways speed"};
-cvar_t cl_followmodel_side_limit = {CVAR_SAVE, "cl_followmodel_side_limit", "2", "gun following sideways limit"};
-cvar_t cl_followmodel_up = {CVAR_SAVE, "cl_followmodel_up", "1", "enables gun following upward"};
-cvar_t cl_followmodel_up_speed = {CVAR_SAVE, "cl_followmodel_up_speed", "0.01", "gun following upward speed"};
-cvar_t cl_followmodel_up_limit = {CVAR_SAVE, "cl_followmodel_up_limit", "1.5", "gun following upward limit"};
+cvar_t cl_leanmodel_side_highpass1 = {CVAR_SAVE, "cl_leanmodel_side_highpass1", "30", "gun leaning sideways pre-highpass in 1/s"};
+cvar_t cl_leanmodel_side_highpass = {CVAR_SAVE, "cl_leanmodel_side_highpass", "5", "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", "0.65", "gun leaning upward speed"};
+cvar_t cl_leanmodel_up_limit = {CVAR_SAVE, "cl_leanmodel_up_limit", "50", "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", "0.25", "gun following sideways speed"};
+cvar_t cl_followmodel_side_limit = {CVAR_SAVE, "cl_followmodel_side_limit", "6", "gun following sideways limit"};
+cvar_t cl_followmodel_side_highpass1 = {CVAR_SAVE, "cl_followmodel_side_highpass1", "30", "gun following sideways pre-highpass in 1/s"};
+cvar_t cl_followmodel_side_highpass = {CVAR_SAVE, "cl_followmodel_side_highpass", "5", "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", "0.5", "gun following upward speed"};
+cvar_t cl_followmodel_up_limit = {CVAR_SAVE, "cl_followmodel_up_limit", "5", "gun following upward limit"};
+cvar_t cl_followmodel_up_highpass1 = {CVAR_SAVE, "cl_followmodel_up_highpass1", "60", "gun following upward pre-highpass in 1/s"};
+cvar_t cl_followmodel_up_highpass = {CVAR_SAVE, "cl_followmodel_up_highpass", "3", "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 chase_pitchangle = {CVAR_SAVE, "chase_pitchangle", "55", "chase cam pitch angle"};
float v_dmg_time, v_dmg_roll, v_dmg_pitch;
-float gunorg[3], gunangles[3];
/*
static vec3_t eyeboxmins = {-16, -16, -24};
static vec3_t eyeboxmaxs = { 16, 16, 32};
#endif
+
+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], 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};
else
{
// smooth stair stepping, but only if onground and enabled
- if (!cl.onground || cl_stairsmoothspeed.value <= 0)
+ if (!cl.onground || cl_stairsmoothspeed.value <= 0 || !ent->persistent.trail_allowed) // FIXME use a better way to detect teleport/warp
cl.stairsmoothz = vieworg[2];
else
{
if (cl.stats[STAT_HEALTH] <= 0 && v_deathtilt.integer)
viewangles[ROLL] = v_deathtiltangle.value;
VectorAdd(viewangles, cl.punchangle, viewangles);
- viewangles[ROLL] += V_CalcRoll(cl.viewangles, cl.movement_velocity);
+ viewangles[ROLL] += V_CalcRoll(cl.viewangles, cl.velocity);
if (v_dmg_time > 0)
{
viewangles[ROLL] += v_dmg_time/v_kicktime.value*v_dmg_roll;
VectorAdd(vieworg, cl.punchvector, vieworg);
if (cl.stats[STAT_HEALTH] > 0)
{
- double xyspeed, bob;
- vec_t d;
+ double xyspeed, bob, bobroll;
+ float cycle, cycle2;
+ vec_t frametime;
- // gun model leaning code
- vec_t ef_speed_up = cl_leanmodel_up_speed.value * cl.realframetime * cl.movevars_timescale;
- if(cl_leanmodel_up.value && ef_speed_up >= 0 && ef_speed_up < 1) // bad things happen if this goes out of range, so prevent the effect
- {
- // prevent the gun from doing a 360* rotation when going around the 0 <-> 360 border
- if(cl.viewangles[PITCH] - gunangles[PITCH] >= 180)
- gunangles[PITCH] += 360;
- if(gunangles[PITCH] - cl.viewangles[PITCH] >= 180)
- gunangles[PITCH] -= 360;
-
- d = cl.viewangles[PITCH] - gunangles[PITCH];
- gunangles[PITCH] = bound(cl.viewangles[PITCH] - cl_leanmodel_up_limit.value, gunangles[PITCH] * (1 - ef_speed_up) + cl.viewangles[PITCH] * ef_speed_up, cl.viewangles[PITCH] + cl_leanmodel_up_limit.value);
- }
- else
- gunangles[PITCH] = cl.viewangles[PITCH];
+ frametime = cl.realframetime * cl.movevars_timescale;
- vec_t ef_speed_side = cl_leanmodel_side_speed.value * cl.realframetime * cl.movevars_timescale;
- if(cl_leanmodel_side.value && ef_speed_side >= 0 && ef_speed_side < 1) // bad things happen if this goes out of range, so prevent the effect
+ // 1. if we teleported, clear the frametime... the lowpass will recover the previous value then
+ if(!ent->persistent.trail_allowed) // FIXME improve this check
{
- // prevent the gun from doing a 360* rotation when going around the 0 <-> 360 border
- if(cl.viewangles[YAW] - gunangles[YAW] >= 180)
- gunangles[YAW] += 360;
- if(gunangles[YAW] - cl.viewangles[YAW] >= 180)
- gunangles[YAW] -= 360;
-
- d = cl.viewangles[YAW] - gunangles[YAW];
- gunangles[YAW] = bound(cl.viewangles[YAW] - cl_leanmodel_side_limit.value, gunangles[YAW] * (1 - ef_speed_side) + cl.viewangles[YAW] * ef_speed_side, cl.viewangles[YAW] + cl_leanmodel_side_limit.value);
+ // try to fix the first highpass; result is NOT
+ // perfect! TODO find a better fix
+ VectorCopy(viewangles, cl.gunangles_prev);
+ VectorCopy(vieworg, cl.gunorg_prev);
}
- else
- gunangles[YAW] = cl.viewangles[YAW];
- gunangles[ROLL] = viewangles[2];
-
- // gun model following code
- if(cl_followmodel_side.value)
- {
- gunorg[0] = vieworg[0] - bound(-cl_followmodel_side_limit.value, cl.movement_velocity[0] * cl_followmodel_side_speed.value, cl_followmodel_side_limit.value);
- gunorg[1] = vieworg[1] - bound(-cl_followmodel_side_limit.value, cl.movement_velocity[1] * cl_followmodel_side_speed.value, cl_followmodel_side_limit.value);
- }
- else
- {
- gunorg[0] = vieworg[0];
- gunorg[1] = vieworg[1];
- }
-
- if(cl_followmodel_up.value)
- {
- gunorg[2] = vieworg[2] - bound(-cl_followmodel_up_limit.value, cl.movement_velocity[2] * cl_followmodel_up_speed.value, cl_followmodel_up_limit.value);
- }
- else
- {
- gunorg[2] = vieworg[2];
- }
+ // 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(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);
+ VectorCopy(vieworg, 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((viewangles[PITCH] - cl.gunangles_highpass[PITCH]) / 360 + 0.5);
+ cl.gunangles_highpass[YAW] += 360 * floor((viewangles[YAW] - cl.gunangles_highpass[YAW]) / 360 + 0.5);
+ cl.gunangles_highpass[ROLL] += 360 * floor((viewangles[ROLL] - cl.gunangles_highpass[ROLL]) / 360 + 0.5);
+ 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);
+ VectorCopy(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(viewangles, gunangles, gunangles);
// view bobbing code
- xyspeed = sqrt(cl.movement_velocity[0]*cl.movement_velocity[0] + cl.movement_velocity[1]*cl.movement_velocity[1]);
+ xyspeed = sqrt(cl.velocity[0]*cl.velocity[0] + cl.velocity[1]*cl.velocity[1]);
if (cl_bob.value && cl_bobcycle.value)
{
- float cycle;
// LordHavoc: this code is *weird*, but not replacable (I think it
// should be done in QC on the server, but oh well, quake is quake)
// LordHavoc: figured out bobup: the time at which the sin is at 180
gunorg[2] += bound(-7, bob, 4);
}
+ // view rolling code
+ if (cl_bobroll.value && cl_bobrollcycle.value)
+ {
+ cycle2 = cl.time / cl_bobrollcycle.value;
+ cycle2 -= (int) cycle2;
+ if (cycle2 < 0.5)
+ cycle2 = sin(M_PI * cycle2 / 0.5);
+ else
+ cycle2 = sin(M_PI + M_PI * (cycle2-0.5)/0.5);
+
+ // 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
+ cl.bobroll_airtime = 1;
+ else
+ {
+ if(cl.bobroll_airtime > 0)
+ cl.bobroll_airtime -= bound(0, cl_bobrollairtime.value, 1);
+ else
+ cl.bobroll_airtime = 0;
+ }
+
+ cycle2 *= cl_bobroll.value * cl.bobroll_airtime;
+ bobroll = bound(0, xyspeed, sv_maxspeed.value) * cycle2;
+ viewangles[2] += bound(-45, bobroll, 45);
+ }
+
// gun model bobbing code
if (cl_bob.value && cl_bobmodel.value)
{
Cvar_RegisterVariable (&cl_bob);
Cvar_RegisterVariable (&cl_bobcycle);
Cvar_RegisterVariable (&cl_bobup);
+ Cvar_RegisterVariable (&cl_bobroll);
+ Cvar_RegisterVariable (&cl_bobrollcycle);
+ Cvar_RegisterVariable (&cl_bobrollairtime);
Cvar_RegisterVariable (&cl_bobmodel);
Cvar_RegisterVariable (&cl_bobmodel_side);
Cvar_RegisterVariable (&cl_bobmodel_up);
Cvar_RegisterVariable (&cl_bobmodel_speed);
- Cvar_RegisterVariable (&cl_leanmodel_side);
+ Cvar_RegisterVariable (&cl_leanmodel);
Cvar_RegisterVariable (&cl_leanmodel_side_speed);
Cvar_RegisterVariable (&cl_leanmodel_side_limit);
- Cvar_RegisterVariable (&cl_leanmodel_up);
+ 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_side);
+ Cvar_RegisterVariable (&cl_followmodel);
Cvar_RegisterVariable (&cl_followmodel_side_speed);
Cvar_RegisterVariable (&cl_followmodel_side_limit);
- Cvar_RegisterVariable (&cl_followmodel_up);
+ 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);