carb/input/InputTypes.h

File members: carb/input/InputTypes.h

// Copyright (c) 2018-2023, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//

#pragma once
#include "../Types.h"

namespace carb
{
namespace input
{

struct InputDevice DOXYGEN_EMPTY_CLASS;
struct Keyboard DOXYGEN_EMPTY_CLASS;
struct Mouse DOXYGEN_EMPTY_CLASS;
struct Gamepad DOXYGEN_EMPTY_CLASS;

typedef uint32_t SubscriptionId;

constexpr SubscriptionId kInvalidSubscriptionId{};

using SubscriptionOrder = int32_t;

static constexpr SubscriptionOrder kSubscriptionOrderFirst = 0;
static constexpr SubscriptionOrder kSubscriptionOrderLast = -1;
static constexpr SubscriptionOrder kSubscriptionOrderDefault = kSubscriptionOrderLast;

#ifndef DOXYGEN_BUILD
enum class EventType : uint32_t
{
    eUnknown
};
#endif

typedef uint32_t EventTypeMask;
static constexpr EventTypeMask kEventTypeAll = EventTypeMask(-1);

typedef uint32_t ButtonFlags;
const uint32_t kButtonFlagTransitionUp = 1;
const uint32_t kButtonFlagStateUp = (1 << 1);
const uint32_t kButtonFlagTransitionDown = (1 << 2);
const uint32_t kButtonFlagStateDown = (1 << 3);

enum class DeviceType
{
    eKeyboard,
    eMouse,
    eGamepad,
    eCount,
    eUnknown = eCount
};

typedef uint32_t KeyboardModifierFlags;
const uint32_t kKeyboardModifierFlagShift = 1 << 0;
const uint32_t kKeyboardModifierFlagControl = 1 << 1;
const uint32_t kKeyboardModifierFlagAlt = 1 << 2;
const uint32_t kKeyboardModifierFlagSuper = 1 << 3;
const uint32_t kKeyboardModifierFlagCapsLock = 1 << 4;
const uint32_t kKeyboardModifierFlagNumLock = 1 << 5;
const uint32_t kKeyboardModifierFlagCount = 6;

enum class KeyboardEventType
{
    eKeyPress,
    eKeyRepeat,
    eKeyRelease,
    eChar,

    // Must always be last
    eCount
};

typedef uint32_t InputType;

enum class KeyboardInput : InputType
{
    eUnknown,
    eSpace,
    eApostrophe,
    eComma,
    eMinus,
    ePeriod,
    eSlash,
    eKey0,
    eKey1,
    eKey2,
    eKey3,
    eKey4,
    eKey5,
    eKey6,
    eKey7,
    eKey8,
    eKey9,
    eSemicolon,
    eEqual,
    eA,
    eB,
    eC,
    eD,
    eE,
    eF,
    eG,
    eH,
    eI,
    eJ,
    eK,
    eL,
    eM,
    eN,
    eO,
    eP,
    eQ,
    eR,
    eS,
    eT,
    eU,
    eV,
    eW,
    eX,
    eY,
    eZ,
    eLeftBracket,
    eBackslash,
    eRightBracket,
    eGraveAccent,
    eEscape,
    eTab,
    eEnter,
    eBackspace,
    eInsert,
    eDel,
    eRight,
    eLeft,
    eDown,
    eUp,
    ePageUp,
    ePageDown,
    eHome,
    eEnd,
    eCapsLock,
    eScrollLock,
    eNumLock,
    ePrintScreen,
    ePause,
    eF1,
    eF2,
    eF3,
    eF4,
    eF5,
    eF6,
    eF7,
    eF8,
    eF9,
    eF10,
    eF11,
    eF12,
    eNumpad0,
    eNumpad1,
    eNumpad2,
    eNumpad3,
    eNumpad4,
    eNumpad5,
    eNumpad6,
    eNumpad7,
    eNumpad8,
    eNumpad9,
    eNumpadDel,
    eNumpadDivide,
    eNumpadMultiply,
    eNumpadSubtract,
    eNumpadAdd,
    eNumpadEnter,
    eNumpadEqual,
    eLeftShift,
    eLeftControl,
    eLeftAlt,
    eLeftSuper,
    eRightShift,
    eRightControl,
    eRightAlt,
    eRightSuper,
    eMenu,

    eCount
};

const uint32_t kCharacterMaxNumBytes = 4;

struct KeyboardEvent
{
    union
    {
        Keyboard* keyboard;
        InputDevice* device;
    };

    KeyboardEventType type;
    union
    {
        KeyboardInput key;
        InputType inputType;

        char character[kCharacterMaxNumBytes];
    };

    KeyboardModifierFlags modifiers;
};

enum class MouseEventType
{
    eLeftButtonDown,
    eLeftButtonUp,
    eMiddleButtonDown,
    eMiddleButtonUp,
    eRightButtonDown,
    eRightButtonUp,
    eMove,
    eScroll,

    // Must always be last
    eCount
};

struct MouseEvent
{
    union
    {
        Mouse* mouse;
        InputDevice* device;
    };

    MouseEventType type;
    union
    {
        Float2 normalizedCoords;
        Float2 scrollDelta;
    };
    KeyboardModifierFlags modifiers;
    Float2 pixelCoords;
};

enum class MouseInput : InputType
{
    eLeftButton,
    eRightButton,
    eMiddleButton,
    eForwardButton,
    eBackButton,
    eScrollRight,
    eScrollLeft,
    eScrollUp,
    eScrollDown,
    eMoveRight,
    eMoveLeft,
    eMoveUp,
    eMoveDown,

    eCount
};

enum class GamepadInput : InputType
{
    eLeftStickRight,
    eLeftStickLeft,
    eLeftStickUp,
    eLeftStickDown,
    eRightStickRight,
    eRightStickLeft,
    eRightStickUp,
    eRightStickDown,
    eLeftTrigger,
    eRightTrigger,
    eA,
    eB,
    eX,
    eY,
    eLeftShoulder,
    eRightShoulder,
    eMenu1,
    eMenu2,
    eLeftStick,
    eRightStick,
    eDpadUp,
    eDpadRight,
    eDpadDown,
    eDpadLeft,

    eCount
};

struct GamepadEvent
{
    union
    {
        Gamepad* gamepad;
        InputDevice* device;
    };
    union
    {
        GamepadInput input;
        InputType inputType;
    };
    float value;
};

enum class GamepadConnectionEventType
{
    eCreated,
    eConnected,
    eDisconnected,
    eDestroyed
};

struct GamepadConnectionEvent
{
    union
    {
        Gamepad* gamepad;
        InputDevice* device;
    };
    GamepadConnectionEventType type;
};

struct InputEvent
{
    DeviceType deviceType;
    union
    {
        KeyboardEvent keyboardEvent;
        MouseEvent mouseEvent;
        GamepadEvent gamepadEvent;
        InputDevice* device;
    };
};

struct ActionMappingDesc
{
    DeviceType deviceType;
    union
    {
        Keyboard* keyboard;
        Mouse* mouse;
        Gamepad* gamepad;
        InputDevice* device;
    };
    union
    {
        KeyboardInput keyboardInput;
        MouseInput mouseInput;
        GamepadInput gamepadInput;
        InputType inputType;
    };
    KeyboardModifierFlags modifiers;
};

struct ActionEvent
{
    const char* action;
    float value;
    ButtonFlags flags;
};

typedef bool (*OnActionEventFn)(const ActionEvent& evt, void* userData);

typedef bool (*OnKeyboardEventFn)(const KeyboardEvent& evt, void* userData);

typedef bool (*OnMouseEventFn)(const MouseEvent& evt, void* userData);

typedef bool (*OnGamepadEventFn)(const GamepadEvent& evt, void* userData);

typedef void (*OnGamepadConnectionEventFn)(const GamepadConnectionEvent& evt, void* userData);

typedef bool (*OnInputEventFn)(const InputEvent& evt, void* userData);

enum class FilterResult : uint8_t
{
    eRetain = 0,

    eConsume = 1,
};

typedef FilterResult (*InputEventFilterFn)(InputEvent& evt, void* userData);

const char* const kAnyDevice = nullptr;

} // namespace input
} // namespace carb