input.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <vpadbase/base.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct VPADAccStatus VPADAccStatus;
typedef struct VPADDirection VPADDirection;
typedef struct VPADGyroStatus VPADGyroStatus;
typedef struct VPADStatus VPADStatus;
typedef struct VPADTouchCalibrationParam VPADTouchCalibrationParam;
typedef struct VPADTouchData VPADTouchData;
typedef struct VPADVec2D VPADVec2D;
typedef struct VPADVec3D VPADVec3D;
 
typedef enum VPADButtons
{
   VPAD_BUTTON_A                 = 0x8000,
   VPAD_BUTTON_B                 = 0x4000,
   VPAD_BUTTON_X                 = 0x2000,
   VPAD_BUTTON_Y                 = 0x1000,
   VPAD_BUTTON_LEFT              = 0x0800,
   VPAD_BUTTON_RIGHT             = 0x0400,
   VPAD_BUTTON_UP                = 0x0200,
   VPAD_BUTTON_DOWN              = 0x0100,
   VPAD_BUTTON_ZL                = 0x0080,
   VPAD_BUTTON_ZR                = 0x0040,
   VPAD_BUTTON_L                 = 0x0020,
   VPAD_BUTTON_R                 = 0x0010,
   VPAD_BUTTON_PLUS              = 0x0008,
   VPAD_BUTTON_MINUS             = 0x0004,
   VPAD_BUTTON_HOME              = 0x0002,
   VPAD_BUTTON_SYNC              = 0x0001,
   VPAD_BUTTON_STICK_R           = 0x00020000,
   VPAD_BUTTON_STICK_L           = 0x00040000,
   VPAD_BUTTON_TV                = 0x00010000,
   VPAD_STICK_R_EMULATION_LEFT   = 0x04000000,
   VPAD_STICK_R_EMULATION_RIGHT  = 0x02000000,
   VPAD_STICK_R_EMULATION_UP     = 0x01000000,
   VPAD_STICK_R_EMULATION_DOWN   = 0x00800000,
   VPAD_STICK_L_EMULATION_LEFT   = 0x40000000,
   VPAD_STICK_L_EMULATION_RIGHT  = 0x20000000,
   VPAD_STICK_L_EMULATION_UP     = 0x10000000,
   VPAD_STICK_L_EMULATION_DOWN   = 0x08000000,
} VPADButtons;
 
typedef enum VPADTouchPadValidity
{
   VPAD_VALID                    = 0x0,
 
   VPAD_INVALID_X                = 0x1,
 
   VPAD_INVALID_Y                = 0x2,
} VPADTouchPadValidity;
 
typedef enum VPADTouchPadResolution
{
   VPAD_TP_1920X1080             = 0,
   VPAD_TP_1280X720              = 1,
   VPAD_TP_854X480               = 2,
} VPADTouchPadResolution;
 
typedef enum VPADReadError
{
   VPAD_READ_SUCCESS             = 0,
   VPAD_READ_NO_SAMPLES          = -1,
   VPAD_READ_INVALID_CONTROLLER  = -2,
   VPAD_READ_BUSY                = -4,
   VPAD_READ_UNINITIALIZED       = -5,
} VPADReadError;
 
typedef enum VPADLcdMode
{
   VPAD_LCD_STANDBY              = 0,
   VPAD_LCD_OFF                  = 1,
   VPAD_LCD_ON                   = 0xFF,
} VPADLcdMode;
 
typedef enum VPADGyroZeroDriftMode
{
   VPAD_GYRO_ZERODRIFT_LOOSE     = 0,
   VPAD_GYRO_ZERODRIFT_STANDARD,
   VPAD_GYRO_ZERODRIFT_TIGHT,
   VPAD_GYRO_ZERODRIFT_NONE
} VPADGyroZeroDriftMode;
 
struct VPADVec2D
{
   float x;
   float y;
};
WUT_CHECK_OFFSET(VPADVec2D, 0x00, x);
WUT_CHECK_OFFSET(VPADVec2D, 0x04, y);
WUT_CHECK_SIZE(VPADVec2D, 0x08);
 
struct VPADVec3D
{
   float x;
   float y;
   float z;
};
WUT_CHECK_OFFSET(VPADVec3D, 0x00, x);
WUT_CHECK_OFFSET(VPADVec3D, 0x04, y);
WUT_CHECK_OFFSET(VPADVec3D, 0x08, z);
WUT_CHECK_SIZE(VPADVec3D, 0x0C);
 
struct VPADDirection
{
   VPADVec3D x;
   VPADVec3D y;
   VPADVec3D z;
};
WUT_CHECK_OFFSET(VPADDirection, 0x00, x);
WUT_CHECK_OFFSET(VPADDirection, 0x0C, y);
WUT_CHECK_OFFSET(VPADDirection, 0x18, z);
WUT_CHECK_SIZE(VPADDirection, 0x24);
 
struct VPADTouchCalibrationParam
{
   uint16_t adjustX;
   uint16_t adjustY;
   float scaleX;
   float scaleY;
};
WUT_CHECK_OFFSET(VPADTouchCalibrationParam, 0x00, adjustX);
WUT_CHECK_OFFSET(VPADTouchCalibrationParam, 0x02, adjustY);
WUT_CHECK_OFFSET(VPADTouchCalibrationParam, 0x04, scaleX);
WUT_CHECK_OFFSET(VPADTouchCalibrationParam, 0x08, scaleY);
WUT_CHECK_SIZE(VPADTouchCalibrationParam, 0x0C);
 
struct VPADTouchData
{
   uint16_t x;
   uint16_t y;
 
   uint16_t touched;
 
   uint16_t validity;
};
WUT_CHECK_OFFSET(VPADTouchData, 0x00, x);
WUT_CHECK_OFFSET(VPADTouchData, 0x02, y);
WUT_CHECK_OFFSET(VPADTouchData, 0x04, touched);
WUT_CHECK_OFFSET(VPADTouchData, 0x06, validity);
WUT_CHECK_SIZE(VPADTouchData, 0x08);
 
struct VPADAccStatus
{
   VPADVec3D acc;
   float magnitude;
   float variation;
   VPADVec2D vertical;
};
WUT_CHECK_OFFSET(VPADAccStatus, 0x00, acc);
WUT_CHECK_OFFSET(VPADAccStatus, 0x0C, magnitude);
WUT_CHECK_OFFSET(VPADAccStatus, 0x10, variation);
WUT_CHECK_OFFSET(VPADAccStatus, 0x14, vertical);
WUT_CHECK_SIZE(VPADAccStatus, 0x1c);
 
struct VPADStatus
{
   uint32_t hold;
 
   uint32_t trigger;
 
   uint32_t release;
 
   VPADVec2D leftStick;
 
   VPADVec2D rightStick;
 
   VPADAccStatus accelorometer;
 
   VPADVec3D gyro;
 
   VPADVec3D angle;
 
   uint8_t error;
 
   WUT_UNKNOWN_BYTES(0x01);
 
   VPADTouchData tpNormal;
 
   VPADTouchData tpFiltered1;
 
   VPADTouchData tpFiltered2;
 
   WUT_UNKNOWN_BYTES(0x02);
 
   VPADDirection direction;
 
   BOOL usingHeadphones;
 
   VPADVec3D mag;
 
   uint8_t slideVolume;
 
   uint8_t battery;
 
   uint8_t micStatus;
 
   uint8_t slideVolumeEx;
 
   WUT_UNKNOWN_BYTES(0x8);
};
WUT_CHECK_OFFSET(VPADStatus, 0x00, hold);
WUT_CHECK_OFFSET(VPADStatus, 0x04, trigger);
WUT_CHECK_OFFSET(VPADStatus, 0x08, release);
WUT_CHECK_OFFSET(VPADStatus, 0x0C, leftStick);
WUT_CHECK_OFFSET(VPADStatus, 0x14, rightStick);
WUT_CHECK_OFFSET(VPADStatus, 0x1C, accelorometer);
WUT_CHECK_OFFSET(VPADStatus, 0x38, gyro);
WUT_CHECK_OFFSET(VPADStatus, 0x44, angle);
WUT_CHECK_OFFSET(VPADStatus, 0x50, error);
WUT_CHECK_OFFSET(VPADStatus, 0x52, tpNormal);
WUT_CHECK_OFFSET(VPADStatus, 0x5A, tpFiltered1);
WUT_CHECK_OFFSET(VPADStatus, 0x62, tpFiltered2);
WUT_CHECK_OFFSET(VPADStatus, 0x6C, direction);
WUT_CHECK_OFFSET(VPADStatus, 0x94, mag);
WUT_CHECK_OFFSET(VPADStatus, 0xA0, slideVolume);
WUT_CHECK_OFFSET(VPADStatus, 0xA1, battery);
WUT_CHECK_OFFSET(VPADStatus, 0xA2, micStatus);
WUT_CHECK_OFFSET(VPADStatus, 0xA3, slideVolumeEx);
WUT_CHECK_SIZE(VPADStatus, 0xAC);
 
typedef void(*VPADSamplingCallback)(VPADChan chan);
 
void
VPADInit();
 
void
VPADShutdown();
 
int32_t
VPADRead(VPADChan chan,
         VPADStatus *buffers,
         uint32_t count,
         VPADReadError *outError);
 
void
VPADGetTPCalibrationParam(VPADChan chan,
                          VPADTouchCalibrationParam *outParam);
 
void
VPADSetTPCalibrationParam(VPADChan chan,
                          const VPADTouchCalibrationParam *param);
 
void
VPADGetTPCalibratedPoint(VPADChan chan,
                         VPADTouchData *calibratedData,
                         const VPADTouchData *uncalibratedData);
 
void
VPADGetTPCalibratedPointEx(VPADChan chan,
                           VPADTouchPadResolution tpResolution,
                           VPADTouchData *calibratedData,
                           const VPADTouchData *uncalibratedData);
 
void
VPADSetAccParam(VPADChan chan,
                float playRadius,
                float sensitivity);
 
void
VPADGetAccParam(VPADChan chan,
                float *outPlayRadius,
                float *outSensitivity);
 
void
VPADSetBtnRepeat(VPADChan chan,
                 float delaySec,
                 float pulseSec);
 
void
VPADEnableStickCrossClamp(VPADChan chan);
 
void
VPADDisableStickCrossClamp(VPADChan chan);
 
void
VPADSetLStickClampThreshold(VPADChan chan,
                            int32_t max,
                            int32_t min);
 
void
VPADSetRStickClampThreshold(VPADChan chan,
                            int32_t max,
                            int32_t min);
 
void
VPADGetGyroDirReviseParam(VPADChan chan,
                          float *param);
 
void
VPADGetGyroZeroDriftMode(VPADChan chan,
                         VPADGyroZeroDriftMode *mode);
 
void
VPADGetLStickClampThreshold(VPADChan chan,
                            int32_t *max,
                            int32_t *min);
 
void
VPADGetRStickClampThreshold(VPADChan chan,
                            int32_t *max,
                            int32_t *min);
 
void
VPADSetStickOrigin(VPADChan chan);
 
void
VPADDisableLStickZeroClamp(VPADChan chan);
 
void
VPADDisableRStickZeroClamp(VPADChan chan);
 
void
VPADEnableLStickZeroClamp(VPADChan chan);
 
void
VPADEnableRStickZeroClamp(VPADChan chan);
 
void
VPADSetCrossStickEmulationParamsL(VPADChan chan,
                                  float rotationDegree,
                                  float range,
                                  float radius);
 
void
VPADSetCrossStickEmulationParamsR(VPADChan chan,
                                  float rotationDegree,
                                  float range,
                                  float radius);
 
void
VPADGetCrossStickEmulationParamsL(VPADChan chan,
                                  float *outRotationDegree,
                                  float *outRange,
                                  float *outRadius);
 
void
VPADGetCrossStickEmulationParamsR(VPADChan chan,
                                  float *outRotationDegree,
                                  float *outRange,
                                  float *outRadius);
 
void
VPADSetGyroAngle(VPADChan chan,
                 float ax,
                 float ay,
                 float az);
 
void
VPADSetGyroDirReviseBase(VPADChan chan,
                         VPADDirection *base);
 
void
VPADSetGyroDirReviseParam(VPADChan chan,
                          float param);
 
void
VPADSetGyroDirection(VPADChan chan,
                     VPADDirection *dir);
 
void
VPADSetGyroDirectionMag(VPADChan chan,
                        float mag);
 
void
VPADSetGyroMagnification(VPADChan chan,
                         float pitch,
                         float yaw,
                         float roll);
 
void
VPADSetGyroZeroDriftMode(VPADChan chan,
                         VPADGyroZeroDriftMode mode);
 
void
VPADEnableGyroZeroPlay(VPADChan chan);
 
void
VPADEnableGyroDirRevise(VPADChan chan);
 
void
VPADEnableGyroAccRevise(VPADChan chan);
 
void
VPADDisableGyroZeroPlay(VPADChan chan);
 
void
VPADDisableGyroDirRevise(VPADChan chan);
 
void
VPADDisableGyroAccRevise(VPADChan chan);
 
 
float
VPADIsEnableGyroZeroPlay(VPADChan chan);
 
float
VPADIsEnableGyroZeroDrift(VPADChan chan);
 
float
VPADIsEnableGyroDirRevise(VPADChan chan);
 
float
VPADIsEnableGyroAccRevise(VPADChan chan);
 
void
VPADSetGyroZeroPlayParam(VPADChan chan,
                         float radius);
 
void
VPADInitGyroZeroPlayParam(VPADChan chan);
 
void
VPADInitGyroDirReviseParam(VPADChan chan);
 
void
VPADInitGyroAccReviseParam(VPADChan chan);
 
void
VPADStartGyroMagRevise(VPADChan chan);
 
void
VPADStopGyroMagRevise(VPADChan chan);
 
void
VPADInitGyroZeroDriftMode(VPADChan chan);
 
BOOL
VPADGetTVMenuStatus(VPADChan chan);
 
void
VPADSetTVMenuInvalid(VPADChan chan,
                     BOOL invalid);
 
void
VPADDisablePowerButton(VPADChan chan);
 
void
VPADEnablePowerButton(VPADChan chan);
 
int32_t
VPADControlMotor(VPADChan chan,
                 uint8_t *pattern,
                 uint8_t length);
 
void
VPADStopMotor(VPADChan chan);
 
int32_t
VPADSetLcdMode(VPADChan chan,
               VPADLcdMode lcdMode);
 
int32_t
VPADGetLcdMode(VPADChan chan,
               VPADLcdMode *outLcdMode);
 
int32_t
VPADSetSensorBar(VPADChan chan,
                 BOOL on);
 
VPADSamplingCallback
VPADSetSamplingCallback(VPADChan chan,
                        VPADSamplingCallback callback);
 
BOOL
VPADGetButtonProcMode(VPADChan chan);
 
#ifdef __cplusplus
}
#endif