diff --git a/src/client/game.cpp b/src/client/game.cpp index 4d5240d25..87e0d4e11 100644 --- a/src/client/game.cpp +++ b/src/client/game.cpp @@ -885,7 +885,7 @@ bool Game::startup(bool *kill, this->chat_backend = chat_backend; simple_singleplayer_mode = start_data.isSinglePlayer(); - input->keycache.populate(); + input->reloadKeybindings(); driver = device->getVideoDriver(); smgr = m_rendering_engine->get_scene_manager(); diff --git a/src/client/game_formspec.cpp b/src/client/game_formspec.cpp index f573a1543..4bd1a42bd 100644 --- a/src/client/game_formspec.cpp +++ b/src/client/game_formspec.cpp @@ -554,7 +554,7 @@ bool GameFormSpec::handleCallbacks() } 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; } diff --git a/src/client/inputhandler.cpp b/src/client/inputhandler.cpp index a33931503..492f2fd6c 100644 --- a/src/client/inputhandler.cpp +++ b/src/client/inputhandler.cpp @@ -12,75 +12,98 @@ #include "log_internal.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() -{ - 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"); + keybindings[KeyType::ESC] = EscapeKey; - key[KeyType::AUTOFORWARD] = getKeySetting("keymap_autoforward"); + keybindings[KeyType::AUTOFORWARD] = getKeySetting("keymap_autoforward"); - key[KeyType::DROP] = getKeySetting("keymap_drop"); - key[KeyType::INVENTORY] = getKeySetting("keymap_inventory"); - key[KeyType::CHAT] = getKeySetting("keymap_chat"); - key[KeyType::CMD] = getKeySetting("keymap_cmd"); - key[KeyType::CMD_LOCAL] = getKeySetting("keymap_cmd_local"); - key[KeyType::CONSOLE] = getKeySetting("keymap_console"); - key[KeyType::MINIMAP] = getKeySetting("keymap_minimap"); - key[KeyType::FREEMOVE] = getKeySetting("keymap_freemove"); - key[KeyType::PITCHMOVE] = getKeySetting("keymap_pitchmove"); - key[KeyType::FASTMOVE] = getKeySetting("keymap_fastmove"); - key[KeyType::NOCLIP] = getKeySetting("keymap_noclip"); - key[KeyType::HOTBAR_PREV] = getKeySetting("keymap_hotbar_previous"); - key[KeyType::HOTBAR_NEXT] = getKeySetting("keymap_hotbar_next"); - key[KeyType::MUTE] = getKeySetting("keymap_mute"); - key[KeyType::INC_VOLUME] = getKeySetting("keymap_increase_volume"); - key[KeyType::DEC_VOLUME] = getKeySetting("keymap_decrease_volume"); - key[KeyType::CINEMATIC] = getKeySetting("keymap_cinematic"); - key[KeyType::SCREENSHOT] = getKeySetting("keymap_screenshot"); - key[KeyType::TOGGLE_BLOCK_BOUNDS] = getKeySetting("keymap_toggle_block_bounds"); - key[KeyType::TOGGLE_HUD] = getKeySetting("keymap_toggle_hud"); - key[KeyType::TOGGLE_CHAT] = getKeySetting("keymap_toggle_chat"); - key[KeyType::TOGGLE_FOG] = getKeySetting("keymap_toggle_fog"); - key[KeyType::TOGGLE_UPDATE_CAMERA] = getKeySetting("keymap_toggle_update_camera"); - key[KeyType::TOGGLE_DEBUG] = getKeySetting("keymap_toggle_debug"); - key[KeyType::TOGGLE_PROFILER] = getKeySetting("keymap_toggle_profiler"); - key[KeyType::CAMERA_MODE] = getKeySetting("keymap_camera_mode"); - key[KeyType::INCREASE_VIEWING_RANGE] = + keybindings[KeyType::DROP] = getKeySetting("keymap_drop"); + keybindings[KeyType::INVENTORY] = getKeySetting("keymap_inventory"); + keybindings[KeyType::CHAT] = getKeySetting("keymap_chat"); + keybindings[KeyType::CMD] = getKeySetting("keymap_cmd"); + keybindings[KeyType::CMD_LOCAL] = getKeySetting("keymap_cmd_local"); + keybindings[KeyType::CONSOLE] = getKeySetting("keymap_console"); + keybindings[KeyType::MINIMAP] = getKeySetting("keymap_minimap"); + keybindings[KeyType::FREEMOVE] = getKeySetting("keymap_freemove"); + keybindings[KeyType::PITCHMOVE] = getKeySetting("keymap_pitchmove"); + keybindings[KeyType::FASTMOVE] = getKeySetting("keymap_fastmove"); + keybindings[KeyType::NOCLIP] = getKeySetting("keymap_noclip"); + keybindings[KeyType::HOTBAR_PREV] = getKeySetting("keymap_hotbar_previous"); + keybindings[KeyType::HOTBAR_NEXT] = getKeySetting("keymap_hotbar_next"); + keybindings[KeyType::MUTE] = getKeySetting("keymap_mute"); + keybindings[KeyType::INC_VOLUME] = getKeySetting("keymap_increase_volume"); + keybindings[KeyType::DEC_VOLUME] = getKeySetting("keymap_decrease_volume"); + keybindings[KeyType::CINEMATIC] = getKeySetting("keymap_cinematic"); + keybindings[KeyType::SCREENSHOT] = getKeySetting("keymap_screenshot"); + keybindings[KeyType::TOGGLE_BLOCK_BOUNDS] = getKeySetting("keymap_toggle_block_bounds"); + keybindings[KeyType::TOGGLE_HUD] = getKeySetting("keymap_toggle_hud"); + keybindings[KeyType::TOGGLE_CHAT] = getKeySetting("keymap_toggle_chat"); + keybindings[KeyType::TOGGLE_FOG] = getKeySetting("keymap_toggle_fog"); + keybindings[KeyType::TOGGLE_UPDATE_CAMERA] = getKeySetting("keymap_toggle_update_camera"); + keybindings[KeyType::TOGGLE_DEBUG] = getKeySetting("keymap_toggle_debug"); + keybindings[KeyType::TOGGLE_PROFILER] = getKeySetting("keymap_toggle_profiler"); + keybindings[KeyType::CAMERA_MODE] = getKeySetting("keymap_camera_mode"); + keybindings[KeyType::INCREASE_VIEWING_RANGE] = getKeySetting("keymap_increase_viewing_range_min"); - key[KeyType::DECREASE_VIEWING_RANGE] = + keybindings[KeyType::DECREASE_VIEWING_RANGE] = getKeySetting("keymap_decrease_viewing_range_min"); - key[KeyType::RANGESELECT] = getKeySetting("keymap_rangeselect"); - key[KeyType::ZOOM] = getKeySetting("keymap_zoom"); + keybindings[KeyType::RANGESELECT] = getKeySetting("keymap_rangeselect"); + keybindings[KeyType::ZOOM] = getKeySetting("keymap_zoom"); - key[KeyType::QUICKTUNE_NEXT] = getKeySetting("keymap_quicktune_next"); - key[KeyType::QUICKTUNE_PREV] = getKeySetting("keymap_quicktune_prev"); - key[KeyType::QUICKTUNE_INC] = getKeySetting("keymap_quicktune_inc"); - key[KeyType::QUICKTUNE_DEC] = getKeySetting("keymap_quicktune_dec"); + keybindings[KeyType::QUICKTUNE_NEXT] = getKeySetting("keymap_quicktune_next"); + keybindings[KeyType::QUICKTUNE_PREV] = getKeySetting("keymap_quicktune_prev"); + keybindings[KeyType::QUICKTUNE_INC] = getKeySetting("keymap_quicktune_inc"); + keybindings[KeyType::QUICKTUNE_DEC] = getKeySetting("keymap_quicktune_dec"); for (int i = 0; i < HUD_HOTBAR_ITEMCOUNT_MAX; i++) { 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 - handler->dontListenForKeys(); - for (auto k : key) { - handler->listenForKey(k); - } - handler->listenForKey(EscapeKey); + // First clear all keys, then re-add the ones we listen for + keysListenedFor.clear(); + for (int i = 0; i < KeyType::INTERNAL_ENUM_COUNT; i++) { + listenForKey(keybindings[i], static_cast(i)); + } +} + +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 if (event.EventType == irr::EET_KEY_INPUT_EVENT) { KeyPress keyCode(event.KeyInput); - if (keyCode && keysListenedFor[keyCode]) { // ignore key input that is invalid or irrelevant for the game. - 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); - } - + if (setKeyDown(keyCode, event.KeyInput.PressedDown)) return true; - } - } else if (g_touchcontrols && event.EventType == irr::EET_TOUCH_INPUT_EVENT) { // In case of touchcontrols, we have to handle different events g_touchcontrols->translateEvent(event); @@ -171,31 +179,22 @@ bool MyEventReceiver::OnEvent(const SEvent &event) // Handle mouse events switch (event.MouseInput.Event) { case EMIE_LMOUSE_PRESSED_DOWN: - keyIsDown.set(LMBKey); - keyWasDown.set(LMBKey); - keyWasPressed.set(LMBKey); + setKeyDown(LMBKey, true); break; case EMIE_MMOUSE_PRESSED_DOWN: - keyIsDown.set(MMBKey); - keyWasDown.set(MMBKey); - keyWasPressed.set(MMBKey); + setKeyDown(MMBKey, true); break; case EMIE_RMOUSE_PRESSED_DOWN: - keyIsDown.set(RMBKey); - keyWasDown.set(RMBKey); - keyWasPressed.set(RMBKey); + setKeyDown(RMBKey, true); break; case EMIE_LMOUSE_LEFT_UP: - keyIsDown.unset(LMBKey); - keyWasReleased.set(LMBKey); + setKeyDown(LMBKey, false); break; case EMIE_MMOUSE_LEFT_UP: - keyIsDown.unset(MMBKey); - keyWasReleased.set(MMBKey); + setKeyDown(MMBKey, false); break; case EMIE_RMOUSE_LEFT_UP: - keyIsDown.unset(RMBKey); - keyWasReleased.set(RMBKey); + setKeyDown(RMBKey, false); break; case EMIE_MOUSE_WHEEL: mouse_wheel += event.MouseInput.Wheel; @@ -257,7 +256,7 @@ s32 RandomInputHandler::Rand(s32 min, s32 max) } struct RandomInputHandlerSimData { - std::string key; + GameKeyType key; float counter; int time_max; }; @@ -265,19 +264,19 @@ struct RandomInputHandlerSimData { void RandomInputHandler::step(float dtime) { static RandomInputHandlerSimData rnd_data[] = { - { "keymap_jump", 0.0f, 40 }, - { "keymap_aux1", 0.0f, 40 }, - { "keymap_forward", 0.0f, 40 }, - { "keymap_left", 0.0f, 40 }, - { "keymap_dig", 0.0f, 30 }, - { "keymap_place", 0.0f, 15 } + { KeyType::JUMP, 0.0f, 40 }, + { KeyType::AUX1, 0.0f, 40 }, + { KeyType::FORWARD, 0.0f, 40 }, + { KeyType::LEFT, 0.0f, 40 }, + { KeyType::DIG, 0.0f, 30 }, + { KeyType::PLACE, 0.0f, 15 } }; for (auto &i : rnd_data) { i.counter -= dtime; if (i.counter < 0.0) { i.counter = 0.1 * Rand(1, i.time_max); - keydown.toggle(getKeySetting(i.key.c_str())); + keydown.flip(i.key); } } { diff --git a/src/client/inputhandler.h b/src/client/inputhandler.h index 6de1a0575..fec52a74d 100644 --- a/src/client/inputhandler.h +++ b/src/client/inputhandler.h @@ -7,7 +7,10 @@ #include "irrlichttypes.h" #include "irr_v2d.h" #include "joystick_controller.h" +#include #include +#include +#include #include "keycode.h" class InputHandler; @@ -17,142 +20,32 @@ enum class PointerType { 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 -{ - typedef std::list 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 { public: // This is the one method that we have to implement 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 - bool WasKeyDown(KeyPress keyCode) + bool WasKeyDown(GameKeyType key) { - bool b = keyWasDown[keyCode]; + bool b = keyWasDown[key]; if (b) - keyWasDown.unset(keyCode); + keyWasDown.reset(key); return b; } // Checks whether a key was just pressed. State will be cleared // 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 // 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) - { - keysListenedFor.set(keyCode); - } - void dontListenForKeys() - { - keysListenedFor.clear(); - } + void reloadKeybindings(); s32 getMouseWheel() { @@ -163,28 +56,30 @@ public: void clearInput() { - keyIsDown.clear(); - keyWasDown.clear(); - keyWasPressed.clear(); - keyWasReleased.clear(); + physicalKeyDown.clear(); + keyIsDown.reset(); + keyWasDown.reset(); + keyWasPressed.reset(); + keyWasReleased.reset(); mouse_wheel = 0; } void releaseAllKeys() { - keyWasReleased.append(keyIsDown); - keyIsDown.clear(); + physicalKeyDown.clear(); + keyWasReleased |= keyIsDown; + keyIsDown.reset(); } void clearWasKeyPressed() { - keyWasPressed.clear(); + keyWasPressed.reset(); } void clearWasKeyReleased() { - keyWasReleased.clear(); + keyWasReleased.reset(); } JoystickController *joystick = nullptr; @@ -192,26 +87,41 @@ public: PointerType getLastPointerType() { return last_pointer_type; } 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 keybindings; + s32 mouse_wheel = 0; + // The current state of physical keys. + std::set physicalKeyDown; + // The current state of keys - KeyList keyIsDown; + std::bitset keyIsDown; // Like keyIsDown but only reset when that key is read - KeyList keyWasDown; + std::bitset keyWasDown; // Whether a key has just been pressed - KeyList keyWasPressed; + std::bitset keyWasPressed; // Whether a key has just been released - KeyList keyWasReleased; + std::bitset keyWasReleased; // List of keys we listen for - // TODO perhaps the type of this is not really - // 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; + std::unordered_map keysListenedFor; // Intentionally not reset by clearInput/releaseAllKeys. bool fullscreen_is_down = false; @@ -222,12 +132,6 @@ private: class InputHandler { public: - InputHandler() - { - keycache.handler = this; - keycache.populate(); - } - virtual ~InputHandler() = default; virtual bool isRandom() const @@ -247,8 +151,7 @@ public: virtual void clearWasKeyPressed() {} virtual void clearWasKeyReleased() {} - virtual void listenForKey(KeyPress keyCode) {} - virtual void dontListenForKeys() {} + virtual void reloadKeybindings() {} virtual v2s32 getMousePos() = 0; virtual void setMousePos(s32 x, s32 y) = 0; @@ -261,7 +164,6 @@ public: virtual void releaseAllKeys() {} JoystickController joystick; - KeyCache keycache; }; /* @@ -274,6 +176,7 @@ public: RealInputHandler(MyEventReceiver *receiver) : m_receiver(receiver) { m_receiver->joystick = &joystick; + m_receiver->reloadKeybindings(); } virtual ~RealInputHandler() @@ -283,19 +186,19 @@ public: 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) { - return m_receiver->WasKeyDown(keycache.key[k]) || joystick.wasKeyDown(k); + return m_receiver->WasKeyDown(k) || joystick.wasKeyDown(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) { - return m_receiver->WasKeyReleased(keycache.key[k]) || joystick.wasKeyReleased(k); + return m_receiver->WasKeyReleased(k) || joystick.wasKeyReleased(k); } virtual float getJoystickSpeed(); @@ -316,13 +219,9 @@ public: m_receiver->clearWasKeyReleased(); } - virtual void listenForKey(KeyPress keyCode) + virtual void reloadKeybindings() { - m_receiver->listenForKey(keyCode); - } - virtual void dontListenForKeys() - { - m_receiver->dontListenForKeys(); + m_receiver->reloadKeybindings(); } virtual v2s32 getMousePos(); @@ -360,7 +259,7 @@ public: 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 wasKeyPressed(GameKeyType k) { return false; } virtual bool wasKeyReleased(GameKeyType k) { return false; } @@ -377,7 +276,7 @@ public: s32 Rand(s32 min, s32 max); private: - KeyList keydown; + std::bitset keydown; v2s32 mousepos; v2s32 mousespeed; float joystickSpeed; diff --git a/src/client/keycode.h b/src/client/keycode.h index 038c47ebd..503529b52 100644 --- a/src/client/keycode.h +++ b/src/client/keycode.h @@ -49,6 +49,11 @@ public: return !(*this == o); } + // Used for e.g. std::set + bool operator<(KeyPress o) const { + return scancode < o.scancode; + } + // Check whether the keypress is valid operator bool() const { @@ -60,11 +65,22 @@ public: static KeyPress getSpecialKey(const std::string &name); private: + using value_type = std::variant; bool loadFromScancode(const std::string &name); void loadFromKey(irr::EKEY_CODE keycode, wchar_t keychar); std::string formatScancode() const; - std::variant scancode = irr::KEY_UNKNOWN; + value_type scancode = irr::KEY_UNKNOWN; + + friend std::hash; +}; + +template <> +struct std::hash +{ + size_t operator()(KeyPress kp) const noexcept { + return std::hash{}(kp.scancode); + } }; // Global defines for convenience