types.hpp

Go to the documentation of this file.

 
#pragma once
 
// standard includes
#include <array>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <vector>
 
namespace lvh {
 
  using DeviceId = std::uint64_t;
 
  enum class ErrorCode {
    ok,  
    invalid_argument,  
    backend_unavailable,  
    device_closed,  
    unsupported_profile,  
    backend_failure,  
  };
 
  class OperationStatus {
  public:
    OperationStatus();
 
    OperationStatus(ErrorCode code, std::string message);
 
    static OperationStatus success();
 
    static OperationStatus failure(ErrorCode code, std::string message);
 
    bool ok() const;
 
    ErrorCode code() const;
 
    const std::string &message() const;
 
  private:
    ErrorCode code_;
    std::string message_;
  };
 
  enum class BackendKind {
    fake,  
    platform_default,  
  };
 
  struct RuntimeOptions {
    BackendKind backend = BackendKind::fake;
  };
 
  struct BackendCapabilities {
    std::string backend_name;
 
    bool supports_virtual_hid = false;
 
    bool supports_gamepad = false;
 
    bool supports_keyboard = false;
 
    bool supports_mouse = false;
 
    bool supports_touchscreen = false;
 
    bool supports_trackpad = false;
 
    bool supports_pen_tablet = false;
 
    bool supports_output_reports = false;
 
    bool supports_xtest_fallback = false;
 
    bool requires_installed_driver = false;
  };
 
  enum class DeviceNodeKind {
    input_event,  
    joystick,  
    hidraw,  
    sysfs,  
    other,  
  };
 
  struct DeviceNode {
    DeviceNodeKind kind = DeviceNodeKind::other;
 
    std::string path;
  };
 
  enum class DeviceType {
    gamepad,  
    keyboard,  
    mouse,  
    touchscreen,  
    trackpad,  
    pen_tablet,  
  };
 
  enum class BusType {
    unknown,  
    usb,  
    bluetooth,  
  };
 
  enum class GamepadProfileKind {
    generic,  
    xbox_360,  
    xbox_one,  
    xbox_series,  
    dualsense,  
    switch_pro,  
    dualshock4,  
  };
 
  struct GamepadProfileCapabilities {
    bool supports_rumble = false;
 
    bool supports_motion = false;
 
    bool supports_touchpad = false;
 
    bool supports_rgb_led = false;
 
    bool supports_battery = false;
 
    bool supports_adaptive_triggers = false;
  };
 
  struct DeviceProfile {
    DeviceType device_type = DeviceType::gamepad;
 
    GamepadProfileKind gamepad_kind = GamepadProfileKind::generic;
 
    BusType bus_type = BusType::usb;
 
    std::uint16_t vendor_id = 0;
 
    std::uint16_t product_id = 0;
 
    std::uint16_t version = 0;
 
    std::uint8_t report_id = 1;
 
    std::size_t input_report_size = 0;
 
    std::size_t output_report_size = 0;
 
    std::string name;
 
    std::string manufacturer;
 
    GamepadProfileCapabilities capabilities;
 
    std::vector<std::uint8_t> report_descriptor;
  };
 
  enum class ClientControllerType {
    unknown,  
    xbox,  
    playstation,  
    nintendo,  
  };
 
  struct GamepadMetadata {
    int global_index = -1;
 
    int client_relative_index = -1;
 
    ClientControllerType client_type = ClientControllerType::unknown;
 
    bool has_motion_sensors = false;
 
    bool has_touchpad = false;
 
    bool has_rgb_led = false;
 
    bool has_battery = false;
 
    std::string stable_id;
  };
 
  struct CreateGamepadOptions {
    DeviceProfile profile;
 
    GamepadMetadata metadata;
  };
 
  struct CreateKeyboardOptions {
    DeviceProfile profile;
 
    std::uint32_t auto_repeat_interval_ms = 50;
 
    std::string stable_id;
  };
 
  struct CreateMouseOptions {
    DeviceProfile profile;
 
    std::string stable_id;
  };
 
  struct CreateTouchscreenOptions {
    DeviceProfile profile;
 
    std::string stable_id;
  };
 
  struct CreateTrackpadOptions {
    DeviceProfile profile;
 
    std::string stable_id;
  };
 
  struct CreatePenTabletOptions {
    DeviceProfile profile;
 
    std::string stable_id;
  };
 
  enum class GamepadButton : std::uint8_t {
    a = 0,  
    b,  
    x,  
    y,  
    back,  
    start,  
    guide,  
    left_stick,  
    right_stick,  
    left_shoulder,  
    right_shoulder,  
    dpad_up,  
    dpad_down,  
    dpad_left,  
    dpad_right,  
    misc1,  
    touchpad,  
  };
 
  class ButtonSet {
  public:
    void set(GamepadButton button, bool pressed = true);
 
    void reset(GamepadButton button);
 
    void clear();
 
    bool test(GamepadButton button) const;
 
    std::uint32_t raw_bits() const;
 
  private:
    std::uint32_t bits_ = 0;
  };
 
  struct Stick {
    float x = 0.0F;
 
    float y = 0.0F;
  };
 
  struct Vector3 {
    float x = 0.0F;
 
    float y = 0.0F;
 
    float z = 0.0F;
  };
 
  enum class GamepadBatteryState : std::uint8_t {
    unknown,  
    discharging,  
    charging,  
    full,  
    voltage_or_temperature_error,  
    temperature_error,  
    charging_error,  
  };
 
  struct GamepadBattery {
    GamepadBatteryState state = GamepadBatteryState::unknown;
 
    std::uint8_t percentage = 100;
  };
 
  struct GamepadTouchContact {
    std::uint8_t id = 0;
 
    bool active = false;
 
    float x = 0.0F;
 
    float y = 0.0F;
  };
 
  struct GamepadState {
    ButtonSet buttons;
 
    Stick left_stick;
 
    Stick right_stick;
 
    float left_trigger = 0.0F;
 
    float right_trigger = 0.0F;
 
    std::optional<Vector3> acceleration;
 
    std::optional<Vector3> gyroscope;
 
    std::optional<GamepadBattery> battery;
 
    std::array<GamepadTouchContact, 2> touchpad_contacts {};
  };
 
  using KeyboardKeyCode = std::uint16_t;
 
  struct KeyboardEvent {
    KeyboardKeyCode key_code = 0;
 
    bool pressed = false;
  };
 
  struct KeyboardTextEvent {
    std::string text;
  };
 
  enum class MouseButton : std::uint8_t {
    left = 0,  
    middle,  
    right,  
    side,  
    extra,  
  };
 
  enum class MouseEventKind {
    relative_motion,  
    absolute_motion,  
    button,  
    vertical_scroll,  
    horizontal_scroll,  
  };
 
  struct MouseEvent {
    MouseEventKind kind = MouseEventKind::relative_motion;
 
    std::int32_t x = 0;
 
    std::int32_t y = 0;
 
    std::int32_t width = 0;
 
    std::int32_t height = 0;
 
    MouseButton button = MouseButton::left;
 
    bool pressed = false;
 
    std::int32_t high_resolution_scroll = 0;
  };
 
  struct TouchContact {
    std::int32_t id = 0;
 
    float x = 0.0F;
 
    float y = 0.0F;
 
    float pressure = 0.0F;
 
    std::int32_t orientation = 0;
  };
 
  enum class PenToolType : std::uint8_t {
    pen,  
    eraser,  
    brush,  
    pencil,  
    airbrush,  
    touch,  
    unchanged,  
  };
 
  enum class PenButton : std::uint8_t {
    primary,  
    secondary,  
    tertiary,  
  };
 
  struct PenToolState {
    PenToolType tool = PenToolType::pen;
 
    float x = 0.0F;
 
    float y = 0.0F;
 
    float pressure = -1.0F;
 
    float distance = -1.0F;
 
    float tilt_x = 0.0F;
 
    float tilt_y = 0.0F;
  };
 
  enum class GamepadOutputKind {
    rumble,  
    rgb_led,  
    adaptive_triggers,  
    raw_report,  
  };
 
  struct GamepadOutput {
    GamepadOutputKind kind = GamepadOutputKind::raw_report;
 
    std::uint16_t low_frequency_rumble = 0;
 
    std::uint16_t high_frequency_rumble = 0;
 
    std::uint8_t red = 0;
 
    std::uint8_t green = 0;
 
    std::uint8_t blue = 0;
 
    std::uint8_t adaptive_trigger_flags = 0;
 
    std::uint8_t left_trigger_effect_type = 0;
 
    std::uint8_t right_trigger_effect_type = 0;
 
    std::array<std::uint8_t, 10> left_trigger_effect {};
 
    std::array<std::uint8_t, 10> right_trigger_effect {};
 
    std::vector<std::uint8_t> raw_report;
  };
 
  using OutputCallback = std::function<void(const GamepadOutput &)>;
 
}  // namespace lvh