oss/luanti
oss/luanti
1
0
Fork 0
mirror of https://github.com/luanti-org/luanti.git synced 2025-07-02 16:38:41 +00:00
Code Wiki Activity

Refactor input handler (#15933)

Browse source
This commit is contained in:
y5nw 2025-03-30 18:16:20 +02:00 • committed by GitHub
parent 309c0a0cb6
commit 4cd2273349
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 168 additions and 254 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/client/game.cpp
View file

@ -885,7 +885,7 @@ bool Game::startup(bool *kill,
this->chat_backend = chat_backend; this->chat_backend = chat_backend;
simple_singleplayer_mode = start_data.isSinglePlayer(); simple_singleplayer_mode = start_data.isSinglePlayer();
input->keycache.populate(); input->reloadKeybindings();
driver = device->getVideoDriver(); driver = device->getVideoDriver();
smgr = m_rendering_engine->get_scene_manager(); smgr = m_rendering_engine->get_scene_manager();

2
src/client/game_formspec.cpp
View file

@ -554,7 +554,7 @@ bool GameFormSpec::handleCallbacks()
} }
if (g_gamecallback->keyconfig_changed) { if (g_gamecallback->keyconfig_changed) {
m_input->keycache.populate(); // update the cache with new settings m_input->reloadKeybindings(); // update the cache with new settings
g_gamecallback->keyconfig_changed = false; g_gamecallback->keyconfig_changed = false;
} }

191
src/client/inputhandler.cpp
View file

@ -12,75 +12,98 @@
#include "log_internal.h" #include "log_internal.h"
#include "client/renderingengine.h" #include "client/renderingengine.h"
void KeyCache::populate_nonchanging() void MyEventReceiver::reloadKeybindings()
{ {
key[KeyType::ESC] = EscapeKey; keybindings[KeyType::FORWARD] = getKeySetting("keymap_forward");
} keybindings[KeyType::BACKWARD] = getKeySetting("keymap_backward");
keybindings[KeyType::LEFT] = getKeySetting("keymap_left");
keybindings[KeyType::RIGHT] = getKeySetting("keymap_right");
keybindings[KeyType::JUMP] = getKeySetting("keymap_jump");
keybindings[KeyType::AUX1] = getKeySetting("keymap_aux1");
keybindings[KeyType::SNEAK] = getKeySetting("keymap_sneak");
keybindings[KeyType::DIG] = getKeySetting("keymap_dig");
keybindings[KeyType::PLACE] = getKeySetting("keymap_place");
void KeyCache::populate() keybindings[KeyType::ESC] = EscapeKey;
{
key[KeyType::FORWARD] = getKeySetting("keymap_forward");
key[KeyType::BACKWARD] = getKeySetting("keymap_backward");
key[KeyType::LEFT] = getKeySetting("keymap_left");
key[KeyType::RIGHT] = getKeySetting("keymap_right");
key[KeyType::JUMP] = getKeySetting("keymap_jump");
key[KeyType::AUX1] = getKeySetting("keymap_aux1");
key[KeyType::SNEAK] = getKeySetting("keymap_sneak");
key[KeyType::DIG] = getKeySetting("keymap_dig");
key[KeyType::PLACE] = getKeySetting("keymap_place");
key[KeyType::AUTOFORWARD] = getKeySetting("keymap_autoforward"); keybindings[KeyType::AUTOFORWARD] = getKeySetting("keymap_autoforward");
key[KeyType::DROP] = getKeySetting("keymap_drop"); keybindings[KeyType::DROP] = getKeySetting("keymap_drop");
key[KeyType::INVENTORY] = getKeySetting("keymap_inventory"); keybindings[KeyType::INVENTORY] = getKeySetting("keymap_inventory");
key[KeyType::CHAT] = getKeySetting("keymap_chat"); keybindings[KeyType::CHAT] = getKeySetting("keymap_chat");
key[KeyType::CMD] = getKeySetting("keymap_cmd"); keybindings[KeyType::CMD] = getKeySetting("keymap_cmd");
key[KeyType::CMD_LOCAL] = getKeySetting("keymap_cmd_local"); keybindings[KeyType::CMD_LOCAL] = getKeySetting("keymap_cmd_local");
key[KeyType::CONSOLE] = getKeySetting("keymap_console"); keybindings[KeyType::CONSOLE] = getKeySetting("keymap_console");
key[KeyType::MINIMAP] = getKeySetting("keymap_minimap"); keybindings[KeyType::MINIMAP] = getKeySetting("keymap_minimap");
key[KeyType::FREEMOVE] = getKeySetting("keymap_freemove"); keybindings[KeyType::FREEMOVE] = getKeySetting("keymap_freemove");
key[KeyType::PITCHMOVE] = getKeySetting("keymap_pitchmove"); keybindings[KeyType::PITCHMOVE] = getKeySetting("keymap_pitchmove");
key[KeyType::FASTMOVE] = getKeySetting("keymap_fastmove"); keybindings[KeyType::FASTMOVE] = getKeySetting("keymap_fastmove");
key[KeyType::NOCLIP] = getKeySetting("keymap_noclip"); keybindings[KeyType::NOCLIP] = getKeySetting("keymap_noclip");
key[KeyType::HOTBAR_PREV] = getKeySetting("keymap_hotbar_previous"); keybindings[KeyType::HOTBAR_PREV] = getKeySetting("keymap_hotbar_previous");
key[KeyType::HOTBAR_NEXT] = getKeySetting("keymap_hotbar_next"); keybindings[KeyType::HOTBAR_NEXT] = getKeySetting("keymap_hotbar_next");
key[KeyType::MUTE] = getKeySetting("keymap_mute"); keybindings[KeyType::MUTE] = getKeySetting("keymap_mute");
key[KeyType::INC_VOLUME] = getKeySetting("keymap_increase_volume"); keybindings[KeyType::INC_VOLUME] = getKeySetting("keymap_increase_volume");
key[KeyType::DEC_VOLUME] = getKeySetting("keymap_decrease_volume"); keybindings[KeyType::DEC_VOLUME] = getKeySetting("keymap_decrease_volume");
key[KeyType::CINEMATIC] = getKeySetting("keymap_cinematic"); keybindings[KeyType::CINEMATIC] = getKeySetting("keymap_cinematic");
key[KeyType::SCREENSHOT] = getKeySetting("keymap_screenshot"); keybindings[KeyType::SCREENSHOT] = getKeySetting("keymap_screenshot");
key[KeyType::TOGGLE_BLOCK_BOUNDS] = getKeySetting("keymap_toggle_block_bounds"); keybindings[KeyType::TOGGLE_BLOCK_BOUNDS] = getKeySetting("keymap_toggle_block_bounds");
key[KeyType::TOGGLE_HUD] = getKeySetting("keymap_toggle_hud"); keybindings[KeyType::TOGGLE_HUD] = getKeySetting("keymap_toggle_hud");
key[KeyType::TOGGLE_CHAT] = getKeySetting("keymap_toggle_chat"); keybindings[KeyType::TOGGLE_CHAT] = getKeySetting("keymap_toggle_chat");
key[KeyType::TOGGLE_FOG] = getKeySetting("keymap_toggle_fog"); keybindings[KeyType::TOGGLE_FOG] = getKeySetting("keymap_toggle_fog");
key[KeyType::TOGGLE_UPDATE_CAMERA] = getKeySetting("keymap_toggle_update_camera"); keybindings[KeyType::TOGGLE_UPDATE_CAMERA] = getKeySetting("keymap_toggle_update_camera");
key[KeyType::TOGGLE_DEBUG] = getKeySetting("keymap_toggle_debug"); keybindings[KeyType::TOGGLE_DEBUG] = getKeySetting("keymap_toggle_debug");
key[KeyType::TOGGLE_PROFILER] = getKeySetting("keymap_toggle_profiler"); keybindings[KeyType::TOGGLE_PROFILER] = getKeySetting("keymap_toggle_profiler");
key[KeyType::CAMERA_MODE] = getKeySetting("keymap_camera_mode"); keybindings[KeyType::CAMERA_MODE] = getKeySetting("keymap_camera_mode");
key[KeyType::INCREASE_VIEWING_RANGE] = keybindings[KeyType::INCREASE_VIEWING_RANGE] =
getKeySetting("keymap_increase_viewing_range_min"); getKeySetting("keymap_increase_viewing_range_min");
key[KeyType::DECREASE_VIEWING_RANGE] = keybindings[KeyType::DECREASE_VIEWING_RANGE] =
getKeySetting("keymap_decrease_viewing_range_min"); getKeySetting("keymap_decrease_viewing_range_min");
key[KeyType::RANGESELECT] = getKeySetting("keymap_rangeselect"); keybindings[KeyType::RANGESELECT] = getKeySetting("keymap_rangeselect");
key[KeyType::ZOOM] = getKeySetting("keymap_zoom"); keybindings[KeyType::ZOOM] = getKeySetting("keymap_zoom");
key[KeyType::QUICKTUNE_NEXT] = getKeySetting("keymap_quicktune_next"); keybindings[KeyType::QUICKTUNE_NEXT] = getKeySetting("keymap_quicktune_next");
key[KeyType::QUICKTUNE_PREV] = getKeySetting("keymap_quicktune_prev"); keybindings[KeyType::QUICKTUNE_PREV] = getKeySetting("keymap_quicktune_prev");
key[KeyType::QUICKTUNE_INC] = getKeySetting("keymap_quicktune_inc"); keybindings[KeyType::QUICKTUNE_INC] = getKeySetting("keymap_quicktune_inc");
key[KeyType::QUICKTUNE_DEC] = getKeySetting("keymap_quicktune_dec"); keybindings[KeyType::QUICKTUNE_DEC] = getKeySetting("keymap_quicktune_dec");
for (int i = 0; i < HUD_HOTBAR_ITEMCOUNT_MAX; i++) { for (int i = 0; i < HUD_HOTBAR_ITEMCOUNT_MAX; i++) {
std::string slot_key_name = "keymap_slot" + std::to_string(i + 1); std::string slot_key_name = "keymap_slot" + std::to_string(i + 1);
key[KeyType::SLOT_1 + i] = getKeySetting(slot_key_name.c_str()); keybindings[KeyType::SLOT_1 + i] = getKeySetting(slot_key_name.c_str());
} }
if (handler) { // First clear all keys, then re-add the ones we listen for
// First clear all keys, then re-add the ones we listen for keysListenedFor.clear();
handler->dontListenForKeys(); for (int i = 0; i < KeyType::INTERNAL_ENUM_COUNT; i++) {
for (auto k : key) { listenForKey(keybindings[i], static_cast<GameKeyType>(i));
handler->listenForKey(k); }
} }
handler->listenForKey(EscapeKey);
bool MyEventReceiver::setKeyDown(KeyPress keyCode, bool is_down)
{
if (keysListenedFor.find(keyCode) == keysListenedFor.end()) // ignore irrelevant key input
return false;
auto action = keysListenedFor[keyCode];
if (is_down) {
physicalKeyDown.insert(keyCode);
setKeyDown(action, true);
} else {
physicalKeyDown.erase(keyCode);
setKeyDown(action, false);
}
return true;
}
void MyEventReceiver::setKeyDown(GameKeyType action, bool is_down)
{
if (is_down) {
if (!IsKeyDown(action))
keyWasPressed.set(action);
keyIsDown.set(action);
keyWasDown.set(action);
} else {
if (IsKeyDown(action))
keyWasReleased.set(action);
keyIsDown.reset(action);
} }
} }
@ -143,23 +166,8 @@ bool MyEventReceiver::OnEvent(const SEvent &event)
// Remember whether each key is down or up // Remember whether each key is down or up
if (event.EventType == irr::EET_KEY_INPUT_EVENT) { if (event.EventType == irr::EET_KEY_INPUT_EVENT) {
KeyPress keyCode(event.KeyInput); KeyPress keyCode(event.KeyInput);
if (keyCode && keysListenedFor[keyCode]) { // ignore key input that is invalid or irrelevant for the game. if (setKeyDown(keyCode, event.KeyInput.PressedDown))
if (event.KeyInput.PressedDown) {
if (!IsKeyDown(keyCode))
keyWasPressed.set(keyCode);
keyIsDown.set(keyCode);
keyWasDown.set(keyCode);
} else {
if (IsKeyDown(keyCode))
keyWasReleased.set(keyCode);
keyIsDown.unset(keyCode);
}
return true; return true;
}
} else if (g_touchcontrols && event.EventType == irr::EET_TOUCH_INPUT_EVENT) { } else if (g_touchcontrols && event.EventType == irr::EET_TOUCH_INPUT_EVENT) {
// In case of touchcontrols, we have to handle different events // In case of touchcontrols, we have to handle different events
g_touchcontrols->translateEvent(event); g_touchcontrols->translateEvent(event);
@ -171,31 +179,22 @@ bool MyEventReceiver::OnEvent(const SEvent &event)
// Handle mouse events // Handle mouse events
switch (event.MouseInput.Event) { switch (event.MouseInput.Event) {
case EMIE_LMOUSE_PRESSED_DOWN: case EMIE_LMOUSE_PRESSED_DOWN:
keyIsDown.set(LMBKey); setKeyDown(LMBKey, true);
keyWasDown.set(LMBKey);
keyWasPressed.set(LMBKey);
break; break;
case EMIE_MMOUSE_PRESSED_DOWN: case EMIE_MMOUSE_PRESSED_DOWN:
keyIsDown.set(MMBKey); setKeyDown(MMBKey, true);
keyWasDown.set(MMBKey);
keyWasPressed.set(MMBKey);
break; break;
case EMIE_RMOUSE_PRESSED_DOWN: case EMIE_RMOUSE_PRESSED_DOWN:
keyIsDown.set(RMBKey); setKeyDown(RMBKey, true);
keyWasDown.set(RMBKey);
keyWasPressed.set(RMBKey);
break; break;
case EMIE_LMOUSE_LEFT_UP: case EMIE_LMOUSE_LEFT_UP:
keyIsDown.unset(LMBKey); setKeyDown(LMBKey, false);
keyWasReleased.set(LMBKey);
break; break;
case EMIE_MMOUSE_LEFT_UP: case EMIE_MMOUSE_LEFT_UP:
keyIsDown.unset(MMBKey); setKeyDown(MMBKey, false);
keyWasReleased.set(MMBKey);
break; break;
case EMIE_RMOUSE_LEFT_UP: case EMIE_RMOUSE_LEFT_UP:
keyIsDown.unset(RMBKey); setKeyDown(RMBKey, false);
keyWasReleased.set(RMBKey);
break; break;
case EMIE_MOUSE_WHEEL: case EMIE_MOUSE_WHEEL:
mouse_wheel += event.MouseInput.Wheel; mouse_wheel += event.MouseInput.Wheel;
@ -257,7 +256,7 @@ s32 RandomInputHandler::Rand(s32 min, s32 max)
} }
struct RandomInputHandlerSimData { struct RandomInputHandlerSimData {
std::string key; GameKeyType key;
float counter; float counter;
int time_max; int time_max;
}; };
@ -265,19 +264,19 @@ struct RandomInputHandlerSimData {
void RandomInputHandler::step(float dtime) void RandomInputHandler::step(float dtime)
{ {
static RandomInputHandlerSimData rnd_data[] = { static RandomInputHandlerSimData rnd_data[] = {
{ "keymap_jump", 0.0f, 40 }, { KeyType::JUMP, 0.0f, 40 },
{ "keymap_aux1", 0.0f, 40 }, { KeyType::AUX1, 0.0f, 40 },
{ "keymap_forward", 0.0f, 40 }, { KeyType::FORWARD, 0.0f, 40 },
{ "keymap_left", 0.0f, 40 }, { KeyType::LEFT, 0.0f, 40 },
{ "keymap_dig", 0.0f, 30 }, { KeyType::DIG, 0.0f, 30 },
{ "keymap_place", 0.0f, 15 } { KeyType::PLACE, 0.0f, 15 }
}; };
for (auto &i : rnd_data) { for (auto &i : rnd_data) {
i.counter -= dtime; i.counter -= dtime;
if (i.counter < 0.0) { if (i.counter < 0.0) {
i.counter = 0.1 * Rand(1, i.time_max); i.counter = 0.1 * Rand(1, i.time_max);
keydown.toggle(getKeySetting(i.key.c_str())); keydown.flip(i.key);
} }
} }
{ {

209
src/client/inputhandler.h
View file

@ -7,7 +7,10 @@
#include "irrlichttypes.h" #include "irrlichttypes.h"
#include "irr_v2d.h" #include "irr_v2d.h"
#include "joystick_controller.h" #include "joystick_controller.h"
#include <array>
#include <list> #include <list>
#include <set>
#include <unordered_map>
#include "keycode.h" #include "keycode.h"
class InputHandler; class InputHandler;
@ -17,142 +20,32 @@ enum class PointerType {
Touch, Touch,
}; };
/****************************************************************************
Fast key cache for main game loop
****************************************************************************/
/* This is faster than using getKeySetting with the tradeoff that functions
* using it must make sure that it's initialised before using it and there is
* no error handling (for example bounds checking). This is really intended for
* use only in the main running loop of the client (the_game()) where the faster
* (up to 10x faster) key lookup is an asset. Other parts of the codebase
* (e.g. formspecs) should continue using getKeySetting().
*/
struct KeyCache
{
KeyCache()
{
handler = NULL;
populate();
populate_nonchanging();
}
void populate();
// Keys that are not settings dependent
void populate_nonchanging();
KeyPress key[KeyType::INTERNAL_ENUM_COUNT];
InputHandler *handler;
};
class KeyList : private std::list<KeyPress>
{
typedef std::list<KeyPress> super;
typedef super::iterator iterator;
typedef super::const_iterator const_iterator;
virtual const_iterator find(KeyPress key) const
{
const_iterator f(begin());
const_iterator e(end());
while (f != e) {
if (*f == key)
return f;
++f;
}
return e;
}
virtual iterator find(KeyPress key)
{
iterator f(begin());
iterator e(end());
while (f != e) {
if (*f == key)
return f;
++f;
}
return e;
}
public:
void clear() { super::clear(); }
void set(KeyPress key)
{
if (find(key) == end())
push_back(key);
}
void unset(KeyPress key)
{
iterator p(find(key));
if (p != end())
erase(p);
}
void toggle(KeyPress key)
{
iterator p(this->find(key));
if (p != end())
erase(p);
else
push_back(key);
}
void append(const KeyList &other)
{
for (auto key : other) {
set(key);
}
}
bool operator[](KeyPress key) const { return find(key) != end(); }
};
class MyEventReceiver : public IEventReceiver class MyEventReceiver : public IEventReceiver
{ {
public: public:
// This is the one method that we have to implement // This is the one method that we have to implement
virtual bool OnEvent(const SEvent &event); virtual bool OnEvent(const SEvent &event);
bool IsKeyDown(KeyPress keyCode) const { return keyIsDown[keyCode]; } bool IsKeyDown(GameKeyType key) const { return keyIsDown[key]; }
// Checks whether a key was down and resets the state // Checks whether a key was down and resets the state
bool WasKeyDown(KeyPress keyCode) bool WasKeyDown(GameKeyType key)
{ {
bool b = keyWasDown[keyCode]; bool b = keyWasDown[key];
if (b) if (b)
keyWasDown.unset(keyCode); keyWasDown.reset(key);
return b; return b;
} }
// Checks whether a key was just pressed. State will be cleared // Checks whether a key was just pressed. State will be cleared
// in the subsequent iteration of Game::processPlayerInteraction // in the subsequent iteration of Game::processPlayerInteraction
bool WasKeyPressed(KeyPress keycode) const { return keyWasPressed[keycode]; } bool WasKeyPressed(GameKeyType key) const { return keyWasPressed[key]; }
// Checks whether a key was just released. State will be cleared // Checks whether a key was just released. State will be cleared
// in the subsequent iteration of Game::processPlayerInteraction // in the subsequent iteration of Game::processPlayerInteraction
bool WasKeyReleased(KeyPress keycode) const { return keyWasReleased[keycode]; } bool WasKeyReleased(GameKeyType key) const { return keyWasReleased[key]; }
void listenForKey(KeyPress keyCode) void reloadKeybindings();
{
keysListenedFor.set(keyCode);
}
void dontListenForKeys()
{
keysListenedFor.clear();
}
s32 getMouseWheel() s32 getMouseWheel()
{ {
@ -163,28 +56,30 @@ public:
void clearInput() void clearInput()
{ {
keyIsDown.clear(); physicalKeyDown.clear();
keyWasDown.clear(); keyIsDown.reset();
keyWasPressed.clear(); keyWasDown.reset();
keyWasReleased.clear(); keyWasPressed.reset();
keyWasReleased.reset();
mouse_wheel = 0; mouse_wheel = 0;
} }
void releaseAllKeys() void releaseAllKeys()
{ {
keyWasReleased.append(keyIsDown); physicalKeyDown.clear();
keyIsDown.clear(); keyWasReleased |= keyIsDown;
keyIsDown.reset();
} }
void clearWasKeyPressed() void clearWasKeyPressed()
{ {
keyWasPressed.clear(); keyWasPressed.reset();
} }
void clearWasKeyReleased() void clearWasKeyReleased()
{ {
keyWasReleased.clear(); keyWasReleased.reset();
} }
JoystickController *joystick = nullptr; JoystickController *joystick = nullptr;
@ -192,26 +87,41 @@ public:
PointerType getLastPointerType() { return last_pointer_type; } PointerType getLastPointerType() { return last_pointer_type; }
private: private:
void listenForKey(KeyPress keyCode, GameKeyType action)
{
if (keyCode)
keysListenedFor[keyCode] = action;
}
bool setKeyDown(KeyPress keyCode, bool is_down);
void setKeyDown(GameKeyType action, bool is_down);
/* This is faster than using getKeySetting with the tradeoff that functions
* using it must make sure that it's initialised before using it and there is
* no error handling (for example bounds checking). This is useful here as the
* faster (up to 10x faster) key lookup is an asset.
*/
std::array<KeyPress, KeyType::INTERNAL_ENUM_COUNT> keybindings;
s32 mouse_wheel = 0; s32 mouse_wheel = 0;
// The current state of physical keys.
std::set<KeyPress> physicalKeyDown;
// The current state of keys // The current state of keys
KeyList keyIsDown; std::bitset<GameKeyType::INTERNAL_ENUM_COUNT> keyIsDown;
// Like keyIsDown but only reset when that key is read // Like keyIsDown but only reset when that key is read
KeyList keyWasDown; std::bitset<GameKeyType::INTERNAL_ENUM_COUNT> keyWasDown;
// Whether a key has just been pressed // Whether a key has just been pressed
KeyList keyWasPressed; std::bitset<GameKeyType::INTERNAL_ENUM_COUNT> keyWasPressed;
// Whether a key has just been released // Whether a key has just been released
KeyList keyWasReleased; std::bitset<GameKeyType::INTERNAL_ENUM_COUNT> keyWasReleased;
// List of keys we listen for // List of keys we listen for
// TODO perhaps the type of this is not really std::unordered_map<KeyPress, GameKeyType> keysListenedFor;
// performant as KeyList is designed for few but
// often changing keys, and keysListenedFor is expected
// to change seldomly but contain lots of keys.
KeyList keysListenedFor;
// Intentionally not reset by clearInput/releaseAllKeys. // Intentionally not reset by clearInput/releaseAllKeys.
bool fullscreen_is_down = false; bool fullscreen_is_down = false;
@ -222,12 +132,6 @@ private:
class InputHandler class InputHandler
{ {
public: public:
InputHandler()
{
keycache.handler = this;
keycache.populate();
}
virtual ~InputHandler() = default; virtual ~InputHandler() = default;
virtual bool isRandom() const virtual bool isRandom() const
@ -247,8 +151,7 @@ public:
virtual void clearWasKeyPressed() {} virtual void clearWasKeyPressed() {}
virtual void clearWasKeyReleased() {} virtual void clearWasKeyReleased() {}
virtual void listenForKey(KeyPress keyCode) {} virtual void reloadKeybindings() {}
virtual void dontListenForKeys() {}
virtual v2s32 getMousePos() = 0; virtual v2s32 getMousePos() = 0;
virtual void setMousePos(s32 x, s32 y) = 0; virtual void setMousePos(s32 x, s32 y) = 0;
@ -261,7 +164,6 @@ public:
virtual void releaseAllKeys() {} virtual void releaseAllKeys() {}
JoystickController joystick; JoystickController joystick;
KeyCache keycache;
}; };
/* /*
@ -274,6 +176,7 @@ public:
RealInputHandler(MyEventReceiver *receiver) : m_receiver(receiver) RealInputHandler(MyEventReceiver *receiver) : m_receiver(receiver)
{ {
m_receiver->joystick = &joystick; m_receiver->joystick = &joystick;
m_receiver->reloadKeybindings();
} }
virtual ~RealInputHandler() virtual ~RealInputHandler()
@ -283,19 +186,19 @@ public:
virtual bool isKeyDown(GameKeyType k) virtual bool isKeyDown(GameKeyType k)
{ {
return m_receiver->IsKeyDown(keycache.key[k]) || joystick.isKeyDown(k); return m_receiver->IsKeyDown(k) || joystick.isKeyDown(k);
} }
virtual bool wasKeyDown(GameKeyType k) virtual bool wasKeyDown(GameKeyType k)
{ {
return m_receiver->WasKeyDown(keycache.key[k]) || joystick.wasKeyDown(k); return m_receiver->WasKeyDown(k) || joystick.wasKeyDown(k);
} }
virtual bool wasKeyPressed(GameKeyType k) virtual bool wasKeyPressed(GameKeyType k)
{ {
return m_receiver->WasKeyPressed(keycache.key[k]) || joystick.wasKeyPressed(k); return m_receiver->WasKeyPressed(k) || joystick.wasKeyPressed(k);
} }
virtual bool wasKeyReleased(GameKeyType k) virtual bool wasKeyReleased(GameKeyType k)
{ {
return m_receiver->WasKeyReleased(keycache.key[k]) || joystick.wasKeyReleased(k); return m_receiver->WasKeyReleased(k) || joystick.wasKeyReleased(k);
} }
virtual float getJoystickSpeed(); virtual float getJoystickSpeed();
@ -316,13 +219,9 @@ public:
m_receiver->clearWasKeyReleased(); m_receiver->clearWasKeyReleased();
} }
virtual void listenForKey(KeyPress keyCode) virtual void reloadKeybindings()
{ {
m_receiver->listenForKey(keyCode); m_receiver->reloadKeybindings();
}
virtual void dontListenForKeys()
{
m_receiver->dontListenForKeys();
} }
virtual v2s32 getMousePos(); virtual v2s32 getMousePos();
@ -360,7 +259,7 @@ public:
return true; return true;
} }
virtual bool isKeyDown(GameKeyType k) { return keydown[keycache.key[k]]; } virtual bool isKeyDown(GameKeyType k) { return keydown[k]; }
virtual bool wasKeyDown(GameKeyType k) { return false; } virtual bool wasKeyDown(GameKeyType k) { return false; }
virtual bool wasKeyPressed(GameKeyType k) { return false; } virtual bool wasKeyPressed(GameKeyType k) { return false; }
virtual bool wasKeyReleased(GameKeyType k) { return false; } virtual bool wasKeyReleased(GameKeyType k) { return false; }
@ -377,7 +276,7 @@ public:
s32 Rand(s32 min, s32 max); s32 Rand(s32 min, s32 max);
private: private:
KeyList keydown; std::bitset<GameKeyType::INTERNAL_ENUM_COUNT> keydown;
v2s32 mousepos; v2s32 mousepos;
v2s32 mousespeed; v2s32 mousespeed;
float joystickSpeed; float joystickSpeed;

18
src/client/keycode.h
View file

@ -49,6 +49,11 @@ public:
return !(*this == o); return !(*this == o);
} }
// Used for e.g. std::set
bool operator<(KeyPress o) const {
return scancode < o.scancode;
}
// Check whether the keypress is valid // Check whether the keypress is valid
operator bool() const operator bool() const
{ {
@ -60,11 +65,22 @@ public:
static KeyPress getSpecialKey(const std::string &name); static KeyPress getSpecialKey(const std::string &name);
private: private:
using value_type = std::variant<u32, irr::EKEY_CODE>;
bool loadFromScancode(const std::string &name); bool loadFromScancode(const std::string &name);
void loadFromKey(irr::EKEY_CODE keycode, wchar_t keychar); void loadFromKey(irr::EKEY_CODE keycode, wchar_t keychar);
std::string formatScancode() const; std::string formatScancode() const;
std::variant<u32, irr::EKEY_CODE> scancode = irr::KEY_UNKNOWN; value_type scancode = irr::KEY_UNKNOWN;
friend std::hash<KeyPress>;
};
template <>
struct std::hash<KeyPress>
{
size_t operator()(KeyPress kp) const noexcept {
return std::hash<KeyPress::value_type>{}(kp.scancode);
}
}; };
// Global defines for convenience // Global defines for convenience