osb/source/game/StarInput.hpp

191 lines
5.3 KiB
C++
Raw Normal View History

2023-07-01 20:34:43 +00:00
#ifndef STAR_INPUT_HPP
#define STAR_INPUT_HPP
#include "StarInputEvent.hpp"
#include "StarJson.hpp"
#include "StarListener.hpp"
#include "StarHash.hpp"
namespace Star {
STAR_CLASS(Input);
STAR_EXCEPTION(InputException, StarException);
typedef Variant<Key, MouseButton, ControllerButton> InputVariant;
template <>
struct hash<InputVariant> {
size_t operator()(InputVariant const& v) const;
};
class Input {
public:
2023-07-02 00:55:25 +00:00
static Json inputEventToJson(InputEvent const& event);
2023-07-01 20:34:43 +00:00
struct KeyBind {
Key key = Key::Zero;
KeyMod mods = KeyMod::NoMod;
uint8_t priority = 0;
inline bool operator<(KeyBind const& rhs) const {
return priority < rhs.priority;
}
inline bool operator>(KeyBind const& rhs) const {
return priority > rhs.priority;
}
};
struct MouseBind {
MouseButton button = MouseButton::Left;
KeyMod mods = KeyMod::NoMod;
uint8_t priority = 0;
};
struct ControllerBind {
unsigned int controller = 0;
ControllerButton button = ControllerButton::Invalid;
};
2023-07-01 22:16:14 +00:00
typedef MVariant<KeyBind, MouseBind, ControllerBind> Bind;
2023-07-01 20:34:43 +00:00
static Bind bindFromJson(Json const& json);
static Json bindToJson(Bind const& bind);
2023-07-01 22:16:14 +00:00
struct BindCategory;
2023-07-01 20:34:43 +00:00
struct BindEntry {
// The internal ID of this entry.
String id;
// The user-facing name of this entry.
String name;
2023-07-01 22:16:14 +00:00
// The category this entry belongs to.
BindCategory const* category;
2023-07-01 20:34:43 +00:00
// The default binds.
List<Bind> defaultBinds;
// The user-configured binds.
List<Bind> customBinds;
2023-07-01 22:16:14 +00:00
BindEntry(String entryId, Json const& config, BindCategory const& parentCategory);
2023-07-02 07:19:54 +00:00
void updated();
2023-07-01 20:34:43 +00:00
};
struct BindRef {
KeyMod mods;
2023-07-02 07:19:54 +00:00
uint8_t priority = 0;
BindEntry* entry = nullptr; // Invalidated on reload, careful!
2023-07-01 20:34:43 +00:00
BindRef(BindEntry& bindEntry, KeyBind& keyBind);
BindRef(BindEntry& bindEntry, MouseBind& mouseBind);
BindRef(BindEntry& bindEntry);
2023-07-01 20:34:43 +00:00
};
struct BindCategory {
String id;
String name;
2023-07-01 22:16:14 +00:00
Json config;
2023-07-01 20:34:43 +00:00
2023-07-02 07:19:54 +00:00
StableHashMap<String, BindEntry> entries;
2023-07-01 20:34:43 +00:00
2023-07-01 22:16:14 +00:00
BindCategory(String categoryId, Json const& categoryConfig);
2023-07-01 20:34:43 +00:00
};
struct InputState {
2023-07-02 07:19:54 +00:00
unsigned presses = 0;
unsigned releases = 0;
bool pressed = false;
bool held = false;
bool released = false;
2023-07-01 20:34:43 +00:00
// Calls the passed functions for each press and release.
template <typename PressFunction, typename ReleaseFunction>
void forEach(PressFunction&& pressed, ReleaseFunction&& released) {
for (size_t i = 0; i != releases; ++i) {
pressed();
released();
}
}
2023-07-02 07:19:54 +00:00
inline void reset() {
presses = releases = 0;
pressed = released = false;
2023-07-01 20:34:43 +00:00
}
2023-07-02 07:19:54 +00:00
inline void press() { pressed = ++presses; held = true; }
inline void release() { released = ++releases; held = false; }
2023-07-01 20:34:43 +00:00
};
// Get pointer to the singleton root instance, if it exists. Otherwise,
// returns nullptr.
static Input* singletonPtr();
// Gets reference to GuiContext singleton, throws GuiContextException if root
// is not initialized.
static Input& singleton();
Input();
~Input();
Input(Input const&) = delete;
Input& operator=(Input const&) = delete;
2023-07-02 00:55:25 +00:00
List<std::pair<InputEvent, bool>> const& inputEventsThisFrame() const;
// Clears input state. Should be done at the very start or end of the client loop.
2023-07-01 20:34:43 +00:00
void reset();
2023-07-02 00:55:25 +00:00
void update();
2023-07-01 20:34:43 +00:00
// Handles an input event.
2023-07-02 00:55:25 +00:00
bool handleInput(InputEvent const& input, bool gameProcessed);
void rebuildMappings();
2023-07-01 20:34:43 +00:00
// Loads input categories and their binds from Assets.
void reload();
2023-07-02 07:19:54 +00:00
void setTextInputActive(bool active);
Maybe<unsigned> bindDown(String const& categoryId, String const& bindId);
bool bindHeld(String const& categoryId, String const& bindId);
Maybe<unsigned> bindUp (String const& categoryId, String const& bindId);
void resetBinds(String const& categoryId, String const& bindId);
void setBinds(String const& categoryId, String const& bindId, Json const& binds);
Json getDefaultBinds(String const& categoryId, String const& bindId);
Json getBinds(String const& categoryId, String const& bindId);
2023-07-01 20:34:43 +00:00
private:
2023-07-02 00:55:25 +00:00
List<BindEntry*> filterBindEntries(List<BindRef> const& binds, KeyMod mods) const;
2023-07-02 07:19:54 +00:00
BindEntry* bindEntryPtr(String const& categoryId, String const& bindId);
BindEntry& bindEntry(String const& categoryId, String const& bindId);
InputState* bindStatePtr(String const& categoryId, String const& bindId);
InputState* inputStatePtr(InputVariant key);
2023-07-01 20:34:43 +00:00
static Input* s_singleton;
// Regenerated on reload.
2023-07-02 07:19:54 +00:00
StableHashMap<String, BindCategory> m_bindCategories;
2023-07-01 20:34:43 +00:00
// Contains raw pointers to bind entries in categories, so also regenerated on reload.
2023-07-02 00:55:25 +00:00
HashMap<InputVariant, List<BindRef>> m_bindMappings;
2023-07-01 20:34:43 +00:00
ListenerPtr m_rootReloadListener;
2023-07-02 00:55:25 +00:00
// Per-frame input event storage for Lua.
List<std::pair<InputEvent, bool>> m_inputEvents;
2023-07-01 20:34:43 +00:00
2023-07-02 00:55:25 +00:00
// Per-frame input state maps.
//Input states
2023-07-01 20:34:43 +00:00
HashMap<InputVariant, InputState> m_inputStates;
2023-07-02 00:55:25 +00:00
//Bind states
2023-07-02 07:19:54 +00:00
HashMap<BindEntry const*, InputState> m_bindStates;
KeyMod m_pressedMods;
bool m_textInputActive;
2023-07-01 20:34:43 +00:00
};
}
#endif