Input.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include <algorithm>
#include <cstdint>
#include <limits>
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() Button : UInt32 {
        None = 0,
 
        Space,
        Apostrophe, /* ' */
        Comma, /* , */
        Minus, /* - */
        Period, /* . */
        Slash, /* / */
        Semicolon, /* ; */
        Equal, /* = */
 
        Number0,
        Number1,
        Number2,
        Number3,
        Number4,
        Number5,
        Number6,
        Number7,
        Number8,
        Number9,
 
        A,
        B,
        C,
        D,
        E,
        F,
        G,
        H,
        I,
        J,
        K,
        L,
        M,
        N,
        O,
        P,
        Q,
        R,
        S,
        T,
        U,
        V,
        W,
        X,
        Y,
        Z,
 
        LeftBracket, /* [ */
        RightBracket, /* ] */
        Backslash, /* \ */
        GraveAccent, /* ` */
 
        World1, /* non-us #1 */
        World2, /* non-us #2 */
 
        Escape,
        Enter,
        Tab,
        Backspace,
        Insert,
        Delete,
        Right,
        Left,
        Down,
        Up,
 
        PageUp,
        PageDown,
        Home,
        End,
        CapsLock,
        ScrollLock,
        NumLock,
        PrintScreen,
        Pause,
 
        F1,
        F2,
        F3,
        F4,
        F5,
        F6,
        F7,
        F8,
        F9,
        F10,
        F11,
        F12,
        F13,
        F14,
        F15,
        F16,
        F17,
        F18,
        F19,
        F20,
        F21,
        F22,
        F23,
        F24,
        F25,
 
        Keypad0,
        Keypad1,
        Keypad2,
        Keypad3,
        Keypad4,
        Keypad5,
        Keypad6,
        Keypad7,
        Keypad8,
        Keypad9,
 
        KeypadDecimal,
        KeypadDivide,
        KeypadMultiply,
        KeypadSubtract,
        KeypadAdd,
        KeypadEnter,
        KeypadEqual,
 
        LeftShift,
        LeftControl,
        LeftAlt,
        LeftSuper,
        RightShift,
        RightControl,
        RightAlt,
        RightSuper,
        Menu,
 
        MouseLeft,
        MouseMiddle,
        MouseRight,
 
        Mouse0,
        Mouse1,
        Mouse2,
        Mouse3,
        Mouse4,
        Mouse5,
        Mouse6,
        Mouse7,
 
        Unknown = std::numeric_limits<UInt32>::max()
    };
 
    using ButtonSet = Vector<Button>;
 
    [[nodiscard]] inline bool operator&(const ButtonSet& set, const Button button) noexcept { return std::find(set.begin(), set.end(), button) != set.end(); }
 
    [[nodiscard]] inline bool operator&(const ButtonSet& a, const ButtonSet& b) noexcept {
        for(const Button button : b) {
            if(!(a & button)) {
                return false;
            }
        }
        return true;
    }
 
    [[nodiscard]] inline ButtonSet operator+(const Button a, const Button b) { return ButtonSet{a, b}; }
 
    inline ButtonSet& operator+=(ButtonSet& set, const Button button) {
        const auto found = std::find(set.begin(), set.end(), button);
        if(found != set.end()) {
            return set;
        }
        set.push_back(button);
        return set;
    }
 
    [[nodiscard]] inline ButtonSet operator+(const ButtonSet& set, const Button button) {
        ButtonSet buttonSet = set;
        buttonSet += button;
        return buttonSet;
    }
 
    inline ButtonSet& operator+=(ButtonSet& set, const ButtonSet& buttons) {
        for(const Button button : buttons) {
            set += button;
        }
        return set;
    }
 
    [[nodiscard]] inline ButtonSet operator+(const ButtonSet& set, const ButtonSet& buttons) {
        ButtonSet buttonSet = set;
        buttonSet += buttons;
        return buttonSet;
    }
 
    [[nodiscard]] inline ButtonSet operator|(const ButtonSet& set, const Button button) { return set + button; }
 
    inline ButtonSet& operator-=(ButtonSet& set, const Button button) {
        const auto found = std::find(set.begin(), set.end(), button);
        if(found == set.end()) {
            return set;
        }
        set.erase(found);
        return set;
    }
 
    [[nodiscard]] inline ButtonSet operator-(const ButtonSet& set, const Button button) {
        ButtonSet buttonSet = set;
        buttonSet -= button;
        return buttonSet;
    }
 
    inline ButtonSet& operator-=(ButtonSet& set, const ButtonSet& buttons) {
        for(const Button button : buttons) {
            set -= button;
        }
        return set;
    }
 
    [[nodiscard]] inline ButtonSet operator-(const ButtonSet& set, const ButtonSet& buttons) {
        ButtonSet buttonSet = set;
        buttonSet -= buttons;
        return buttonSet;
    }
 
    enum class CE_SCRIPT_EXPORT() ModifierButton : UInt16 {
        Shift = 1u << 0u,
 
        Control = 1u << 1u,
 
        Alt = 1u << 2u,
 
        Super = 1u << 3u,
 
        CapsLock = 1u << 4u,
 
        NumLock = 1u << 5u,
 
        ScrollLock = 1u << 6u,
 
        None = 0,
 
        Any = std::numeric_limits<std::underlying_type_t<ModifierButton>>::max()
    };
 
    [[nodiscard]] inline constexpr bool operator&(ModifierButton a, ModifierButton b) noexcept {
        if(b == ModifierButton::None) {
            return a == b;
        }
        if(b == ModifierButton::Any) {
            return true;
        }
        return (static_cast<std::underlying_type_t<ModifierButton>>(a) & static_cast<std::underlying_type_t<ModifierButton>>(b)) ==
            static_cast<std::underlying_type_t<ModifierButton>>(b);
    }
 
    [[nodiscard]] inline constexpr ModifierButton operator|(ModifierButton a, ModifierButton b) noexcept {
        return static_cast<ModifierButton>(static_cast<std::underlying_type_t<ModifierButton>>(a) | static_cast<std::underlying_type_t<ModifierButton>>(b));
    }
 
    [[nodiscard]] inline constexpr ModifierButton operator+(ModifierButton a, ModifierButton b) noexcept {
        return static_cast<ModifierButton>(static_cast<std::underlying_type_t<ModifierButton>>(a) | static_cast<std::underlying_type_t<ModifierButton>>(b));
    }
 
    inline constexpr ModifierButton operator+=(ModifierButton& a, const ModifierButton b) noexcept { return a = (a + b); }
 
    [[nodiscard]] inline constexpr ModifierButton operator-(ModifierButton a, ModifierButton b) noexcept {
        return static_cast<ModifierButton>(static_cast<std::underlying_type_t<ModifierButton>>(a) & // NOLINT
            ~static_cast<std::underlying_type_t<ModifierButton>>(b));
    }
 
    inline constexpr ModifierButton operator-=(ModifierButton& a, const ModifierButton b) noexcept { return a = (a - b); }
 
    [[nodiscard]] StringView toString(Button button) noexcept;
 
    [[nodiscard]] Button button(const StringView& str) noexcept;
 
    [[nodiscard]] String toString(ModifierButton modifier) noexcept;
 
    enum class CE_SCRIPT_EXPORT() Axis : UInt8 {
        MouseVertical,
 
        MouseHorizontal,
 
        MouseScrollVertical,
 
        MouseScrollHorizontal,
 
        Unknown = std::numeric_limits<UInt8>::max()
    };
 
    [[nodiscard]] StringView toString(Axis axis) noexcept;
 
    [[nodiscard]] Axis axis(const StringView& str) noexcept;
 
    enum class CursorMode {
        Normal,
 
        Hidden,
 
        Captured
    };
 
} // namespace CeresEngine