79 lines
2.9 KiB
C++
79 lines
2.9 KiB
C++
#ifndef PLAYER_INPUT_HPP
|
|
#define PLAYER_INPUT_HPP
|
|
|
|
#include <vector>
|
|
#include <optional>
|
|
#include "godot_cpp/classes/input.hpp"
|
|
#include "godot_cpp/classes/input_event.hpp"
|
|
#include "godot_cpp/classes/node.hpp"
|
|
#include "godot_cpp/variant/callable.hpp"
|
|
|
|
namespace godot {
|
|
class PlayerInput : public Node {
|
|
GDCLASS(PlayerInput, Node)
|
|
static void _bind_methods();
|
|
public:
|
|
// a listener is a combination of a positive and negative action and a listener function.
|
|
// listener functions use godot's Object::call function.
|
|
// So they require a Node instance and a function name.
|
|
// The expected signature is void(Ref<InputEvent>, float)
|
|
// actions can also be "special" actions prefixed with _.
|
|
// special actions include _mouse_up, _mouse_down, _mouse_left and _mouse_right
|
|
// which rather than checking action_is_down,
|
|
// will use PlayerInput::get_last_mouse_motion() to poll the current state.
|
|
struct Listener {
|
|
friend class PlayerInput;
|
|
private:
|
|
// the two actions, evaluated as positive - negative
|
|
String actionNegative{""};
|
|
String actionPositive{""};
|
|
// the last cached action, if the newest result matches this, the event will be considered
|
|
// duplicate and ignored (not passed to listener)
|
|
float lastCached{0.f};
|
|
Callable callable;
|
|
// if either actionNegative or actionPositive is a _mouse_ event this will be true
|
|
bool isMouseEvent{false};
|
|
|
|
public:
|
|
Listener(String positive, String negative, Callable callable);
|
|
Listener(String action, Callable callable);
|
|
// evaluate the current state of an action.
|
|
static std::optional<float> evaluate_action(String const &action);
|
|
// check if this event has any chance to result in a trigger, does not evaluate the event or
|
|
// poll current input state
|
|
bool has_changed(Ref<InputEvent> const &event);
|
|
// evaluate the event for changes to either actionPositive or actionNegative
|
|
float evaluate(Ref<InputEvent> const &event);
|
|
|
|
bool operator==(godot::PlayerInput::Listener const& b);
|
|
};
|
|
private:
|
|
// the last mouse motion, updated by the primary instance
|
|
static Vector2 lastMouseMotion;
|
|
// does a primary instance exist
|
|
static bool primaryExists;
|
|
// is this the primary instance
|
|
// the primary instance is responsible for updating static
|
|
// variables like lastMouseMotion
|
|
bool isPrimary{false};
|
|
|
|
// current listeners for this instance
|
|
std::vector<Listener> listeners{};
|
|
public:
|
|
static Vector2 get_last_mouse_motion();
|
|
|
|
virtual void _enter_tree() override;
|
|
virtual void _exit_tree() override;
|
|
virtual void _unhandled_input(Ref<InputEvent> const &event) override;
|
|
virtual void _process(double deltaTime) override;
|
|
|
|
void listen_to(Listener const& listener);
|
|
void stop_listening(Node *node);
|
|
void stop_listening(Listener const& listener);
|
|
void clear_listeners();
|
|
};
|
|
}
|
|
|
|
|
|
#endif // !PLAYER_INPUT_HPP
|