BufferedRaylib.hpp

 
#include "raylib.h"
#include "../FastSignals/libfastsignals/include/signal.h"
 
#include <set>
#include <string>
#include <string_view>
#include <map>
#include <array>
#include <concepts>
 
namespace raylib {
 
    template<typename F>
    struct Delegate {};
 
    template<typename Ret, typename... Args>
    struct Delegate<Ret(Args...)>: public is::signals::signal<Ret(Args...)> {
        using callback_type = typename is::signals::signal<Ret(Args...)>::slot_type;
 
        Delegate& operator+=(callback_type callback) { this->connect(callback); return *this; }
 
        void set(callback_type callback) {
            this->disconnect_all_slots();
            this->connect(callback);
        }
        Delegate& operator=(callback_type callback) { set(callback); return *this; }
    };
 
    struct Button {
        // Enumerates different button types.
        enum class Type {
            Invalid = 0,
            Keyboard,
            Mouse,
            Gamepad
        } type;
 
        // Union to store different types of button configurations (raylib enums).
        // NOTE: it is recommended to not directly manipulate buttons but to instead use one of the following factory functions
        union {
            KeyboardKey keyboard;
            MouseButton mouse;
            struct {
                int id;
                GamepadButton button;
            } gamepad;
        };
 
        bool operator<(const Button& o) const;
 
        static bool IsPressed(const Button& button);
 
        static uint8_t IsSetPressed(const std::set<Button>& buttons);
 
        // Static helper functions to create Button objects for different input types.
        static Button key(KeyboardKey key) { return { Type::Keyboard, key}; }
 
        static Button btn(MouseButton button) { return { Type::Mouse, {.mouse = button}}; }
        static Button mouse_button(MouseButton button) { return btn(button); }
 
        static Button pad(GamepadButton button, int gamepad = 0) { return { Type::Keyboard, {.gamepad = {gamepad, button}}}; }
        static Button joy(GamepadButton button, int gamepad = 0) { return pad(button, gamepad); }
        static Button gamepad_button(GamepadButton button, int gamepad = 0) { return pad(button, gamepad); }
    };
 
    // Typedef for a set of buttons.
    using ButtonSet = std::set<Button>;
 
    struct Action {
        // Enumerates different action types.
        enum class Type {
            Invalid = 0,
            Button,
            Axis,
            Vector,
            MultiButton
        } type;
 
        struct Gamepad {
            int id;
            GamepadAxis axis;
        };
 
        template<size_t N>
        struct MultiButtonData {
            enum Direction {
                Up, Down, Left, Right,
                UpLeft, UpRight, DownLeft, DownRight
            };
            std::array<ButtonSet, N> directions;
            std::array<uint8_t, N> lasts;
            bool normalize = true; // When true the maximum value returned for a given axis is 1, if false the value of each direction will be the sum of the buttons pressed pointing one direction minus the sum of the pressed buttons pointing the other direction
        };
 
        // Union to store different types of action data.
        // NOTE: It is recommended that you don't try to mess with these values yourself, instead use one of the factory functions below
        // NOTE: Every inner type has a variable called last_state which holds the state as of the last time this action was pumped!
        //  Can be quired externally if nessicary... but ensure that you are accessing data of the correct type!
        union Data {
            struct Button {
                ButtonSet* buttons;
                bool combo = false; // When true all buttons in the set must be pressed for the action to trigger
                uint8_t last_state = 0; // TODO: can we add a function to access the last state?
            } button;
 
            struct Axis {
                enum class Type {
                    Invalid = 0,
                    Gamepad,
                    MouseWheel
                } type;
 
                Gamepad gamepad;
                float last_state = 0;
            } axis;
 
            struct Vector {
                enum class Type {
                    Invalid = 0,
                    MouseWheel,
                    MousePosition,
                    // MouseDelta,
                    GamepadAxes,
                } type;
 
                struct GamepadAxes{
                    Gamepad horizontal;
                    Gamepad vertical;
                } gamepad;
                Vector2 last_state = { 0, 0 };
            } vector;
 
            struct MultiButton {
                enum class Type {
                    Invalid = 0,
                    ButtonPair,
                    QuadButtons,
                } type;
 
                MultiButtonData<4>* quadButtons;
                Vector2 last_state;
            } multi;
        } data;
 
        // Callback invoked when the action is triggered
        Delegate<void(const std::string_view name, Vector2 state, Vector2 delta)> callback;
 
        // Constructors and destructor for the Action class.
        Action() : type(Type::Invalid), data({.button = {}}) {}
        ~Action() {
            if(type == Type::Button && data.button.buttons) delete data.button.buttons;
            else if(type == Type::MultiButton && data.multi.quadButtons) delete data.multi.quadButtons;
        }
        Action(Type t, Data d = {.button = {nullptr, false, 0}}) : type(t), data(d) {}
        Action(const Action&) = delete;
        Action(Action&& o) : Action() { *this = std::move(o); }
        Action& operator=(const Action&) = delete;
        Action& operator=(Action&& o);
 
        // Member functions to add and set callback functions for the action (vector overloads).
        Action& AddVectorCallbackNamed(is::signals::signal<void(const std::string_view name, Vector2 state, Vector2 delta)>::slot_type callback) {
            this->callback.connect(callback);
            return *this;
        }
        Action& SetVectorCallbackNamed(is::signals::signal<void(const std::string_view name, Vector2 state, Vector2 delta)>::slot_type callback) {
            this->callback.disconnect_all_slots();
            return AddVectorCallbackNamed(callback);
        }
        Action& AddVectorCallback(is::signals::signal<void(Vector2 state, Vector2 delta)>::slot_type callback) {
            return AddVectorCallbackNamed((is::signals::signal<void(const std::string_view name, Vector2 state, Vector2 delta)>::slot_type)
                [callback = std::move(callback)](const std::string_view name, Vector2 state, Vector2 delta){
                    callback(state, delta);
                });
        }
        Action& SetVectorCallback(is::signals::signal<void(Vector2 state, Vector2 delta)>::slot_type callback) {
            return SetVectorCallbackNamed((is::signals::signal<void(const std::string_view name, Vector2 state, Vector2 delta)>::slot_type)
                [callback = std::move(callback)](const std::string_view name, Vector2 state, Vector2 delta){
                    callback(state, delta);
                });
        }
 
        // Member functions to add and set callback functions for the action (float overloads).
        Action& AddFloatCallbackNamed(is::signals::signal<void(const std::string_view name, float state, float delta)>::slot_type callback) {
            return AddVectorCallbackNamed(
                (is::signals::signal<void(const std::string_view name, Vector2 state, Vector2 delta)>::slot_type)
                [callback](const std::string_view name, Vector2 state, Vector2 delta) {
                    callback(name, state.x, delta.x);
                });
        }
        Action& SetFloatCallbackNamed(is::signals::signal<void(const std::string_view name, float state, float delta)>::slot_type callback) {
            this->callback.disconnect_all_slots();
            return AddFloatCallbackNamed(callback);
        }
        Action& AddFloatCallback(is::signals::signal<void(float state, float delta)>::slot_type callback) {
            return AddFloatCallbackNamed([callback = std::move(callback)](const std::string_view name, float state, float delta){
                callback(state, delta);
            });
        }
        Action& SetFloatCallback(is::signals::signal<void(float state, float delta)>::slot_type callback) {
            return SetFloatCallbackNamed([callback = std::move(callback)](const std::string_view name, float state, float delta){
                callback(state, delta);
            });
        }
 
        // Aliases for backwards compatibility
        Action& AddCallbackNamed(is::signals::signal<void(const std::string_view name, float state, float delta)>::slot_type callback) {
            return AddFloatCallbackNamed(callback);
        }
        Action& SetCallbackNamed(is::signals::signal<void(const std::string_view name, float state, float delta)>::slot_type callback) {
            return SetFloatCallbackNamed(callback);
        }
        Action& AddCallback(is::signals::signal<void(float state, float delta)>::slot_type callback) {
            return AddFloatCallback(callback);
        }
        Action& SetCallback(is::signals::signal<void(float state, float delta)>::slot_type callback) {
            return SetFloatCallback(callback);
        }
 
        // Member functions to add and set callback functions for the action (button pressed overloads).
        Action& AddPressedCallbackNamed(is::signals::signal<void(const std::string_view name)>::slot_type callback) {
            return AddVectorCallbackNamed(
                (is::signals::signal<void(const std::string_view name, Vector2 state, Vector2 delta)>::slot_type)
                [callback](const std::string_view name, Vector2 state, Vector2 delta) {
                    if(state.x) callback(name);
                });
        }
        Action& SetPressedCallbackNamed(is::signals::signal<void(const std::string_view name)>::slot_type callback) {
            this->callback.disconnect_all_slots();
            return AddPressedCallbackNamed(callback);
        }
        Action& AddPressedCallback(is::signals::signal<void()>::slot_type callback) {
            return AddVectorCallbackNamed(
                (is::signals::signal<void(const std::string_view name, Vector2 state, Vector2 delta)>::slot_type)
                [callback](const std::string_view name, Vector2 state, Vector2 delta) {
                    if(state.x) callback();
                });
        }
        Action& SetPressedCallback(is::signals::signal<void()>::slot_type callback) {
            this->callback.disconnect_all_slots();
            return AddPressedCallback(callback);
        }
        // Member functions to add and set callback functions for the action (button released overloads).
        Action& AddReleasedCallbackNamed(is::signals::signal<void(const std::string_view name)>::slot_type callback) {
            return AddVectorCallbackNamed(
                (is::signals::signal<void(const std::string_view name, Vector2 state, Vector2 delta)>::slot_type)
                [callback](const std::string_view name, Vector2 state, Vector2 delta) {
                    if(!state.x) callback(name);
                });
        }
        Action& SetReleasedCallbackNamed(is::signals::signal<void(const std::string_view name)>::slot_type callback) {
            this->callback.disconnect_all_slots();
            return AddReleasedCallbackNamed(callback);
        }
        Action& AddReleasedCallback(is::signals::signal<void()>::slot_type callback) {
            return AddVectorCallbackNamed(
                (is::signals::signal<void(const std::string_view name, Vector2 state, Vector2 delta)>::slot_type)
                [callback](const std::string_view name, Vector2 state, Vector2 delta) {
                    if(!state.x) callback();
                });
        }
        Action& SetReleasedCallback(is::signals::signal<void()>::slot_type callback) {
            this->callback.disconnect_all_slots();
            return AddReleasedCallback(callback);
        }
 
        static Action button(Button button, bool combo = false) { return Action{Action::Type::Button, Action::Data{ .button = {new ButtonSet{button}, combo}}}; }
 
        static Action key(KeyboardKey key, bool combo = false) { return button({ Button::Type::Keyboard, key}, combo); }
 
        static Action mouse_button(MouseButton b, bool combo = false) { return button({ Button::Type::Mouse, {.mouse = b}}, combo); }
 
        static Action pad(GamepadButton b, int gamepad = 0, bool combo = false) { return button({ Button::Type::Keyboard, {.gamepad = {gamepad, b}}}, combo); }
 
        static Action joy(GamepadButton b, int gamepad = 0, bool combo = false) { return pad(b, gamepad, combo); }
 
        static Action gamepad_button(GamepadButton b, int gamepad = 0, bool combo = false) { return pad(b, gamepad, combo); }
 
        static Action button_set(ButtonSet buttons = {}, bool combo = false) { return Action{Action::Type::Button, Action::Data{ .button = { new ButtonSet(buttons), combo }}}; }
 
        static Action gamepad_axis(GamepadAxis axis = GAMEPAD_AXIS_LEFT_X, int gamepad = 0) {
            return {Action::Type::Axis, {.axis = {Data::Axis::Type::Gamepad, {gamepad, axis}}}};
        }
 
        static Action mouse_wheel() {
            return {Action::Type::Axis, {.axis = { Data::Axis::Type::MouseWheel }}};
        }
 
        static Action button_axis(ButtonSet positive, ButtonSet negative, bool normalize = true) {
            Action out{Action::Type::MultiButton};
            out.data.multi.type = Data::MultiButton::Type::ButtonPair;
            out.data.multi.quadButtons = new MultiButtonData<4>{{ positive, negative }, {}, normalize};
            return out;
        }
 
        static Action button_pair(ButtonSet left, ButtonSet right, bool normalize = true) {
            return button_axis(left, right, normalize);
        }
 
        static Action mouse_wheel_vector() {
            return {Action::Type::Vector, {.vector = { Data::Vector::Type::MouseWheel }}};
        }
 
        static Action mouse_position() {
            return {Action::Type::Vector, {.vector = { Data::Vector::Type::MousePosition }}};
        }
 
        static Action gamepad_axes(GamepadAxis horizontal = GAMEPAD_AXIS_LEFT_X, GamepadAxis vertical = GAMEPAD_AXIS_LEFT_Y, int gamepadHorizontal = 0, int gamepadVertical = -1);
 
        static Action quad(ButtonSet up, ButtonSet down, ButtonSet left, ButtonSet right, bool normalized = true) {
            Action out{Action::Type::MultiButton};
            out.data.multi.type = Data::MultiButton::Type::QuadButtons;
            out.data.multi.quadButtons = new MultiButtonData<4>{{ up, down, left, right }, {}, normalized};
            return out;
        }
 
        static Action wasd(
            ButtonSet up = {Button::key(KEY_W), Button::key(KEY_UP)},
            ButtonSet left = {Button::key(KEY_A), Button::key(KEY_LEFT)},
            ButtonSet down = {Button::key(KEY_S), Button::key(KEY_DOWN)},
            ButtonSet right = {Button::key(KEY_D), Button::key(KEY_RIGHT)},
            bool normalized = true
        ) { return quad(up, down, left, right, normalized); }
 
 
        Action&& Move() { return std::move(*this); }
        Action&& move() { return std::move(*this); }
 
        void PollEvents(std::string_view name);
 
    protected:
        friend struct BufferedInput;
 
        // Functions which get called by BufferedInput to process actions
        void PumpButton(std::string_view name);
        void PumpAxis(std::string_view name);
        void PumpVector(std::string_view name);
        void PumpMultiButton(std::string_view name);
    };
 
 
    struct BufferedInput {
        // Map associating names with actions
        std::map<std::string, Action> actions;
 
        // Access to the action map via the input object itself
        Action& operator[](const std::string& key) {
            return actions[key];
        }
 
        // Function which updates the state of all actions in the `actions` map.
        void PollEvents(bool whileUnfocused = false);
    };
 
}