input.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
 
#include <rex/assert.h>
#include <rex/types.h>
#include <rex/result.h>
#include <rex/kernel/types/status.h>
 
namespace rex::xam {

constexpr i32 kXInputGamepadLeftThumbDeadzone = 7849;
constexpr i32 kXInputGamepadRightThumbDeadzone = 8689;
constexpr u8 kXInputGamepadTriggerThreshold = 30;
 
enum X_INPUT_CAPS : u8 {
  kXInputCapsFFBSupported = 0x0001,
  kXInputCapsWireless = 0x0002, 
  kXInputCapsVoiceSupported = 0x0004,
  kXInputCapsPMDSupported = 0x0008,
  kXInputCapsNoNavigation = 0x0010,
};
 
enum X_INPUT_DEVTYPE : u8 {
  kXInputDevTypeGamepad = 0x00000001,
  kXInputDevTypeKeyboard = 0x00000002,
};
 
enum X_INPUT_DEVSUBTYPE : u8 {
  kXInputDevSubtypeUSBKeyboard = 0x00000000,
  kXInputDevSubtypeGamepad = 0x00000001,
  kXInputDevSubtypeWheel = 0x00000002,
  kXInputDevSubtypeArcadeStick = 0x00000003,
  kXInputDevSubtypeFlightStick = 0x00000004,
  kXInputDevSubtypeDancePad = 0x00000005,
  kXInputDevSubtypeGuitar = 0x00000006,
  kXInputDevSubtypeGuitarAlternate = 0x00000007,
  kXInputDevSubtypeDrumKit = 0x00000008,
  kXInputDevSubtypeGuitarBass = 0x0000000B,
  kXInputDevSubtypeArcadePad = 0x00000013, 
};
 
enum X_INPUT_FLAG {
  kXInputFlagGamepad = 0x00000001,   
  kXInputFlagKeyboard = 0x00000002,  
  kXInputFlagUnknown = 0x00000004,   
  kXInputFlagUnknown2 = 0x00000008,  
  kXInputFlagMic = 0x00000020,       
  kXInputFlagAnyDevice = 0x000000FF, 
  kXInputFlagAnyUser = 1 << 30,      
};
 
enum X_INPUT_GAMEPAD_BUTTON : u16 {
  kXInputGamepadDPadUp = 0x0001,
  kXInputGamepadDPadDown = 0x0002,
  kXInputGamepadDPadLeft = 0x0004,
  kXInputGamepadDPadRight = 0x0008,
  kXInputGamepadStart = 0x0010,
  kXInputGamepadBack = 0x0020,
  kXInputGamepadLeftThumb = 0x0040,
  kXInputGamepadRightThumb = 0x0080,
  kXInputGamepadLeftShoulder = 0x0100,
  kXInputGamepadRightShoulder = 0x0200,
  kXInputGamepadGuide = 0x0400,
  kXInputGamepadA = 0x1000,
  kXInputGamepadB = 0x2000,
  kXInputGamepadX = 0x4000,
  kXInputGamepadY = 0x8000,
};
 
enum X_INPUT_KEYSTROKE_FLAGS : u16 {
  kXInputKeystrokeKeyDown = 0x0001, 
  kXInputKeystrokeKeyUp = 0x0002,   
  kXInputKeystrokeRepeat = 0x0004,  
  kXInputKeystrokeShift = 0x0008,   
  kXInputKeystrokeCtrl = 0x0010,    
  kXInputKeystrokeAlt = 0x0020,     
  kXInputKeystrokeValidUnicode = 0x1000,
};
 
struct X_INPUT_GAMEPAD {
  be_u16 buttons;   
  u8 left_trigger;  
  u8 right_trigger; 
  be_i16 thumb_lx;  
  be_i16 thumb_ly;  
  be_i16 thumb_rx;  
  be_i16 thumb_ry;  
};
REX_STATIC_ASSERT_SIZE(X_INPUT_GAMEPAD, 12);
 
struct X_INPUT_STATE {
  be_u32 packet_number;
  X_INPUT_GAMEPAD gamepad;
};
REX_STATIC_ASSERT_SIZE(X_INPUT_STATE, sizeof(X_INPUT_GAMEPAD) + 4);
 
struct X_INPUT_VIBRATION {
  be_u16 left_motor_speed;
  be_u16 right_motor_speed;
};
REX_STATIC_ASSERT_SIZE(X_INPUT_VIBRATION, 4);
 
struct X_INPUT_CAPABILITIES {
  u8 type;                     
  u8 sub_type;                 
  be_u16 flags;                
  X_INPUT_GAMEPAD gamepad;     
  X_INPUT_VIBRATION vibration; 
};
REX_STATIC_ASSERT_SIZE(X_INPUT_CAPABILITIES,
                       sizeof(X_INPUT_GAMEPAD) + sizeof(X_INPUT_VIBRATION) + 4);

struct X_INPUT_KEYSTROKE {
  be_u16 virtual_key; 
  be_u16 unicode;     
  be_u16 flags;       
  u8 user_index;      
  u8 hid_code;        
};
REX_STATIC_ASSERT_SIZE(X_INPUT_KEYSTROKE, 8);
 
}  // namespace rex::xam
 
namespace rex::xam {
 
enum class HIDError : u8 {
  kNotConnected = 1, 
  kEmpty = 2,        
  kBadArguments = 3,
  kFailed = 4,
};

[[nodiscard]] inline rex::Error BuildError(HIDError code, std::string message) {
  return {ErrorCategory::kPlatform, std::move(message), static_cast<int>(code)};
}

[[nodiscard]] inline HIDError CodeOf(const rex::Error& error) {
  return static_cast<HIDError>(error.code);
}

[[nodiscard]] inline HIDError ToHIDError(rex::kernel::X_RESULT result) {
  switch (result) {
    case rex::kernel::X_ERROR_DEVICE_NOT_CONNECTED:
      return HIDError::kNotConnected;
    case rex::kernel::X_ERROR_EMPTY:
      return HIDError::kEmpty;
    case rex::kernel::X_ERROR_BAD_ARGUMENTS:
      return HIDError::kBadArguments;
    default:
      return HIDError::kFailed;
  }
}

[[nodiscard]] inline rex::kernel::X_RESULT ToXResult(HIDError code) {
  switch (code) {
    case HIDError::kNotConnected:
      return rex::kernel::X_ERROR_DEVICE_NOT_CONNECTED;
    case HIDError::kEmpty:
      return rex::kernel::X_ERROR_EMPTY;
    case HIDError::kBadArguments:
      return rex::kernel::X_ERROR_BAD_ARGUMENTS;
    case HIDError::kFailed:
      break;
  }
  return rex::kernel::X_ERROR_FUNCTION_FAILED;
}
 
}  // namespace rex::xam