zdoom/raze
0
0
Fork 0
mirror of https://github.com/ZDoom/Raze.git synced 2025-03-13 04:24:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Move all mouse handling into GameInput class.

Browse source
This commit is contained in:
Mitchell Richters 2023-04-03 18:40:34 +10:00
parent 8d11fef916
commit dbba0abb2e
9 changed files with 78 additions and 75 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
source/core/gamecontrol.cpp
View file

@ -219,7 +219,7 @@ bool System_DispatchEvent(event_t* ev)
{
if (ev->type == EV_Mouse && !System_WantGuiCapture())
{
inputState.MouseAddToPos(ev->x, ev->y);
gameInput.MouseAddToPos(ev->x, ev->y);
return true;
}
@ -1415,9 +1415,9 @@ void GameInterface::FreeLevelData()
//
//---------------------------------------------------------------------------
void GameInterface::GetInput(HIDInput* const hidInput, InputPacket* const currInput, const double scaleAdjust)
void GameInterface::GetInput(InputPacket* const currInput, const double scaleAdjust)
{
gameInput.processMovement(hidInput, currInput, scaleAdjust);
gameInput.processMovement(currInput, scaleAdjust);
}
//---------------------------------------------------------------------------

93
source/core/gameinput.cpp
View file

@ -106,7 +106,7 @@ void processCrouchToggle(bool& toggle, ESyncBits& actions, const bool crouchable
//
//---------------------------------------------------------------------------
void GameInput::processMovement(HIDInput* const hidInput, InputPacket* const currInput, const double scaleAdjust, const int drink_amt, const bool allowstrafe, const double turnscale)
void GameInput::processMovement(InputPacket* const currInput, const double scaleAdjust, const int drink_amt, const bool allowstrafe, const double turnscale)
{
// set up variables.
const int keymove = 1 << int(!!(inputBuffer.actions & SB_RUN));
@ -115,27 +115,27 @@ void GameInput::processMovement(HIDInput* const hidInput, InputPacket* const cur
// determine player input.
const auto turning = buttonMap.ButtonDown(gamefunc_Turn_Right) - buttonMap.ButtonDown(gamefunc_Turn_Left);
const auto moving = buttonMap.ButtonDown(gamefunc_Move_Forward) - buttonMap.ButtonDown(gamefunc_Move_Backward) + hidInput->joyaxes[JOYAXIS_Forward] * scaleAdjustf;
const auto strafing = buttonMap.ButtonDown(gamefunc_Strafe_Right) - buttonMap.ButtonDown(gamefunc_Strafe_Left) - hidInput->joyaxes[JOYAXIS_Side] * scaleAdjustf;
const auto moving = buttonMap.ButtonDown(gamefunc_Move_Forward) - buttonMap.ButtonDown(gamefunc_Move_Backward) + joyAxes[JOYAXIS_Forward] * scaleAdjustf;
const auto strafing = buttonMap.ButtonDown(gamefunc_Strafe_Right) - buttonMap.ButtonDown(gamefunc_Strafe_Left) - joyAxes[JOYAXIS_Side] * scaleAdjustf;
// process player angle input.
if (!(buttonMap.ButtonDown(gamefunc_Strafe) && allowstrafe))
{
const float turndir = clamp(turning + strafing * !allowstrafe, -1.f, 1.f);
const float turnspeed = float(getTicrateScale(YAW_TURNSPEEDS[keymove]) * turnscale * (isTurboTurnTime() ? 1. : YAW_PREAMBLESCALE));
currInput->avel += hidInput->mouse.X * m_yaw - (hidInput->joyaxes[JOYAXIS_Yaw] * hidspeed - turndir * turnspeed) * scaleAdjustf;
currInput->avel += mouseInput.X * m_yaw - (joyAxes[JOYAXIS_Yaw] * hidspeed - turndir * turnspeed) * scaleAdjustf;
if (turndir) updateTurnHeldAmt(scaleAdjust); else turnheldtime = 0;
}
else
{
currInput->svel += hidInput->mouse.X * m_side - (hidInput->joyaxes[JOYAXIS_Yaw] - turning) * keymove * scaleAdjustf;
currInput->svel += mouseInput.X * m_side - (joyAxes[JOYAXIS_Yaw] - turning) * keymove * scaleAdjustf;
}
// process player pitch input.
if (!(inputBuffer.actions & SB_AIMMODE))
currInput->horz -= hidInput->mouse.Y * m_pitch + hidInput->joyaxes[JOYAXIS_Pitch] * hidspeed * scaleAdjustf;
currInput->horz -= mouseInput.Y * m_pitch + joyAxes[JOYAXIS_Pitch] * hidspeed * scaleAdjustf;
else
currInput->fvel += hidInput->mouse.Y * m_forward + hidInput->joyaxes[JOYAXIS_Pitch] * keymove * scaleAdjustf;
currInput->fvel += mouseInput.Y * m_forward + joyAxes[JOYAXIS_Pitch] * keymove * scaleAdjustf;
// process movement input.
currInput->fvel += moving * keymove;
@ -159,7 +159,7 @@ void GameInput::processMovement(HIDInput* const hidInput, InputPacket* const cur
//
//---------------------------------------------------------------------------
void GameInput::processVehicle(HIDInput* const hidInput, InputPacket* const currInput, const double scaleAdjust, const float baseVel, const float velScale, const bool canMove, const bool canTurn, const bool attenuate)
void GameInput::processVehicle(InputPacket* const currInput, const double scaleAdjust, const float baseVel, const float velScale, const bool canMove, const bool canTurn, const bool attenuate)
{
// mask out all actions not compatible with vehicles.
inputBuffer.actions &= ~(SB_WEAPONMASK_BITS | SB_TURNAROUND | SB_CENTERVIEW | SB_HOLSTER | SB_JUMP | SB_CROUCH | SB_RUN |
@ -169,24 +169,24 @@ void GameInput::processVehicle(HIDInput* const hidInput, InputPacket* const curr
{
const auto kbdForwards = buttonMap.ButtonDown(gamefunc_Move_Forward) || buttonMap.ButtonDown(gamefunc_Strafe);
const auto kbdBackward = buttonMap.ButtonDown(gamefunc_Move_Backward);
currInput->fvel = kbdForwards - kbdBackward + hidInput->joyaxes[JOYAXIS_Forward];
currInput->fvel = kbdForwards - kbdBackward + joyAxes[JOYAXIS_Forward];
if (buttonMap.ButtonDown(gamefunc_Run)) inputBuffer.actions |= SB_CROUCH;
}
if (canTurn)
{
// Cancel out micro-movement
hidInput->mouse.X *= fabs(hidInput->mouse.X) >= (m_sensitivity_x * MOUSESCALE * 2.f);
mouseInput.X *= fabs(mouseInput.X) >= (m_sensitivity_x * MOUSESCALE * 2.f);
const auto kbdLeft = buttonMap.ButtonDown(gamefunc_Turn_Left) || buttonMap.ButtonDown(gamefunc_Strafe_Left);
const auto kbdRight = buttonMap.ButtonDown(gamefunc_Turn_Right) || buttonMap.ButtonDown(gamefunc_Strafe_Right);
const auto hidLeft = hidInput->mouse.X < 0 || hidInput->joyaxes[JOYAXIS_Yaw] > 0;
const auto hidRight = hidInput->mouse.X > 0 || hidInput->joyaxes[JOYAXIS_Yaw] < 0;
const auto hidLeft = mouseInput.X < 0 || joyAxes[JOYAXIS_Yaw] > 0;
const auto hidRight = mouseInput.X > 0 || joyAxes[JOYAXIS_Yaw] < 0;
const auto kbdDir = kbdRight - kbdLeft;
const auto turnVel = (!attenuate && (isTurboTurnTime() || hidLeft || hidRight)) ? (baseVel) : (baseVel * velScale);
currInput->avel += turnVel * -hidInput->joyaxes[JOYAXIS_Yaw] + turnVel * kbdDir;
currInput->avel += sqrtf(abs(turnVel * hidInput->mouse.X * m_yaw / (float)scaleAdjust) * (7.f / 20.f)) * Sgn(turnVel) * Sgn(hidInput->mouse.X);
currInput->avel += turnVel * -joyAxes[JOYAXIS_Yaw] + turnVel * kbdDir;
currInput->avel += sqrtf(abs(turnVel * mouseInput.X * m_yaw / (float)scaleAdjust) * (7.f / 20.f)) * Sgn(turnVel) * Sgn(mouseInput.X);
currInput->avel *= (float)scaleAdjust;
if (kbdDir) updateTurnHeldAmt(scaleAdjust); else turnheldtime = 0;
}
@ -200,43 +200,52 @@ void GameInput::processVehicle(HIDInput* const hidInput, InputPacket* const curr
}
//---------------------------------------------------------------------------
//
// Prepares received backend input for use throughout class.
//
//---------------------------------------------------------------------------
void GameInput::prepareHidInput()
{
I_GetAxes(joyAxes);
mouseInput *= MOUSESCALE;
if (invertmousex) mouseInput.X = -mouseInput.X;
if (invertmouse) mouseInput.Y = -mouseInput.Y;
}
void GameInput::resetHidInput()
{
memset(joyAxes, 0, sizeof(joyAxes));
mouseInput.Zero();
}
//---------------------------------------------------------------------------
//
// Processes all the input bits.
//
//---------------------------------------------------------------------------
void GameInput::ApplyGlobalInput(HIDInput* const hidInput)
void GameInput::processInputBits()
{
inputState.GetMouseDelta(hidInput->mouse);
if (use_joystick) I_GetAxes(hidInput->joyaxes);
hidInput->mouse *= MOUSESCALE;
if (invertmousex)
hidInput->mouse.X = -hidInput->mouse.X;
if (invertmouse)
hidInput->mouse.Y = -hidInput->mouse.Y;
if (WeaponToSend != 0) inputBuffer.setNewWeapon(WeaponToSend);
WeaponToSend = 0;
if (hidInput && buttonMap.ButtonDown(gamefunc_Dpad_Select))
if (buttonMap.ButtonDown(gamefunc_Dpad_Select))
{
// These buttons should not autorepeat. The game handlers are not really equipped for that.
if (hidInput->joyaxes[JOYAXIS_Forward] > 0 && !(dpad_lock & 1)) { dpad_lock |= 1; inputBuffer.setNewWeapon(WeaponSel_Prev); }
if (joyAxes[JOYAXIS_Forward] > 0 && !(dpad_lock & 1)) { dpad_lock |= 1; inputBuffer.setNewWeapon(WeaponSel_Prev); }
else dpad_lock &= ~1;
if (hidInput->joyaxes[JOYAXIS_Forward] < 0 && !(dpad_lock & 2)) { dpad_lock |= 2; inputBuffer.setNewWeapon(WeaponSel_Next); }
if (joyAxes[JOYAXIS_Forward] < 0 && !(dpad_lock & 2)) { dpad_lock |= 2; inputBuffer.setNewWeapon(WeaponSel_Next); }
else dpad_lock &= ~2;
if ((hidInput->joyaxes[JOYAXIS_Side] < 0 || hidInput->joyaxes[JOYAXIS_Yaw] > 0) && !(dpad_lock & 4)) { dpad_lock |= 4; inputBuffer.actions |= SB_INVPREV; }
if ((joyAxes[JOYAXIS_Side] < 0 || joyAxes[JOYAXIS_Yaw] > 0) && !(dpad_lock & 4)) { dpad_lock |= 4; inputBuffer.actions |= SB_INVPREV; }
else dpad_lock &= ~4;
if ((hidInput->joyaxes[JOYAXIS_Side] > 0 || hidInput->joyaxes[JOYAXIS_Yaw] < 0) && !(dpad_lock & 8)) { dpad_lock |= 8; inputBuffer.actions |= SB_INVNEXT; }
if ((joyAxes[JOYAXIS_Side] > 0 || joyAxes[JOYAXIS_Yaw] < 0) && !(dpad_lock & 8)) { dpad_lock |= 8; inputBuffer.actions |= SB_INVNEXT; }
else dpad_lock &= ~8;
// This eats the controller input for regular use
hidInput->joyaxes[JOYAXIS_Side] = 0;
hidInput->joyaxes[JOYAXIS_Forward] = 0;
hidInput->joyaxes[JOYAXIS_Yaw] = 0;
joyAxes[JOYAXIS_Side] = 0;
joyAxes[JOYAXIS_Forward] = 0;
joyAxes[JOYAXIS_Yaw] = 0;
}
else dpad_lock = 0;
@ -245,20 +254,20 @@ void GameInput::ApplyGlobalInput(HIDInput* const hidInput)
inputBuffer.actions |= ActionsToSend;
ActionsToSend = 0;
if (buttonMap.ButtonDown(gamefunc_Aim_Up) || (buttonMap.ButtonDown(gamefunc_Dpad_Aiming) && hidInput->joyaxes[JOYAXIS_Forward] > 0))
if (buttonMap.ButtonDown(gamefunc_Aim_Up) || (buttonMap.ButtonDown(gamefunc_Dpad_Aiming) && joyAxes[JOYAXIS_Forward] > 0))
{
inputBuffer.actions |= SB_AIM_UP;
inputBuffer.actions &= ~SB_CENTERVIEW;
}
if ((buttonMap.ButtonDown(gamefunc_Aim_Down) || (buttonMap.ButtonDown(gamefunc_Dpad_Aiming) && hidInput->joyaxes[JOYAXIS_Forward] < 0)))
if ((buttonMap.ButtonDown(gamefunc_Aim_Down) || (buttonMap.ButtonDown(gamefunc_Dpad_Aiming) && joyAxes[JOYAXIS_Forward] < 0)))
{
inputBuffer.actions |= SB_AIM_DOWN;
inputBuffer.actions &= ~SB_CENTERVIEW;
}
if (buttonMap.ButtonDown(gamefunc_Dpad_Aiming))
hidInput->joyaxes[JOYAXIS_Forward] = 0;
joyAxes[JOYAXIS_Forward] = 0;
if (buttonMap.ButtonDown(gamefunc_Jump))
inputBuffer.actions |= SB_JUMP;
@ -321,19 +330,19 @@ void GameInput::getInput(const double scaleAdjust, PlayerAngles* const plrAngles
}
InputPacket input{};
HIDInput hidInput{};
ApplyGlobalInput(&hidInput);
prepareHidInput();
processInputBits();
// Directly update the camera angles if we're unsynchronised.
if (!SyncInput())
{
gi->GetInput(&hidInput, &input, scaleAdjust);
gi->GetInput(&input, scaleAdjust);
plrAngles->CameraAngles.Yaw += DAngle::fromDeg(input.avel);
plrAngles->CameraAngles.Pitch += DAngle::fromDeg(input.horz);
}
else
{
gi->GetInput(&hidInput, &input, 1);
gi->GetInput(&input, 1);
}
if (packet)
@ -341,6 +350,8 @@ void GameInput::getInput(const double scaleAdjust, PlayerAngles* const plrAngles
*packet = inputBuffer;
inputBuffer = {};
}
resetHidInput();
}

25
source/core/gameinput.h
View file

@ -8,12 +8,6 @@ inline double getTicrateScale(const double value)
return value / GameTicRate;
}
struct HIDInput
{
float joyaxes[NUM_JOYAXIS];
FVector2 mouse;
};
class GameInput
{
enum
@ -26,6 +20,10 @@ class GameInput
static constexpr double YAW_TURNSPEEDS[3] = { 41.1987304, 156.555175, 272.24121 };
static constexpr double YAW_PREAMBLESCALE = YAW_TURNSPEEDS[0] / YAW_TURNSPEEDS[1];
// Input received from the OS.
float joyAxes[NUM_JOYAXIS];
FVector2 mouseInput;
// Internal variables when generating a packet.
InputPacket inputBuffer;
double turnheldtime;
@ -44,7 +42,9 @@ class GameInput
}
// Prototypes for private member functions.
void ApplyGlobalInput(HIDInput* const hidInput);
void processInputBits();
void prepareHidInput();
void resetHidInput();
public:
// Bit sender updates.
@ -67,9 +67,16 @@ public:
turnheldtime = 0;
}
// Receives mouse input from OS for processing.
void MouseAddToPos(float x, float y)
{
mouseInput.X += x;
mouseInput.Y += y;
}
// Prototypes for large member functions.
void processMovement(HIDInput* const hidInput, InputPacket* const currInput, const double scaleAdjust, const int drink_amt = 0, const bool allowstrafe = true, const double turnscale = 1.);
void processVehicle(HIDInput* const hidInput, InputPacket* const currInput, const double scaleAdjust, const float baseVel, const float velScale, const bool canMove, const bool canTurn, const bool attenuate);
void processMovement(InputPacket* const currInput, const double scaleAdjust, const int drink_amt = 0, const bool allowstrafe = true, const double turnscale = 1.);
void processVehicle(InputPacket* const currInput, const double scaleAdjust, const float baseVel, const float velScale, const bool canMove, const bool canTurn, const bool attenuate);
void getInput(const double scaleAdjust, PlayerAngles* const plrAngles, InputPacket* packet = nullptr);
};

3
source/core/gamestruct.h
View file

@ -18,7 +18,6 @@ struct tspritetype;
class DCoreActor;
struct MapRecord;
struct PlayerAngles;
struct HIDInput;
struct GameStats
{
@ -120,7 +119,7 @@ struct GameInterface
virtual bool WantEscape() { return false; }
virtual void StartSoundEngine() = 0;
virtual void reapplyInputBits(InputPacket* const input) = 0;
virtual void GetInput(HIDInput* const hidInput, InputPacket* const currInput, const double scaleAdjust);
virtual void GetInput(InputPacket* const currInput, const double scaleAdjust);
virtual FString statFPS()
{

13
source/core/inputstate.h
View file

@ -17,7 +17,6 @@ class InputState
{
uint8_t KeyStatus[NUM_KEYS];
bool AnyKeyStatus;
FVector2 g_mousePos;
public:
@ -43,18 +42,6 @@ public:
AnyKeyStatus = true;
}
void MouseAddToPos(float x, float y)
{
g_mousePos.X += x;
g_mousePos.Y += y;
}
void GetMouseDelta(FVector2& gameinput)
{
gameinput = g_mousePos;
g_mousePos.Zero();
}
void ClearAllInput()
{
memset(KeyStatus, 0, sizeof(KeyStatus));

2
source/games/duke/src/duke3d.h
View file

@ -40,7 +40,7 @@ struct GameInterface : public ::GameInterface
void ExitFromMenu() override;
void DrawPlayerSprite(const DVector2& origin, bool onteam) override;
void reapplyInputBits(InputPacket* const input) override { input->actions |= ps[myconnectindex].sync.actions & SB_CENTERVIEW; }
void GetInput(HIDInput* const hidInput, InputPacket* const currInput, const double scaleAdjust) override;
void GetInput(InputPacket* const currInput, const double scaleAdjust) override;
void UpdateSounds() override;
void Startup() override;
void DrawBackground() override;

6
source/games/duke/src/input.cpp
View file

@ -501,7 +501,7 @@ void hud_input(int plnum)
//
//---------------------------------------------------------------------------
void GameInterface::GetInput(HIDInput* const hidInput, InputPacket* const currInput, const double scaleAdjust)
void GameInterface::GetInput(InputPacket* const currInput, const double scaleAdjust)
{
auto const p = &ps[myconnectindex];
@ -525,11 +525,11 @@ void GameInterface::GetInput(HIDInput* const hidInput, InputPacket* const currIn
const auto canTurn = p->OnMotorcycle || p->MotoSpeed || p->moto_drink;
const auto attenuate = p->OnMotorcycle && p->MotoSpeed <= 0;
gameInput.processVehicle(hidInput, currInput, scaleAdjust, baseVel, velScale, canMove, canTurn, attenuate);
gameInput.processVehicle(currInput, scaleAdjust, baseVel, velScale, canMove, canTurn, attenuate);
}
else
{
gameInput.processMovement(hidInput, currInput, scaleAdjust, p->drink_amt);
gameInput.processMovement(currInput, scaleAdjust, p->drink_amt);
}
}

4
source/games/sw/src/game.h
View file

@ -1889,9 +1889,9 @@ struct GameInterface : public ::GameInterface
int GetCurrentSkill() override;
void StartSoundEngine() override;
void reapplyInputBits(InputPacket* const input) override { input->actions |= Player[myconnectindex].input.actions & SB_CENTERVIEW; }
void GetInput(HIDInput* const hidInput, InputPacket* const currInput, const double scaleAdjust) override
void GetInput(InputPacket* const currInput, const double scaleAdjust) override
{
gameInput.processMovement(hidInput, currInput, scaleAdjust, 0, !Player[myconnectindex].sop, Player[myconnectindex].sop_control ? 3. / 1.40625 : 1.);
gameInput.processMovement(currInput, scaleAdjust, 0, !Player[myconnectindex].sop, Player[myconnectindex].sop_control ? 3. / 1.40625 : 1.);
}

1
source/games/sw/src/player.h
View file

@ -125,7 +125,6 @@ void DoPlayer(void);
void domovethings(void);
void InitAllPlayers(void);
void InitMultiPlayerInfo(const DVector3& spawnpos, const DAngle startang);
void MoveScrollMode2D(PLAYER* pp, HIDInput* const hidInput);
void DoPlayerDivePalette(PLAYER* pp);
void DoPlayerNightVisionPalette(PLAYER* pp);
void DoPlayerStopDiveNoWarp(PLAYER* pp);