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