- Take better advantage of InputPacket::ang's FRotator status.

* Change it to a DRotator as that's what the game is expecting. Too many narrowings against DAngle objects needed.
* Utilise object methods where possible.
* Do all math against the object where possible, not its members.
This commit is contained in:
Mitchell Richters 2023-10-03 20:58:38 +11:00
parent 1732cd2e83
commit d6de57095d
19 changed files with 144 additions and 122 deletions

View file

@ -1457,6 +1457,24 @@ public:
} }
}; };
typedef TAngle<float> FAngle;
typedef TAngle<double> DAngle;
constexpr DAngle nullAngle = DAngle::fromDeg(0.);
constexpr FAngle nullFAngle = FAngle::fromDeg(0.);
constexpr DAngle minAngle = DAngle::fromDeg(1. / 65536.);
constexpr FAngle minFAngle = FAngle::fromDeg(1. / 65536.);
constexpr DAngle DAngle1 = DAngle::fromDeg(1);
constexpr DAngle DAngle15 = DAngle::fromDeg(15);
constexpr DAngle DAngle22_5 = DAngle::fromDeg(22.5);
constexpr DAngle DAngle45 = DAngle::fromDeg(45);
constexpr DAngle DAngle60 = DAngle::fromDeg(60);
constexpr DAngle DAngle90 = DAngle::fromDeg(90);
constexpr DAngle DAngle180 = DAngle::fromDeg(180);
constexpr DAngle DAngle270 = DAngle::fromDeg(270);
constexpr DAngle DAngle360 = DAngle::fromDeg(360);
template<class T> template<class T>
inline TAngle<T> fabs (const TAngle<T> &deg) inline TAngle<T> fabs (const TAngle<T> &deg)
{ {
@ -1528,6 +1546,12 @@ inline TVector3<T> clamp(const TVector3<T> &vec, const TVector3<T> &min, const T
return TVector3<T>(clamp(vec.X, min.X, max.X), clamp(vec.Y, min.Y, max.Y), clamp(vec.Z, min.Z, max.Z)); return TVector3<T>(clamp(vec.X, min.X, max.X), clamp(vec.Y, min.Y, max.Y), clamp(vec.Z, min.Z, max.Z));
} }
template<class T>
inline TRotator<T> clamp(const TRotator<T> &rot, const TRotator<T> &min, const TRotator<T> &max)
{
return TRotator<T>(clamp(rot.Pitch, min.Pitch, max.Pitch), clamp(rot.Yaw, min.Yaw, max.Yaw), clamp(rot.Roll, min.Roll, max.Roll));
}
template<class T> template<class T>
inline TAngle<T> interpolatedvalue(const TAngle<T> &oang, const TAngle<T> &ang, const double interpfrac) inline TAngle<T> interpolatedvalue(const TAngle<T> &oang, const TAngle<T> &ang, const double interpfrac)
{ {
@ -1570,6 +1594,16 @@ struct TRotator
TRotator(const TRotator &other) = default; TRotator(const TRotator &other) = default;
TRotator &operator= (const TRotator &other) = default; TRotator &operator= (const TRotator &other) = default;
void Zero()
{
Roll = Yaw = Pitch = nullAngle;
}
bool isZero() const
{
return Pitch == nullAngle && Yaw == nullAngle && Roll == nullAngle;
}
// Access angles as an array // Access angles as an array
Angle &operator[] (int index) Angle &operator[] (int index)
{ {
@ -1584,13 +1618,27 @@ struct TRotator
// Test for equality // Test for equality
bool operator== (const TRotator &other) const bool operator== (const TRotator &other) const
{ {
return fabs(Pitch - other.Pitch) < Angle(EQUAL_EPSILON) && fabs(Yaw - other.Yaw) < Angle(EQUAL_EPSILON) && fabs(Roll - other.Roll) < Angle(EQUAL_EPSILON); return Pitch == other.Pitch && Yaw == other.Yaw && Roll == other.Roll;
} }
// Test for inequality // Test for inequality
bool operator!= (const TRotator &other) const bool operator!= (const TRotator &other) const
{ {
return fabs(Pitch - other.Pitch) >= Angle(EQUAL_EPSILON) && fabs(Yaw - other.Yaw) >= Angle(EQUAL_EPSILON) && fabs(Roll - other.Roll) >= Angle(EQUAL_EPSILON); return Pitch != other.Pitch || Yaw != other.Yaw || Roll != other.Roll;
}
// Test for approximate equality
bool ApproximatelyEquals (const TRotator &other) const
{
constexpr auto epsilon = Angle(EQUAL_EPSILON);
return fabs(Pitch - other.Pitch) < epsilon && fabs(Yaw - other.Yaw) < epsilon && fabs(Roll - other.Roll) < epsilon;
}
// Test for approximate inequality
bool DoesNotApproximatelyEqual (const TRotator &other) const
{
constexpr auto epsilon = Angle(EQUAL_EPSILON);
return fabs(Pitch - other.Pitch) >= epsilon && fabs(Yaw - other.Yaw) >= epsilon && fabs(Roll - other.Roll) >= epsilon;
} }
// Unary negation // Unary negation
@ -1653,12 +1701,25 @@ struct TRotator
return *this; return *this;
} }
TRotator &operator/= (const vec_t &scalar)
{
const auto mul = 1. / scalar;
Pitch *= mul, Yaw *= mul, Roll *= mul;
return *this;
}
TRotator operator/ (const Angle &scalar) const TRotator operator/ (const Angle &scalar) const
{ {
Angle mul(1 / scalar.Degrees_); Angle mul(1 / scalar.Degrees_);
return TRotator(Pitch * mul, Yaw * mul, Roll * mul); return TRotator(Pitch * mul, Yaw * mul, Roll * mul);
} }
TRotator operator/ (const vec_t &scalar) const
{
const auto mul = 1. / scalar;
return TRotator(Pitch * mul, Yaw * mul, Roll * mul);
}
// Vector addition // Vector addition
TRotator &operator+= (const TRotator &other) TRotator &operator+= (const TRotator &other)
{ {
@ -1719,28 +1780,12 @@ typedef TVector3<float> FVector3;
typedef TVector4<float> FVector4; typedef TVector4<float> FVector4;
typedef TRotator<float> FRotator; typedef TRotator<float> FRotator;
typedef TMatrix3x3<float> FMatrix3x3; typedef TMatrix3x3<float> FMatrix3x3;
typedef TAngle<float> FAngle;
typedef TVector2<double> DVector2; typedef TVector2<double> DVector2;
typedef TVector3<double> DVector3; typedef TVector3<double> DVector3;
typedef TVector4<double> DVector4; typedef TVector4<double> DVector4;
typedef TRotator<double> DRotator; typedef TRotator<double> DRotator;
typedef TMatrix3x3<double> DMatrix3x3; typedef TMatrix3x3<double> DMatrix3x3;
typedef TAngle<double> DAngle;
constexpr DAngle nullAngle = DAngle::fromDeg(0.);
constexpr DAngle minAngle = DAngle::fromDeg(1. / 65536.);
constexpr FAngle nullFAngle = FAngle::fromDeg(0.);
constexpr DAngle DAngle1 = DAngle::fromDeg(1);
constexpr DAngle DAngle15 = DAngle::fromDeg(15);
constexpr DAngle DAngle22_5 = DAngle::fromDeg(22.5);
constexpr DAngle DAngle45 = DAngle::fromDeg(45);
constexpr DAngle DAngle60 = DAngle::fromDeg(60);
constexpr DAngle DAngle90 = DAngle::fromDeg(90);
constexpr DAngle DAngle180 = DAngle::fromDeg(180);
constexpr DAngle DAngle270 = DAngle::fromDeg(270);
constexpr DAngle DAngle360 = DAngle::fromDeg(360);
class Plane class Plane
{ {

View file

@ -1033,31 +1033,23 @@ void NetUpdate (void)
int modp, tic; int modp, tic;
DVector3 vel{}; DVector3 vel{};
float avel = 0; DRotator ang{};
float horz = 0;
float roll = 0;
for (tic = 0; tic < ticdup; ++tic) for (tic = 0; tic < ticdup; ++tic)
{ {
modp = (mod + tic) % LOCALCMDTICS; modp = (mod + tic) % LOCALCMDTICS;
vel += localcmds[modp].ucmd.vel; vel += localcmds[modp].ucmd.vel;
avel += localcmds[modp].ucmd.ang.Yaw.Degrees(); ang += localcmds[modp].ucmd.ang;
horz += localcmds[modp].ucmd.ang.Pitch.Degrees();
roll += localcmds[modp].ucmd.ang.Roll.Degrees();
} }
vel /= ticdup; vel /= ticdup;
avel /= ticdup; ang /= ticdup;
horz /= ticdup;
roll /= ticdup;
for (tic = 0; tic < ticdup; ++tic) for (tic = 0; tic < ticdup; ++tic)
{ {
modp = (mod + tic) % LOCALCMDTICS; modp = (mod + tic) % LOCALCMDTICS;
localcmds[modp].ucmd.vel = vel; localcmds[modp].ucmd.vel = vel;
localcmds[modp].ucmd.ang.Yaw = FAngle::fromDeg(avel); localcmds[modp].ucmd.ang = ang;
localcmds[modp].ucmd.ang.Pitch = FAngle::fromDeg(horz);
localcmds[modp].ucmd.ang.Roll = FAngle::fromDeg(roll);
} }
Net_NewMakeTic (); Net_NewMakeTic ();

View file

@ -160,9 +160,9 @@ int UnpackUserCmd (InputPacket *ucmd, const InputPacket *basis, uint8_t **stream
if (flags & UCMDF_BUTTONS) if (flags & UCMDF_BUTTONS)
ucmd->actions = ESyncBits::FromInt(ReadLong(stream)); ucmd->actions = ESyncBits::FromInt(ReadLong(stream));
if (flags & UCMDF_PITCH) if (flags & UCMDF_PITCH)
ucmd->ang.Pitch = FAngle::fromDeg(ReadFloat(stream)); ucmd->ang.Pitch = DAngle::fromDeg(ReadFloat(stream));
if (flags & UCMDF_YAW) if (flags & UCMDF_YAW)
ucmd->ang.Yaw = FAngle::fromDeg(ReadFloat(stream)); ucmd->ang.Yaw = DAngle::fromDeg(ReadFloat(stream));
if (flags & UCMDF_FORWARDMOVE) if (flags & UCMDF_FORWARDMOVE)
ucmd->vel.X = ReadFloat(stream); ucmd->vel.X = ReadFloat(stream);
if (flags & UCMDF_SIDEMOVE) if (flags & UCMDF_SIDEMOVE)
@ -170,7 +170,7 @@ int UnpackUserCmd (InputPacket *ucmd, const InputPacket *basis, uint8_t **stream
if (flags & UCMDF_UPMOVE) if (flags & UCMDF_UPMOVE)
ucmd->vel.Z = ReadFloat(stream); ucmd->vel.Z = ReadFloat(stream);
if (flags & UCMDF_ROLL) if (flags & UCMDF_ROLL)
ucmd->ang.Roll = FAngle::fromDeg(ReadFloat(stream)); ucmd->ang.Roll = DAngle::fromDeg(ReadFloat(stream));
} }
return int(*stream - start); return int(*stream - start);
@ -200,12 +200,12 @@ int PackUserCmd (const InputPacket *ucmd, const InputPacket *basis, uint8_t **st
if (ucmd->ang.Pitch != basis->ang.Pitch) if (ucmd->ang.Pitch != basis->ang.Pitch)
{ {
flags |= UCMDF_PITCH; flags |= UCMDF_PITCH;
WriteFloat (ucmd->ang.Pitch.Degrees(), stream); WriteFloat ((float)ucmd->ang.Pitch.Degrees(), stream);
} }
if (ucmd->ang.Yaw != basis->ang.Yaw) if (ucmd->ang.Yaw != basis->ang.Yaw)
{ {
flags |= UCMDF_YAW; flags |= UCMDF_YAW;
WriteFloat (ucmd->ang.Yaw.Degrees(), stream); WriteFloat ((float)ucmd->ang.Yaw.Degrees(), stream);
} }
if (ucmd->vel.X != basis->vel.X) if (ucmd->vel.X != basis->vel.X)
{ {
@ -225,7 +225,7 @@ int PackUserCmd (const InputPacket *ucmd, const InputPacket *basis, uint8_t **st
if (ucmd->ang.Roll != basis->ang.Roll) if (ucmd->ang.Roll != basis->ang.Roll)
{ {
flags |= UCMDF_ROLL; flags |= UCMDF_ROLL;
WriteFloat (ucmd->ang.Roll.Degrees(), stream); WriteFloat ((float)ucmd->ang.Roll.Degrees(), stream);
} }
// Write the packing bits // Write the packing bits
@ -250,10 +250,8 @@ FSerializer &Serialize(FSerializer &arc, const char *key, InputPacket &cmd, Inpu
if (arc.BeginObject(key)) if (arc.BeginObject(key))
{ {
arc("actions", cmd.actions) arc("actions", cmd.actions)
("horz", cmd.ang.Pitch)
("avel", cmd.ang.Yaw)
("vel", cmd.vel) ("vel", cmd.vel)
("roll", cmd.ang.Roll) ("ang", cmd.ang)
.EndObject(); .EndObject();
} }
return arc; return arc;
@ -263,22 +261,13 @@ int WriteUserCmdMessage (InputPacket *ucmd, const InputPacket *basis, uint8_t **
{ {
if (basis == NULL) if (basis == NULL)
{ {
if (ucmd->actions != 0 || if (ucmd->actions != 0 || !ucmd->vel.isZero() || !ucmd->ang.isZero())
ucmd->ang.Pitch.Degrees() != 0 ||
ucmd->ang.Yaw.Degrees() != 0 ||
!ucmd->vel.isZero() ||
ucmd->ang.Roll.Degrees() != 0)
{ {
WriteByte (DEM_USERCMD, stream); WriteByte (DEM_USERCMD, stream);
return PackUserCmd (ucmd, basis, stream) + 1; return PackUserCmd (ucmd, basis, stream) + 1;
} }
} }
else else if (ucmd->actions != basis->actions || ucmd->vel != basis->vel || ucmd->ang != basis->ang)
if (ucmd->actions != basis->actions ||
ucmd->ang.Pitch != basis->ang.Pitch ||
ucmd->ang.Yaw != basis->ang.Yaw ||
ucmd->vel != basis->vel ||
ucmd->ang.Roll != basis->ang.Roll)
{ {
WriteByte (DEM_USERCMD, stream); WriteByte (DEM_USERCMD, stream);
return PackUserCmd (ucmd, basis, stream) + 1; return PackUserCmd (ucmd, basis, stream) + 1;

View file

@ -100,12 +100,12 @@ void GameInput::resetCrouchToggle()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void GameInput::processMovement(PlayerAngles* const plrAngles, const float scaleAdjust, const int drink_amt, const bool allowstrafe, const float turnscale) void GameInput::processMovement(PlayerAngles* const plrAngles, const double scaleAdjust, const int drink_amt, const bool allowstrafe, const double turnscale)
{ {
// set up variables. // set up variables.
InputPacket thisInput{}; InputPacket thisInput{};
const auto keymove = 1 << int(!!(inputBuffer.actions & SB_RUN)); const auto keymove = 1 << int(!!(inputBuffer.actions & SB_RUN));
const auto hidspeed = float(getTicrateScale(YAW_TURNSPEEDS[2])); const auto hidspeed = DAngle::fromDeg(getTicrateScale(YAW_TURNSPEEDS[2]));
// get all input amounts. // get all input amounts.
const auto turning = buttonMap.ButtonDown(gamefunc_Turn_Right) - const auto turning = buttonMap.ButtonDown(gamefunc_Turn_Right) -
@ -126,18 +126,18 @@ void GameInput::processMovement(PlayerAngles* const plrAngles, const float scale
// process player yaw input. // process player yaw input.
if (!(buttonMap.ButtonDown(gamefunc_Strafe) && allowstrafe)) if (!(buttonMap.ButtonDown(gamefunc_Strafe) && allowstrafe))
{ {
const float turndir = clamp(turning + strafing * !allowstrafe, -1.f, 1.f); const double turndir = clamp(turning + strafing * !allowstrafe, -1., 1.);
const float tttscale = 1.f / (!(cl_noturnscaling || isTurboTurnTime()) * 2.8f + 1.f); const double tttscale = 1. / (1 + !(cl_noturnscaling || isTurboTurnTime()) * 2.8);
const float turnspeed = float(getTicrateScale(YAW_TURNSPEEDS[keymove]) * tttscale); const DAngle turnspeed = DAngle::fromDeg(getTicrateScale(YAW_TURNSPEEDS[keymove]) * tttscale);
thisInput.ang.Yaw += FAngle::fromDeg(mouseInput.X * MOUSE_SCALE * m_yaw); thisInput.ang.Yaw += MOUSE_SCALE * mouseInput.X * m_yaw;
thisInput.ang.Yaw -= FAngle::fromDeg(joyAxes[JOYAXIS_Yaw] * hidspeed * scaleAdjust); thisInput.ang.Yaw -= hidspeed * joyAxes[JOYAXIS_Yaw] * scaleAdjust;
thisInput.ang.Yaw += FAngle::fromDeg(turndir * turnspeed * scaleAdjust); thisInput.ang.Yaw += turnspeed * turndir * scaleAdjust;
thisInput.ang.Yaw *= turnscale; thisInput.ang.Yaw *= turnscale;
if (turndir) updateTurnHeldAmt(scaleAdjust); else turnheldtime = 0; if (turndir) updateTurnHeldAmt(scaleAdjust); else turnheldtime = 0;
} }
else else
{ {
thisInput.vel.Y += mouseInput.X * MOUSE_SCALE * m_side; thisInput.vel.Y += mouseInput.X * MOUSE_SCALE.Degrees() * m_side;
thisInput.vel.Y -= joyAxes[JOYAXIS_Yaw] * keymove * scaleAdjust; thisInput.vel.Y -= joyAxes[JOYAXIS_Yaw] * keymove * scaleAdjust;
thisInput.vel.Y += turning * keymove * scaleAdjust; thisInput.vel.Y += turning * keymove * scaleAdjust;
} }
@ -145,13 +145,13 @@ void GameInput::processMovement(PlayerAngles* const plrAngles, const float scale
// process player pitch input. // process player pitch input.
if (!(inputBuffer.actions & SB_AIMMODE)) if (!(inputBuffer.actions & SB_AIMMODE))
{ {
thisInput.ang.Pitch -= FAngle::fromDeg(mouseInput.Y * MOUSE_SCALE * m_pitch); thisInput.ang.Pitch -= MOUSE_SCALE * mouseInput.Y * m_pitch;
thisInput.ang.Pitch -= FAngle::fromDeg(joyAxes[JOYAXIS_Pitch] * hidspeed * scaleAdjust); thisInput.ang.Pitch -= hidspeed * joyAxes[JOYAXIS_Pitch] * scaleAdjust;
thisInput.ang.Pitch *= turnscale; thisInput.ang.Pitch *= turnscale;
} }
else else
{ {
thisInput.vel.X += mouseInput.Y * MOUSE_SCALE * m_forward; thisInput.vel.X += mouseInput.Y * MOUSE_SCALE.Degrees() * m_forward;
thisInput.vel.X += joyAxes[JOYAXIS_Pitch] * keymove * scaleAdjust; thisInput.vel.X += joyAxes[JOYAXIS_Pitch] * keymove * scaleAdjust;
} }
@ -168,18 +168,16 @@ void GameInput::processMovement(PlayerAngles* const plrAngles, const float scale
// add collected input to game's local input accumulation packet. // add collected input to game's local input accumulation packet.
const DVector3 maxVel{ (double)keymove, (double)keymove, 1. }; const DVector3 maxVel{ (double)keymove, (double)keymove, 1. };
const DRotator maxAng{ MAXANG, MAXANG, MAXANG };
inputBuffer.vel.X = clamp(inputBuffer.vel.X + thisInput.vel.X, -(double)keymove, (double)keymove); inputBuffer.vel.X = clamp(inputBuffer.vel.X + thisInput.vel.X, -(double)keymove, (double)keymove);
inputBuffer.vel.Y = clamp(inputBuffer.vel.Y + thisInput.vel.Y, -(double)keymove, (double)keymove); inputBuffer.vel.Y = clamp(inputBuffer.vel.Y + thisInput.vel.Y, -(double)keymove, (double)keymove);
inputBuffer.vel.Z = clamp(inputBuffer.vel.Z + thisInput.vel.Z, -1., 1.); inputBuffer.vel.Z = clamp(inputBuffer.vel.Z + thisInput.vel.Z, -1., 1.);
inputBuffer.ang.Yaw = clamp(inputBuffer.ang.Yaw + thisInput.ang.Yaw, FAngle::fromDeg(-179.f), FAngle::fromDeg(179.f)); inputBuffer.ang = clamp(inputBuffer.ang + thisInput.ang, -maxAng, maxAng);
inputBuffer.ang.Pitch = clamp(inputBuffer.ang.Pitch + thisInput.ang.Pitch, FAngle::fromDeg(-179.f), FAngle::fromDeg(179.f));
// directly update player angles if we can. // directly update player angles if we can.
if (scaleAdjust < 1) if (scaleAdjust < 1)
{ {
plrAngles->CameraAngles.Yaw += DAngle::fromDeg(thisInput.ang.Yaw.Degrees()); plrAngles->CameraAngles += thisInput.ang;
plrAngles->CameraAngles.Roll += DAngle::fromDeg(thisInput.ang.Roll.Degrees());
plrAngles->CameraAngles.Pitch += DAngle::fromDeg(thisInput.ang.Pitch.Degrees());
} }
} }
@ -190,7 +188,7 @@ void GameInput::processMovement(PlayerAngles* const plrAngles, const float scale
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void GameInput::processVehicle(PlayerAngles* const plrAngles, const float scaleAdjust, const float baseVel, const float velScale, const unsigned flags) void GameInput::processVehicle(PlayerAngles* const plrAngles, const double scaleAdjust, const double baseVel, const double velScale, const unsigned flags)
{ {
// open up input packet for this session. // open up input packet for this session.
InputPacket thisInput{}; InputPacket thisInput{};
@ -226,12 +224,12 @@ void GameInput::processVehicle(PlayerAngles* const plrAngles, const float scaleA
const auto scaleVel = !(flags & VEH_SCALETURN) && (cl_noturnscaling || hidDir || isTurboTurnTime()); const auto scaleVel = !(flags & VEH_SCALETURN) && (cl_noturnscaling || hidDir || isTurboTurnTime());
const auto turnVel = scaleVel ? baseVel : baseVel * velScale; const auto turnVel = scaleVel ? baseVel : baseVel * velScale;
const auto mouseVel = abs(turnVel * mouseInput.X * m_yaw) * (45.f / 2048.f) / scaleAdjust; const auto mouseVel = abs(turnVel * mouseInput.X * m_yaw) * (45.f / 2048.f) / scaleAdjust;
const auto maxVel = FAngle::fromDeg(abs(turnVel * 1.5f)); const auto maxVel = DAngle::fromDeg(abs(turnVel * 1.5f));
// Apply inputs. // Apply inputs.
thisInput.ang.Yaw += FAngle::fromDeg(((mouseVel > 1) ? sqrtf(mouseVel) : mouseVel) * Sgn(turnVel) * Sgn(mouseInput.X) * Sgn(m_yaw)); thisInput.ang.Yaw += DAngle::fromDeg(((mouseVel > 1) ? sqrt(mouseVel) : mouseVel) * Sgn(turnVel) * Sgn(mouseInput.X) * Sgn(m_yaw));
thisInput.ang.Yaw -= FAngle::fromDeg(turnVel * joyAxes[JOYAXIS_Yaw]); thisInput.ang.Yaw -= DAngle::fromDeg(turnVel * joyAxes[JOYAXIS_Yaw]);
thisInput.ang.Yaw += FAngle::fromDeg(turnVel * kbdDir); thisInput.ang.Yaw += DAngle::fromDeg(turnVel * kbdDir);
thisInput.ang.Yaw *= scaleAdjust; thisInput.ang.Yaw *= scaleAdjust;
inputBuffer.ang.Yaw = clamp(inputBuffer.ang.Yaw + thisInput.ang.Yaw, -maxVel, maxVel); inputBuffer.ang.Yaw = clamp(inputBuffer.ang.Yaw + thisInput.ang.Yaw, -maxVel, maxVel);
if (kbdDir) updateTurnHeldAmt(scaleAdjust); else turnheldtime = 0; if (kbdDir) updateTurnHeldAmt(scaleAdjust); else turnheldtime = 0;
@ -244,9 +242,7 @@ void GameInput::processVehicle(PlayerAngles* const plrAngles, const float scaleA
// directly update player angles if we can. // directly update player angles if we can.
if (scaleAdjust < 1) if (scaleAdjust < 1)
{ {
plrAngles->CameraAngles.Yaw += DAngle::fromDeg(thisInput.ang.Yaw.Degrees()); plrAngles->CameraAngles += thisInput.ang;
plrAngles->CameraAngles.Roll += DAngle::fromDeg(thisInput.ang.Roll.Degrees());
plrAngles->CameraAngles.Pitch += DAngle::fromDeg(thisInput.ang.Pitch.Degrees());
} }
} }
@ -368,7 +364,7 @@ void GameInput::getInput(const double scaleAdjust, InputPacket* packet)
I_GetAxes(joyAxes); I_GetAxes(joyAxes);
processInputBits(); processInputBits();
gi->doPlayerMovement(!SyncInput() ? (float)scaleAdjust : 1.f); gi->doPlayerMovement(!SyncInput() ? scaleAdjust : 1.);
mouseInput.Zero(); mouseInput.Zero();
if (packet) if (packet)
@ -390,7 +386,7 @@ void PlayerAngles::doPitchInput(InputPacket* const input)
// Add player's mouse/device input. // Add player's mouse/device input.
if (input->ang.Pitch.Degrees()) if (input->ang.Pitch.Degrees())
{ {
pActor->spr.Angles.Pitch += DAngle::fromDeg(input->ang.Pitch.Degrees() * SyncInput()); pActor->spr.Angles.Pitch += input->ang.Pitch * SyncInput();
input->actions &= ~SB_CENTERVIEW; input->actions &= ~SB_CENTERVIEW;
} }
@ -437,7 +433,7 @@ void PlayerAngles::doPitchInput(InputPacket* const input)
void PlayerAngles::doYawInput(InputPacket* const input) void PlayerAngles::doYawInput(InputPacket* const input)
{ {
// Add player's mouse/device input. // Add player's mouse/device input.
pActor->spr.Angles.Yaw += DAngle::fromDeg(input->ang.Yaw.Degrees() * SyncInput()); pActor->spr.Angles.Yaw += input->ang.Yaw * SyncInput();
if (input->actions & SB_TURNAROUND) if (input->actions & SB_TURNAROUND)
{ {
@ -560,7 +556,7 @@ void PlayerAngles::doRollInput(InputPacket* const input, const DVector2& nVelVec
if (cl_viewtilting == 1) if (cl_viewtilting == 1)
{ {
// Console-like yaw rolling. Adjustment == ~(90/32) for keyboard turning. Clamp is 1.5x this value. // Console-like yaw rolling. Adjustment == ~(90/32) for keyboard turning. Clamp is 1.5x this value.
const auto rollAdj = DAngle::fromDeg(input->ang.Yaw.Degrees() * ROLL_TILTAVELSCALE * rollAmp); const auto rollAdj = input->ang.Yaw * ROLL_TILTAVELSCALE * rollAmp;
const auto rollMax = DAngle::fromDeg((90. / 32. * 1.5) * cl_viewtiltscale); const auto rollMax = DAngle::fromDeg((90. / 32. * 1.5) * cl_viewtiltscale);
scaletozero(pActor->spr.Angles.Roll, ROLL_TILTRETURN); scaletozero(pActor->spr.Angles.Roll, ROLL_TILTRETURN);
pActor->spr.Angles.Roll = clamp(pActor->spr.Angles.Roll + rollAdj, -rollMax, rollMax); pActor->spr.Angles.Roll = clamp(pActor->spr.Angles.Roll + rollAdj, -rollMax, rollMax);
@ -588,7 +584,7 @@ void PlayerAngles::doRollInput(InputPacket* const input, const DVector2& nVelVec
else else
{ {
// Add player's device input. // Add player's device input.
pActor->spr.Angles.Roll += DAngle::fromDeg(input->ang.Roll.Degrees() * SyncInput()); pActor->spr.Angles.Roll += input->ang.Roll * SyncInput();
} }
} }

View file

@ -30,7 +30,8 @@ class GameInput
}; };
static constexpr double YAW_TURNSPEEDS[3] = { 234.375 * (360. / 2048.), 890.625 * (360. / 2048.), 1548.75 * (360. / 2048.) }; static constexpr double YAW_TURNSPEEDS[3] = { 234.375 * (360. / 2048.), 890.625 * (360. / 2048.), 1548.75 * (360. / 2048.) };
static constexpr float MOUSE_SCALE = (1.f / 16.f); static constexpr DAngle MOUSE_SCALE = DAngle::fromDeg(1. / 16.);
static constexpr DAngle MAXANG = DAngle180 - minAngle;
// Input received from the OS. // Input received from the OS.
float joyAxes[NUM_JOYAXIS]; float joyAxes[NUM_JOYAXIS];
@ -44,7 +45,7 @@ class GameInput
ESyncBits ActionsToSend; ESyncBits ActionsToSend;
// Turn speed doubling after x amount of tics. // Turn speed doubling after x amount of tics.
void updateTurnHeldAmt(const float scaleAdjust) void updateTurnHeldAmt(const double scaleAdjust)
{ {
turnheldtime += getTicrateScale(BUILDTICRATE) * scaleAdjust; turnheldtime += getTicrateScale(BUILDTICRATE) * scaleAdjust;
} }
@ -81,8 +82,8 @@ public:
} }
// Prototypes for large member functions. // Prototypes for large member functions.
void processMovement(PlayerAngles* const plrAngles, const float scaleAdjust, const int drink_amt = 0, const bool allowstrafe = true, const float turnscale = 1.f); void processMovement(PlayerAngles* const plrAngles, const double scaleAdjust, const int drink_amt = 0, const bool allowstrafe = true, const double turnscale = 1.);
void processVehicle(PlayerAngles* const plrAngles, const float scaleAdjust, const float baseVel, const float velScale, const unsigned flags); void processVehicle(PlayerAngles* const plrAngles, const double scaleAdjust, const double baseVel, const double velScale, const unsigned flags);
void getInput(const double scaleAdjust, InputPacket* packet = nullptr); void getInput(const double scaleAdjust, InputPacket* packet = nullptr);
void resetCrouchToggle(); void resetCrouchToggle();
}; };
@ -99,8 +100,8 @@ struct PlayerAngles
DAngle YawSpin; DAngle YawSpin;
friend FSerializer& Serialize(FSerializer& arc, const char* keyname, PlayerAngles& w, PlayerAngles* def); friend FSerializer& Serialize(FSerializer& arc, const char* keyname, PlayerAngles& w, PlayerAngles* def);
friend void GameInput::processMovement(PlayerAngles* const plrAngles, const float scaleAdjust, const int drink_amt, const bool allowstrafe, const float turnscale); friend void GameInput::processMovement(PlayerAngles* const plrAngles, const double scaleAdjust, const int drink_amt, const bool allowstrafe, const double turnscale);
friend void GameInput::processVehicle(PlayerAngles* const plrAngles, const float scaleAdjust, const float baseVel, const float velScale, const unsigned flags); friend void GameInput::processVehicle(PlayerAngles* const plrAngles, const double scaleAdjust, const double baseVel, const double velScale, const unsigned flags);
// Prototypes. // Prototypes.
void doPitchInput(InputPacket* const input); void doPitchInput(InputPacket* const input);

View file

@ -115,7 +115,7 @@ struct GameInterface
virtual void RemoveQAVInterpProps(const int res_id) { } virtual void RemoveQAVInterpProps(const int res_id) { }
virtual bool WantEscape() { return false; } virtual bool WantEscape() { return false; }
virtual void StartSoundEngine() = 0; virtual void StartSoundEngine() = 0;
virtual void doPlayerMovement(const float scaleAdjust) = 0; virtual void doPlayerMovement(const double scaleAdjust) = 0;
virtual unsigned getCrouchState() = 0; virtual unsigned getCrouchState() = 0;
virtual FString statFPS() virtual FString statFPS()

View file

@ -71,7 +71,7 @@ enum
struct InputPacket struct InputPacket
{ {
DVector3 vel; DVector3 vel;
FRotator ang; DRotator ang;
ESyncBits actions; ESyncBits actions;

View file

@ -135,7 +135,7 @@ struct GameInterface : public ::GameInterface
void AddQAVInterpProps(const int res_id, const FString& interptype, const bool loopable, const TMap<int, TArray<int>>&& ignoredata) override; void AddQAVInterpProps(const int res_id, const FString& interptype, const bool loopable, const TMap<int, TArray<int>>&& ignoredata) override;
void RemoveQAVInterpProps(const int res_id) override; void RemoveQAVInterpProps(const int res_id) override;
void StartSoundEngine() override; void StartSoundEngine() override;
void doPlayerMovement(const float scaleAdjust) override { gameInput.processMovement(&getPlayer(myconnectindex)->Angles, scaleAdjust); } void doPlayerMovement(const double scaleAdjust) override { gameInput.processMovement(&getPlayer(myconnectindex)->Angles, scaleAdjust); }
unsigned getCrouchState() override; unsigned getCrouchState() override;
}; };

View file

@ -857,10 +857,9 @@ void playerStart(int nPlayer, int bNewLevel)
pPlayer->deathTime = 0; pPlayer->deathTime = 0;
pPlayer->nextWeapon = kWeapNone; pPlayer->nextWeapon = kWeapNone;
actor->vel.Zero(); actor->vel.Zero();
pInput->ang.Yaw = nullFAngle;
pInput->actions = 0; pInput->actions = 0;
pInput->vel.Zero(); pInput->vel.Zero();
pInput->ang.Pitch = nullFAngle; pInput->ang.Zero();
pPlayer->flickerEffect = 0; pPlayer->flickerEffect = 0;
pPlayer->quakeEffect = 0; pPlayer->quakeEffect = 0;
pPlayer->tiltEffect = 0; pPlayer->tiltEffect = 0;

View file

@ -37,7 +37,7 @@ struct GameInterface : public ::GameInterface
void SerializeGameState(FSerializer& arc) override; void SerializeGameState(FSerializer& arc) override;
void ExitFromMenu() override; void ExitFromMenu() override;
void DrawPlayerSprite(const DVector2& origin, bool onteam) override; void DrawPlayerSprite(const DVector2& origin, bool onteam) override;
void doPlayerMovement(const float scaleAdjust) override; void doPlayerMovement(const double scaleAdjust) override;
unsigned getCrouchState() override; unsigned getCrouchState() override;
void UpdateSounds() override; void UpdateSounds() override;
void Startup() override; void Startup() override;

View file

@ -509,25 +509,25 @@ unsigned GameInterface::getCrouchState()
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void GameInterface::doPlayerMovement(const float scaleAdjust) void GameInterface::doPlayerMovement(const double scaleAdjust)
{ {
const auto p = getPlayer(myconnectindex); const auto p = getPlayer(myconnectindex);
if (isRRRA() && (p->OnMotorcycle || p->OnBoat)) if (isRRRA() && (p->OnMotorcycle || p->OnBoat))
{ {
static constexpr float VEHICLETURN = (20.f * 360.f / 2048.f); static constexpr double VEHICLETURN = (20.f * 360.f / 2048.f);
float baseVel, velScale; unsigned vehFlags; double baseVel, velScale; unsigned vehFlags;
if (p->OnMotorcycle) if (p->OnMotorcycle)
{ {
vehFlags = VEH_CANTURN | (VEH_CANMOVE * !p->moto_underwater) | (VEH_SCALETURN * (p->MotoSpeed <= 0)); vehFlags = VEH_CANTURN | (VEH_CANMOVE * !p->moto_underwater) | (VEH_SCALETURN * (p->MotoSpeed <= 0));
velScale = (3.f / 10.f); velScale = (3. / 10.);
baseVel = VEHICLETURN * Sgn(p->MotoSpeed); baseVel = VEHICLETURN * Sgn(p->MotoSpeed);
} }
else else
{ {
vehFlags = VEH_CANMOVE | (VEH_CANTURN * (p->MotoSpeed || p->moto_drink)); vehFlags = VEH_CANMOVE | (VEH_CANTURN * (p->MotoSpeed || p->moto_drink));
velScale = !p->NotOnWater? 1.f : (6.f / 19.f); velScale = !p->NotOnWater? 1. : (6. / 19.);
baseVel = VEHICLETURN * velScale; baseVel = VEHICLETURN * velScale;
} }
@ -535,7 +535,7 @@ void GameInterface::doPlayerMovement(const float scaleAdjust)
} }
else else
{ {
gameInput.processMovement(&p->Angles, scaleAdjust, p->drink_amt, true, (p->psectlotag != ST_2_UNDERWATER) ? 1.f : 0.875f); gameInput.processMovement(&p->Angles, scaleAdjust, p->drink_amt, true, (p->psectlotag != ST_2_UNDERWATER) ? 1. : 0.875);
} }
} }

View file

@ -857,7 +857,7 @@ void playerCenterView(int snum)
if (GetGameVarID(g_iReturnVarID, p->GetActor(), snum).value() == 0) if (GetGameVarID(g_iReturnVarID, p->GetActor(), snum).value() == 0)
{ {
p->cmd.ucmd.actions |= SB_CENTERVIEW; p->cmd.ucmd.actions |= SB_CENTERVIEW;
p->cmd.ucmd.ang.Pitch = nullFAngle; p->cmd.ucmd.ang.Pitch = nullAngle;
setForcedSyncInput(snum); setForcedSyncInput(snum);
} }
else else

View file

@ -1714,7 +1714,7 @@ void processinput_d(int snum)
doubvel = 0; doubvel = 0;
p->vel.X = 0; p->vel.X = 0;
p->vel.Y = 0; p->vel.Y = 0;
p->cmd.ucmd.ang.Yaw = nullFAngle; p->cmd.ucmd.ang.Yaw = nullAngle;
setForcedSyncInput(snum); setForcedSyncInput(snum);
} }

View file

@ -729,7 +729,7 @@ static unsigned outVehicleFlags(DDukePlayer* p, ESyncBits& actions)
static void doVehicleTilting(DDukePlayer* const p, const bool canTilt) static void doVehicleTilting(DDukePlayer* const p, const bool canTilt)
{ {
auto adj = DAngle::fromDeg(p->cmd.ucmd.ang.Yaw.Degrees() * (545943. / 3200000.) * canTilt); auto adj = p->cmd.ucmd.ang.Yaw * (545943. / 3200000.) * canTilt;
if (p->OnMotorcycle) adj *= 5 * Sgn(p->MotoSpeed); if (p->OnMotorcycle) adj *= 5 * Sgn(p->MotoSpeed);
if (cl_rrvehicletilting) adj *= cl_viewtiltscale; if (cl_rrvehicletilting) adj *= cl_viewtiltscale;
p->oTiltStatus = p->TiltStatus; p->oTiltStatus = p->TiltStatus;
@ -2541,7 +2541,7 @@ void processinput_r(int snum)
doubvel = 0; doubvel = 0;
p->vel.X = 0; p->vel.X = 0;
p->vel.Y = 0; p->vel.Y = 0;
p->cmd.ucmd.ang.Yaw = nullFAngle; p->cmd.ucmd.ang.Yaw = nullAngle;
setForcedSyncInput(snum); setForcedSyncInput(snum);
} }

View file

@ -387,7 +387,7 @@ public:
if ((centertest && returnlock) || !cmd.ucmd.ang.Pitch.Degrees()) if ((centertest && returnlock) || !cmd.ucmd.ang.Pitch.Degrees())
{ {
setForcedSyncInput(snum); setForcedSyncInput(snum);
cmd.ucmd.ang.Pitch = nullFAngle; cmd.ucmd.ang.Pitch = nullAngle;
} }
else else
{ {

View file

@ -238,7 +238,7 @@ struct GameInterface : public ::GameInterface
void processSprites(tspriteArray& tsprites, const DVector3& view, DAngle viewang, double interpfrac) override; void processSprites(tspriteArray& tsprites, const DVector3& view, DAngle viewang, double interpfrac) override;
int GetCurrentSkill() override; int GetCurrentSkill() override;
void StartSoundEngine() override; void StartSoundEngine() override;
void doPlayerMovement(const float scaleAdjust) override { gameInput.processMovement(&getPlayer(nLocalPlayer)->Angles, scaleAdjust); } void doPlayerMovement(const double scaleAdjust) override { gameInput.processMovement(&getPlayer(nLocalPlayer)->Angles, scaleAdjust); }
unsigned getCrouchState() override; unsigned getCrouchState() override;
}; };

View file

@ -46,7 +46,7 @@ Weapon WeaponInfo[] = {
}; };
static const uint8_t nMinAmmo[] = { 0, 24, 51, 50, 1, 0, 0 }; static const uint8_t nMinAmmo[] = { 0, 24, 51, 50, 1, 0, 0 };
static FAngle lastavel; static DAngle lastavel;
int isRed = 0; int isRed = 0;

View file

@ -1901,10 +1901,10 @@ struct GameInterface : public ::GameInterface
int GetCurrentSkill() override; int GetCurrentSkill() override;
void StartSoundEngine() override; void StartSoundEngine() override;
unsigned getCrouchState() override; unsigned getCrouchState() override;
void doPlayerMovement(const float scaleAdjust) override void doPlayerMovement(const double scaleAdjust) override
{ {
const auto pp = getPlayer(myconnectindex); const auto pp = getPlayer(myconnectindex);
gameInput.processMovement(&pp->Angles, scaleAdjust, 0, !pp->sop, pp->sop_control ? (3.f / 1.40625f) : 1.f); gameInput.processMovement(&pp->Angles, scaleAdjust, 0, !pp->sop, pp->sop_control ? (3. / 1.40625) : 1.);
} }
}; };

View file

@ -1444,13 +1444,13 @@ void UpdatePlayerSpriteAngle(DSWPlayer* pp)
// //
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
void DoPlayerVehicleInputScaling(DSWPlayer* const pp, FAngle FRotator::* angle, const float scale) void DoPlayerVehicleInputScaling(DSWPlayer* const pp, DAngle DRotator::* angle, const float scale)
{ {
SECTOR_OBJECT* sop = pp->sop; SECTOR_OBJECT* sop = pp->sop;
if (sop->drive_angspeed) if (sop->drive_angspeed)
{ {
pp->cmd.ucmd.ang.*angle = FAngle::fromDeg(float((((pp->cmd.ucmd.ang.*angle).Degrees() * sop->drive_angspeed) + ((pp->lastcmd.ucmd.ang.*angle).Degrees() * (sop->drive_angslide - 1))) / sop->drive_angslide)); pp->cmd.ucmd.ang.*angle = ((pp->cmd.ucmd.ang.*angle * sop->drive_angspeed) + (pp->lastcmd.ucmd.ang.*angle * (sop->drive_angslide - 1))) / sop->drive_angslide;
} }
else else
{ {
@ -2231,7 +2231,7 @@ void DriveCrush(DSWPlayer* pp, DVector2* quad)
return; return;
// not moving - don't crush // not moving - don't crush
if ((pp->vect.isZero()) == 0 && pp->cmd.ucmd.ang.Yaw == nullFAngle) if ((pp->vect.isZero()) == 0 && pp->cmd.ucmd.ang.Yaw == nullAngle)
return; return;
// main sector // main sector
@ -2455,8 +2455,8 @@ void DoPlayerMoveVehicle(DSWPlayer* pp)
double floordist = abs(zz - pp->sop->floor_loz); double floordist = abs(zz - pp->sop->floor_loz);
setForcedSyncInput(pp->pnum); setForcedSyncInput(pp->pnum);
DoPlayerVehicleInputScaling(pp, &FRotator::Yaw, 0.125f); DoPlayerVehicleInputScaling(pp, &DRotator::Yaw, 0.125f);
DoPlayerVehicleInputScaling(pp, &FRotator::Pitch, 0.125f); DoPlayerVehicleInputScaling(pp, &DRotator::Pitch, 0.125f);
if (RectClip) if (RectClip)
{ {
@ -2466,9 +2466,9 @@ void DoPlayerMoveVehicle(DSWPlayer* pp)
auto save_cstat = plActor->spr.cstat; auto save_cstat = plActor->spr.cstat;
plActor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK); plActor->spr.cstat &= ~(CSTAT_SPRITE_BLOCK);
if (pp->cmd.ucmd.ang.Yaw != nullFAngle) if (pp->cmd.ucmd.ang.Yaw != nullAngle)
{ {
auto sum = plActor->spr.Angles.Yaw + DAngle::fromDeg(pp->cmd.ucmd.ang.Yaw.Degrees()); auto sum = plActor->spr.Angles.Yaw + pp->cmd.ucmd.ang.Yaw;
if (RectClipTurn(pp, sum, pos, opos)) if (RectClipTurn(pp, sum, pos, opos))
{ {
plActor->spr.Angles.Yaw = sum; plActor->spr.Angles.Yaw = sum;
@ -2518,9 +2518,9 @@ void DoPlayerMoveVehicle(DSWPlayer* pp)
} }
else else
{ {
if (pp->cmd.ucmd.ang.Yaw != nullFAngle) if (pp->cmd.ucmd.ang.Yaw != nullAngle)
{ {
auto sum = plActor->spr.Angles.Yaw + DAngle::fromDeg(pp->cmd.ucmd.ang.Yaw.Degrees()); auto sum = plActor->spr.Angles.Yaw + pp->cmd.ucmd.ang.Yaw;
if (MultiClipTurn(pp, sum, zz, floordist)) if (MultiClipTurn(pp, sum, zz, floordist))
{ {
plActor->spr.Angles.Yaw = sum; plActor->spr.Angles.Yaw = sum;
@ -2590,12 +2590,12 @@ void DoPlayerMoveTurret(DSWPlayer* pp)
setForcedSyncInput(pp->pnum); setForcedSyncInput(pp->pnum);
DoPlayerVehicleInputScaling(pp, &FRotator::Yaw, 0.125f); DoPlayerVehicleInputScaling(pp, &DRotator::Yaw, 0.125f);
DoPlayerVehicleInputScaling(pp, &FRotator::Pitch, 0.125f); DoPlayerVehicleInputScaling(pp, &DRotator::Pitch, 0.125f);
if (fabs(pp->cmd.ucmd.ang.Yaw) >= FAngle::fromDeg(FLT_EPSILON)) if (pp->cmd.ucmd.ang.Yaw != nullAngle)
{ {
DAngle new_ang = pact->spr.Angles.Yaw + DAngle::fromDeg(pp->cmd.ucmd.ang.Yaw.Degrees()); DAngle new_ang = pact->spr.Angles.Yaw + pp->cmd.ucmd.ang.Yaw;
if (pp->sop->limit_ang_center >= nullAngle) if (pp->sop->limit_ang_center >= nullAngle)
{ {
@ -5769,7 +5769,7 @@ void DoPlayerDeathFollowKiller(DSWPlayer* pp)
// allow turning // allow turning
if (pp->Flags & (PF_DEAD_HEAD|PF_HEAD_CONTROL)) if (pp->Flags & (PF_DEAD_HEAD|PF_HEAD_CONTROL))
{ {
pp->GetActor()->spr.Angles.Yaw += DAngle::fromDeg(pp->cmd.ucmd.ang.Yaw.Degrees()); pp->GetActor()->spr.Angles.Yaw += pp->cmd.ucmd.ang.Yaw;
UpdatePlayerSpriteAngle(pp); UpdatePlayerSpriteAngle(pp);
} }
@ -6550,7 +6550,7 @@ void ChopsCheck(DSWPlayer* pp)
{ {
if (!M_Active() && !(pp->Flags & PF_DEAD) && !pp->sop_riding && numplayers <= 1) if (!M_Active() && !(pp->Flags & PF_DEAD) && !pp->sop_riding && numplayers <= 1)
{ {
if (pp->cmd.ucmd.actions & ~SB_RUN || !pp->cmd.ucmd.vel.XY().isZero() || pp->cmd.ucmd.ang.Yaw.Degrees() || pp->cmd.ucmd.ang.Pitch.Degrees() || if (pp->cmd.ucmd.actions & ~SB_RUN || !pp->cmd.ucmd.vel.XY().isZero() || !pp->cmd.ucmd.ang.isZero() ||
(pp->Flags & (PF_CLIMBING | PF_FALLING | PF_DIVING))) (pp->Flags & (PF_CLIMBING | PF_FALLING | PF_DIVING)))
{ {
// Hit a input key or other reason to stop chops // Hit a input key or other reason to stop chops