input_manager.h

#pragma once
 
#include <vector>
#include <functional>
#include <map>
#include <unordered_map>
#include "../generic/property.h"
#include "../generic/managed.h"
#include "../keycodes.h"
#include "../signals/signal.h"
#include "../event_listener.h"
 
namespace smlt {
 
class Scene;
class InputState;
class InputAxis;
class GameController;
 
namespace ui {
    class Keyboard;
}
 
typedef std::function<void (InputAxis*)> EachAxisCallback;
typedef std::vector<InputAxis*> AxisList;
 
struct TextInputEvent {
    friend class InputManager;
 
    /* Some keys will trigger additional text input events
     * that may be without content. These include backspace, enter, delete,
     * arrow keys, home, end, and space */
    KeyboardCode keyboard_code = KEYBOARD_CODE_NONE;
 
    void cancel() {
        cancelled = true;
    }
 
private:
    bool cancelled = false;
};
 
typedef sig::signal<bool (const unicode&, TextInputEvent&)> TextInputReceivedSignal;
 
enum JoystickButton : int8_t;
 
class InputManager:
    public RefCounted<InputManager> {
 
    DEFINE_SIGNAL(TextInputReceivedSignal, signal_text_input_received);
 
public:
    // You can't copy input managers
    InputManager(const InputManager&) = delete;
    InputManager& operator=(const InputManager&) = delete;
 
    InputManager(InputState* controller);
    ~InputManager();
 
    InputAxis* new_axis(const std::string& name);
    AxisList axises(const std::string& name);
    void each_axis(EachAxisCallback callback);
    void destroy_axises(const std::string& name);
    void destroy_axis(InputAxis* axis);
    std::size_t axis_count(const std::string& name) const;
 
    float axis_value(const std::string& name) const;
    int8_t axis_value_hard(const std::string& name) const;
 
    void update(float dt);
 
    /* Returns true if the axis was just pressed this frame */
    bool axis_was_pressed(const std::string& name) const;
 
    /* Returns true if the axis was just released this frame */
    bool axis_was_released(const std::string& name) const;
 
    bool start_text_input(bool force_onscreen=false);
 
    unicode stop_text_input();
 
    bool text_input_active() const {
        return text_input_enabled_;
    }
 
    bool onscreen_keyboard_active() const {
        return bool(keyboard_);
    }
 
private:
    InputState* controller_;
 
    std::multimap<std::string, std::shared_ptr<InputAxis>> axises_;
 
    std::unordered_map<std::string, bool> prev_axis_states_;
    std::unordered_map<std::string, bool> axis_states_;
 
    float _calculate_value(InputAxis* axis) const;
 
    bool _update_keyboard_axis(InputAxis* axis, float dt);
    bool _update_mouse_button_axis(InputAxis* axis, float dt);
    bool _update_joystick_button_axis(InputAxis* axis, float dt);
    void _update_mouse_axis_axis(InputAxis *axis, float dt);
    bool _update_joystick_axis_axis(InputAxis* axis, float dt);
    bool _update_joystick_hat_axis(InputAxis* axis, float dt);
 
    void _process_mouse(MouseID id, int8_t pbtn, int8_t nbtn,
                        bool* positive_pressed, bool* negative_pressed);
    void _process_game_controller(GameController* controller, JoystickButton pbtn, JoystickButton nbtn, bool *positive_pressed, bool *negative_pressed);
    void _process_keyboard(KeyboardID id, KeyboardCode pbtn, KeyboardCode nbtn,
                           bool* positive_pressed, bool* negative_pressed);
 
    bool text_input_enabled_ = false;
 
 
    /* Watch for keyboard inputs from the window */
    class TextInputHandler : public EventListener {
    public:
        TextInputHandler(InputManager* self): self_(self) {}
 
        void on_key_down(const KeyEvent& evt) override;
    private:
        InputManager* self_;
    };
 
    TextInputHandler event_listener_ = {this};
 
    StagePtr keyboard_stage_;
    CameraPtr keyboard_camera_;
    LayerPtr keyboard_pipeline_;
    ui::Keyboard* keyboard_ = nullptr;
 
    sig::connection scene_deactivated_conn_;
    void on_scene_deactivated(std::string, Scene* scene);
 
public:
    S_DEFINE_PROPERTY(state, &InputManager::controller_);
    S_DEFINE_PROPERTY(onscreen_keyboard, &InputManager::keyboard_);
};
 
}