Source repositoryvirtualhid_input.h

Go to the documentation of this file.

#pragma once
 
// standard includes
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <string_view>
#include <vector>
 
// lib includes
#include <libvirtualhid/libvirtualhid.hpp>
 
// local includes
#include "src/platform/common.h"
 
namespace platf::virtualhid {

  struct input_context_t {
    input_context_t();

    explicit input_context_t(lvh::BackendKind backend);

    void refresh_keyboard();

    void refresh_mouse();

    void refresh_mouse(const lvh::PointerViewport &desktop, const lvh::PointerViewport &viewport);

    void update_mouse_viewport(const touch_port_t &touch_port);
 
    std::unique_ptr<lvh::Runtime> runtime;  
    std::unique_ptr<lvh::Keyboard> keyboard;  
    std::unique_ptr<lvh::Mouse> mouse;  
    lvh::PointerViewport mouse_desktop;  
    lvh::PointerViewport mouse_viewport;  
    std::vector<std::shared_ptr<struct gamepad_context_t>> gamepads {static_cast<std::size_t>(MAX_GAMEPADS)};  
  };

  struct client_context_t {
    explicit client_context_t(input_context_t &input);
 
    input_context_t *global = nullptr;  
    std::unique_ptr<lvh::Touchscreen> touch;  
    std::unique_ptr<lvh::PenTablet> pen;  
    std::set<std::int32_t> active_touches;  
    std::set<lvh::PenButton> pressed_pen_buttons;  
  };

  input_context_t &get_input_context(input_t &input);

  client_context_t &get_client_context(client_input_t *input);

  std::unique_ptr<lvh::Runtime> create_runtime(lvh::BackendKind backend = lvh::BackendKind::platform_default);

  std::vector<supported_gamepad_t> static_supported_gamepads();

  std::vector<supported_gamepad_t> supported_gamepads(
    lvh::Runtime *runtime,
    bool fallback_vigem_available = false,
    bool virtualhid_licensed = true,
    bool require_license = false
  );

  bool should_use_gamepad_runtime(
    const lvh::BackendCapabilities &capabilities,
    std::string_view gamepad_driver,
    bool virtualhid_licensed
  );

  bool should_try_vigembus_fallback(
    std::string_view configured_gamepad,
    bool virtualhid_selected,
    std::string_view gamepad_driver
  );

  int alloc_gamepad(input_context_t &context, const gamepad_id_t &id, const gamepad_arrival_t &metadata, feedback_queue_t feedback_queue);

  int rebind_gamepad(input_context_t &context, const gamepad_id_t &id, feedback_queue_t feedback_queue);

  bool has_gamepad(const input_context_t &context, int nr);
 
#ifdef SUNSHINE_TESTS
  lvh::GamepadStateAdapter *gamepad_adapter_for_testing(input_context_t &context, int nr);
#endif

  void free_gamepad(input_context_t &context, int nr);

  void gamepad_update(input_context_t &context, int nr, const gamepad_state_t &state);

  void gamepad_touch(input_context_t &context, const gamepad_touch_t &touch);

  void gamepad_motion(input_context_t &context, const gamepad_motion_t &motion);

  void gamepad_battery(input_context_t &context, const gamepad_battery_t &battery);

  void move_mouse(input_context_t &context, int delta_x, int delta_y);

  void move_mouse(input_context_t &context, const touch_port_t &touch_port, int delta_x, int delta_y);

  void abs_mouse(input_context_t &context, const touch_port_t &touch_port, float x, float y);

  void button_mouse(input_context_t &context, int button, bool release);

  void scroll(input_context_t &context, int high_res_distance);

  void hscroll(input_context_t &context, int high_res_distance);

  void keyboard_update(input_context_t &context, std::uint16_t modcode, bool release, std::uint8_t flags, bool extended = false);

  void unicode(input_context_t &context, const char *utf8, int size);

  void touch_update(client_context_t &context, const touch_port_t &touch_port, const touch_input_t &touch);

  void pen_update(client_context_t &context, const touch_port_t &touch_port, const pen_input_t &pen);

  bool configured_gamepad_supports_touchpad();

  bool configured_gamepad_supports_controller_extensions();
 
}  // namespace platf::virtualhid